PHP Mockery::spy方法代码示例

 public function testFindAll()
 {
     $repository = m::spy(TranslationRepository::class);
     $service = new TranslationService($repository);
     $service->findAll([]);
     $repository->shouldHaveReceived('getByCriteria')->with([])->once();
 }

 public function testAuthorisedConsumerLanguage()
 {
     $userConsumer = m::spy(ConsumerInterface::class);
     $this->consumerManager->set($userConsumer);
     $this->consumerManager->language();
     $userConsumer->shouldhaveReceived('language');
 }

 public function setUp()
 {
     parent::setUp();
     $this->illuminateDispatcher = m::spy('Illuminate\\Events\\Dispatcher');
     $this->logger = m::spy('Illuminate\\Log\\Writer');
     $this->dispatcher = new EventDispatcher($this->illuminateDispatcher, $this->logger);
 }

 /**
  * @test
  */
 function it_can_accept_arbitrary_query_vars()
 {
     $query = Mockery::spy(WP_User_Query::class);
     $builder = new QueryBuilder($query);
     $builder->set('count_total', false);
     $query->shouldHaveReceived('set')->with('count_total', false);
 }

 public function testWithCustomFieldName()
 {
     $mockQuery = m::spy('query');
     $filter = KeywordFilter::fromKeywords('keywords', 'title');
     $filter->applyToEloquent($mockQuery);
     $mockQuery->shouldHaveReceived('where')->with('title', 'LIKE', '%keywords%')->once();
 }

 public function testPluginsAreBooted()
 {
     $this->kernel->shouldReceive('getPlugins')->andReturn([$plugin1 = \Mockery::spy(PluginInterface::class), $plugin2 = \Mockery::spy(PluginInterface::class)]);
     new Application($this->kernel);
     $plugin1->shouldHaveReceived('boot')->once();
     $plugin2->shouldHaveReceived('boot')->once();
 }

 public function init()
 {
     $this->mockManager = m::spy('Eloquence\\Behaviours\\CountCache\\CountCacheManager');
     $this->observer = new CountCacheObserver();
     $this->observer->setManager($this->mockManager);
     $this->model = new RealModelStub();
 }

 public function setUp()
 {
     $this->emitter = \Mockery::spy(Emitter::class);
     $this->event = \Mockery::mock(EventInterface::class);
     $this->message = DomainMessage::recordNow(0, 0, new Metadata(), $this->event);
     $this->eventPublishingListener = new EventPublishingListener($this->emitter);
 }

 public function test_it_can_load_arbitrary_addons()
 {
     $stub = Mockery::spy(Addon::class);
     $repository = $this->app->make(AddonRepository::class);
     $repository->enableAddon($stub);
     $stub->shouldHaveReceived('enable')->once();
 }

 public function testFilterWithActiveValidAccount()
 {
     $mockRequest = m::spy('requestor');
     CurrentAccount::shouldReceive('determine')->once()->andReturn($this->mockAccount);
     CurrentAccount::shouldReceive('set')->once()->with($this->mockAccount);
     $this->middleware->handle($mockRequest, function () {
     });
 }

 public function testBuildWithCompilerPass()
 {
     $pass = \Mockery::mock('Symfony\\Component\\DependencyInjection\\Compiler\\CompilerPassInterface');
     $builder = \Mockery::spy(new ContainerBuilder());
     $this->plugin->shouldReceive('getCompilerPasses')->andReturn([$pass]);
     $this->plugin->build($builder);
     $builder->shouldHaveReceived('addCompilerPass')->once()->with($pass);
 }

 public function testAddNamespace()
 {
     $mockFileLoader = m::spy(FileLoader::class);
     $mockRepository = m::spy(TranslationRepositoryInterface::class);
     $translationLoader = new TranslationLoader($mockFileLoader, $mockRepository);
     $translationLoader->addNamespace('shift', 'shift');
     $mockFileLoader->shouldHaveReceived('addNamespace')->once()->with('shift', 'shift');
 }

 public function testSetsUpAssets()
 {
     $shiftAssetContainer = m::spy('assetContainer');
     Asset::shouldReceive('container')->once()->with('shift')->andReturn($shiftAssetContainer);
     $composer = new LayoutsInstallationComposer();
     $composer->compose();
     $shiftAssetContainer->shouldHaveReceived('add')->twice();
 }

 /**
  * @test
  */
 public function itVerifiesAMethodWasCalledWithSpecificArguments()
 {
     $spy = m::spy();
     $spy->myMethod(123, "a string");
     $spy->shouldHaveReceived("myMethod")->with(123, "a string");
     $spy->shouldHaveReceived("myMethod", array(123, "a string"));
     $this->setExpectedException("Mockery\\Exception\\InvalidCountException");
     $spy->shouldHaveReceived("myMethod")->with(123);
 }

 public function testEventTriggered()
 {
     $event = \Mockery::mock('Havvg\\Component\\Lifecycle\\Event\\EventInterface');
     $provider = \Mockery::mock('Havvg\\Component\\Lifecycle\\Event\\EventProviderInterface');
     $processor = \Mockery::spy('Havvg\\Component\\Lifecycle\\Event\\EventProcessorInterface');
     $lifecycle = new Lifecycle($provider, $processor);
     $lifecycle->onEventTriggered(new EventTriggeredEvent($event));
     $processor->shouldHaveReceived('process')->once()->with($event);
 }