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); }
/** * @depends testAddConsequence * @depends testIsArtifactAware */ public function testSettingArtifactAppliesToConsequences() { $artifact = \Mockery::mock('Havvg\\Component\\Lifecycle\\Artifact\\ArtifactInterface'); $consequence = \Mockery::spy('Havvg\\Component\\Lifecycle\\Consequence\\ConsequenceInterface, Havvg\\Component\\Lifecycle\\Artifact\\ArtifactAwareInterface'); $collection = new ConsequenceCollection(); $collection->addConsequence($consequence); $collection->setArtifact($artifact); $consequence->shouldHaveReceived('setArtifact')->once()->with($artifact); }
public function testAnEventDoesGetFiredWhenTheModelIsAPushable() { $dispatcher = m::spy(Dispatcher::class); $dispatcher->shouldReceive('fire')->times(5); $manager = new PushableManager($dispatcher); $manager->created(new DummyPushableModel()); $manager->updated(new DummyPushableModel()); $manager->deleted(new DummyPushableModel()); $manager->attached(new DummyPushableModel()); $manager->detached(new DummyPushableModel()); }
public function testSuccessfulRegistration() { $observer = m::spy(RegistrationObserverInterface::class); Recaptcha::shouldReceive('check')->once()->andReturn(true); $this->service->registerUser(['firstName' => 'Kirk', 'lastName' => 'Bushell', 'email' => '*****@*****.**', 'password' => '123456', 'password_confirmation' => '123456', 'g-recaptcha-response' => 'oiajsdlkjasdljksadf'], $observer); $user = $this->userRepository->getAll()->first(); // Assert $observer->shouldHaveReceived('onSuccess')->once(); $this->assertNotNull($user); $this->assertNotNull($user->confirmationToken); }
/** * @return Application */ private function getApplication() { if (!$this->application) { $app = new Application(); require __DIR__ . '/../../../app/app.php'; $app['logger'] = Mockery::spy('Psr\\Log\\LoggerInterface'); $app['debug'] = true; $this->application = $app; } return $this->application; }
/** * @depends testAddCondition * @depends testAddConsequence */ public function testSetArtifactOnConditionsAndConsequences() { $artifact = \Mockery::mock('Havvg\\Component\\Lifecycle\\Artifact\\ArtifactInterface'); $condition = \Mockery::spy('Havvg\\Component\\Lifecycle\\Condition\\ConditionInterface, Havvg\\Component\\Lifecycle\\Artifact\\ArtifactAwareInterface'); $consequence = \Mockery::spy('Havvg\\Component\\Lifecycle\\Consequence\\ConsequenceInterface, Havvg\\Component\\Lifecycle\\Artifact\\ArtifactAwareInterface'); $event = new Event(); $event->addCondition($condition); $event->addConsequence($consequence); $event->setArtifact($artifact); $condition->shouldHaveReceived('setArtifact')->once()->with($artifact); $consequence->shouldHaveReceived('setArtifact')->once()->with($artifact); }
/** * @depends testTriggerEvent */ public function testTriggerEventCollection() { $dispatcher = \Mockery::spy('Symfony\\Component\\EventDispatcher\\EventDispatcherInterface'); $event = \Mockery::mock('Havvg\\Component\\Lifecycle\\Event\\EventInterface'); $collection = new EventCollection(); $collection->addEvent($event); $trigger = new EventTrigger($dispatcher); $trigger->all($collection); $dispatcher->shouldHaveReceived('dispatch')->once()->with(LifecycleEvents::EVENT_TRIGGERED, \Mockery::on(function ($actual) use($event) { return PHPUnit::evaluate($actual, PHPUnit::isInstanceOf('Havvg\\Component\\Lifecycle\\Event\\Runtime\\EventTriggeredEvent')) && PHPUnit::evaluate($actual->getEvent(), PHPUnit::equalTo($event)); })); }
public function testCommandHandling() { $repository = m::spy(UserRepositoryInterface::class); $account = m::mock(Account::class); $eventDispatcher = m::spy(EventDispatcher::class); $commandHandler = new RegisterUserCommandHandler($repository, $eventDispatcher); $command = new RegisterUserCommand('Kirk', 'Bushell', '*****@*****.**', 'lijsdflkjsdf', 'lkajsdflkjsdf', 'kjhasdfkjhasdf'); CurrentAccount::shouldReceive('get')->once()->andReturn($account); $account->shouldReceive('addUser')->once(); $this->assertNotNull($commandHandler->handle($command)); $repository->shouldHaveReceived('save')->once(); $eventDispatcher->shouldHaveReceived('dispatch')->once(); }
public function test_it_logs_the_user_in() { $providerAlias = 'twitbook'; $socialnormUser = new SocialNorm\User([]); $callback = function () { }; $redirector = $this->buildRedirector(); $authenticator = M::spy('AdamWathan\\EloquentOAuth\\Authenticator'); $socialnorm = M::mock('SocialNorm\\SocialNorm'); $socialnorm->shouldReceive('getUser')->with($providerAlias)->andReturn($socialnormUser); $oauth = new OAuthManager($redirector, $authenticator, $socialnorm); $oauth->login($providerAlias, $callback); $authenticator->shouldHaveReceived('login')->with($providerAlias, $socialnormUser, $callback, false); }
public function testExecution() { $command = m::mock('Tectonic\\Application\\Commanding\\Command'); $container = m::mock('Illuminate\\Container\\Container')->makePartial(); $translator = m::mock('Tectonic\\Application\\Commanding\\CommandTranslator')->makePartial(); $logger = m::spy('Illuminate\\Log\\Writer'); $translator->shouldReceive('getCommandHandler')->with($command)->andReturn('handler'); $container->shouldReceive('make')->once()->with('handler')->andReturn($container); $container->shouldReceive('handle')->once()->with($command)->andReturn('execution result'); $commandBus = new DefaultCommandBus($container, $translator, $logger); $response = $commandBus->execute($command); $this->assertEquals($response, 'execution result'); $logger->shouldHaveReceived('info')->once(); }
public function expectsEvents($events) { $this->events = is_array($events) ? $events : func_get_args(); $mock = Mockery::spy('Illuminate\\Contracts\\Events\\Dispatcher'); $mock->shouldReceive('fire')->andReturnUsing(function ($called) { foreach ($this->events as $key => $event) { if (is_string($called) && $called === $event || is_string($called) && is_subclass_of($called, $event) || is_object($called) && $called instanceof $event) { unset($this->events[$key]); } } }); App::instance('events', $mock); return $this; }
public function testOnSuccessfulLogin() { // Arrange $observer = m::spy(AuthenticationResponderInterface::class); // Create a new user. $user = $this->createTempUser(); // Associate user with this account. $currentAccount = CurrentAccount::get(); DB::table('account_user')->insert(['account_id' => $currentAccount->id, 'user_id' => $user->id]); // Act (User not associated with current account, so it should cause a UserAccountAssociation exception) $this->service->login(['email' => '*****@*****.**', 'password' => 'password', 'remember' => false], $observer); // Assert. $this->assertSame(1, (int) $user->id); $observer->shouldHaveReceived('onSuccess')->once(); }
public function testOnSuccess() { // Arrange $user = $this->createTempUser(); $observer = m::spy(UserProfileResponder::class); $testData = ['firstName' => 'Test', 'lastName' => 'User', 'email' => '*****@*****.**', 'password' => '', 'passwordConfirmation' => '']; // Act $this->be($user); // Set logged in user $this->service->updateProfile($testData, $observer); // Assert. $observer->shouldHaveReceived('onSuccess')->once(); $resultUser = App::make(UserRepositoryInterface::class)->getOneBy('id', $user->id); $this->assertSame($resultUser->email, $testData['email']); }
public function setUp() { $faker = Factory::create(); $this->userId = new ApplicationUserId($faker->uuid); $this->userName = $faker->userName; $this->language = $faker->countryISOAlpha3; $this->account = \Mockery::mock(Account::class); $this->user = \Mockery::mock(SourcedUser::class); $this->command = CreateUserCommand::create($this->userId, $this->user, $this->language); $this->userFactory = \Mockery::mock(UserFactory::class); $this->accountFactory = \Mockery::mock(AccountFactory::class); $this->userRepository = \Mockery::spy(UserEventSourcedRepository::class); $this->errorHandler = \Mockery::spy(ErrorEventHandler::class); $this->serviceUnderTest = new MessageAppCommandHandler($this->userFactory, $this->userRepository, $this->accountFactory, $this->errorHandler); }
public function test_if_nothing_is_returned_from_the_callback_the_found_or_created_user_is_used() { $providerAlias = 'provider'; $userDetails = new SocialNormUser([]); $foundUser = M::mock('Illuminate\\Contracts\\Auth\\Authenticatable')->shouldIgnoreMissing(); $otherUser = M::mock('Illuminate\\Contracts\\Auth\\Authenticatable')->shouldIgnoreMissing(); $auth = M::spy(); $users = M::spy(['findByIdentity' => $foundUser]); $identities = M::spy(['userExists' => true, 'getByProvider' => new OAuthIdentity()]); $authenticator = new Authenticator($auth, $users, $identities); $authenticator->login('provider', $userDetails, function () { return; }); $users->shouldNotHaveReceived('create'); $users->shouldHaveReceived('store')->with($foundUser); $identities->shouldHaveReceived('store'); $auth->shouldHaveReceived('login')->with($foundUser); }
public function test_login_uses_existing_user_if_matching_user_exists() { $providerAlias = 'provider'; $auth = M::spy(); $users = M::spy(); $identities = M::spy(); $userDetails = new SocialNormUser([]); $user = M::mock('Illuminate\\Contracts\\Auth\\Authenticatable')->shouldIgnoreMissing(); $identities->shouldReceive('userExists')->andReturn(true); $identities->shouldReceive('getByProvider')->andReturn(new OAuthIdentity()); $users->shouldReceive('findByIdentity')->andReturn($user); $authenticator = new Authenticator($auth, $users, $identities); $authenticator->login('provider', $userDetails); $users->shouldNotHaveReceived('create'); $users->shouldHaveReceived('store')->with($user); $identities->shouldHaveReceived('store'); $auth->shouldHaveReceived('login')->with($user); }