public function test_gets_model_by_classname()
 {
     $this->modelManagerMock->shouldReceive('getAbstractionLayer')->once()->andReturn($this->mock('ANavallaSuiza\\Laravel\\Database\\Contracts\\Dbal\\AbstractionLayer'));
     $this->modelManagerMock->shouldReceive('getModelInstance')->once()->with('Anavel\\Crud\\Tests\\Models\\User');
     $model = $this->sut->getByClassName('Anavel\\Crud\\Tests\\Models\\User', []);
     $this->assertInstanceOf('Anavel\\Crud\\Contracts\\Abstractor\\Model', $model);
 }

 public function test_it_throws_exception_when_route_binder_does_not_exist()
 {
     $this->setExpectedException(InvalidArgumentException::class, 'RouteBinder [NotExistingRouteBinder] does not exist');
     $this->app->shouldReceive('getContext')->once()->andReturn($context = 'web');
     $this->config->shouldReceive('get')->once()->with($context . '.routes', [])->andReturn([\NotExistingRouteBinder::class]);
     $this->binder->loadRoutes(\Mockery::mock(Router::class));
 }

 /**
  * @test
  */
 public function it_registers_the_client()
 {
     //        $this->markTestIncomplete();
     $this->app_mock->shouldReceive('make')->with('config')->andReturn(['services' => ['connectwise' => []]])->once();
     $this->app_mock->shouldReceive('singleton')->withArgs(['connectwise', Mockery::any()])->once();
     $this->service_provider->register();
 }

 protected function setUpMocks()
 {
     $this->localeMock = Mockery::mock(LocaleInterface::class);
     $this->viewFinderMock = Mockery::mock(ViewFinderInterface::class);
     $this->viewMock = Mockery::mock(View::class);
     $this->viewMock->shouldReceive('getPath')->andReturn('');
 }

 /**
  * @covers phpDocumentor\Descriptor\Filter\Filter::filter
  */
 public function testFilter()
 {
     $filterableMock = m::mock('phpDocumentor\\Descriptor\\Filter\\Filterable');
     $this->filterChainMock->shouldReceive('filter')->with($filterableMock)->andReturn($filterableMock);
     $this->classFactoryMock->shouldReceive('getChainFor')->with(get_class($filterableMock))->andReturn($this->filterChainMock);
     $this->assertSame($filterableMock, $this->fixture->filter($filterableMock));
 }

 /**
  * @covers ::__toString
  */
 public function testRenderWithToString()
 {
     $this->viewMock->shouldReceive('merge')->with($this->presenter)->once();
     $this->viewMock->shouldReceive('autoFilter')->with(true)->once();
     $this->viewMock->shouldReceive('render')->with([])->once()->andReturn('');
     $result = (string) $this->presenter;
 }

 /**
  * @test postValidate() returns a failed response on validation errors
  */
 public function postValidate_returns_a_failed_response_on_validation_errors()
 {
     $this->input->shouldReceive('all')->withNoArgs()->once()->andReturn(array('foo'));
     $this->validator->shouldReceive('make')->with(array('foo'), array('recaptcha_response_field' => 'required|recaptcha'))->once()->andReturn($this->getFailsMockFixture(true));
     $this->response->shouldReceive('json')->with(array('result' => 'failed'))->once()->andReturn('bar');
     $controller = $this->getCaptchaControllerInstance();
     $this->assertEquals('bar', $controller->postValidate());
 }

 public function testFindOneById()
 {
     $image1 = $this->dummyData->getTag();
     $this->imageRepository->shouldReceive('findOneById')->with($image1->getId())->andReturn($image1)->once();
     $image = $this->imageService->findOneById($image1->getId());
     $this->assertEntitiesEqual($image1, $image);
 }

 protected function setUp()
 {
     $this->rodzaj = new LoadUrlopRodzajData();
     $this->manager = M::mock(ObjectManager::class);
     $this->manager->shouldReceive('persist');
     $this->manager->shouldReceive('flush');
 }

 public function testEndpoint()
 {
     $this->viewFactory->shouldReceive('make')->withArgs(['fooTable', ['columns' => ['id' => 'id'], 'showHeaders' => false, 'id' => 'fooBar', 'endpoint' => '/test/endpoint/gets/set']])->times(1)->andReturn($this->view);
     $this->viewFactory->shouldReceive('make')->withArgs(['fooScript', ['id' => 'fooBar', 'columns' => ['id' => 'id'], 'options' => [], 'callbacks' => [], 'endpoint' => '/test/endpoint/gets/set']])->times(1)->andReturn($this->view);
     $this->dtv2->endpoint('/test/endpoint/gets/set');
     $this->dtv2->html();
 }

 public function testGetAttributeValuesByIds()
 {
     $attributeValue1 = $this->dummyData->getAttributeValue();
     $this->attributeValueRepository->shouldReceive('getAttributeValuesByIds')->with([$attributeValue1->getId()], null)->andReturn([$attributeValue1])->once();
     $attributeValues = $this->attributeValueService->getAttributeValuesByIds([$attributeValue1->getId()]);
     $this->assertEntitiesEqual($attributeValue1, $attributeValues[0]);
 }

 public function test_can_pass_middleware_during_dispatch_from_array()
 {
     $this->container->shouldReceive('make')->with(TacticianCommandHandler::class)->once()->andReturn(new TacticianCommandHandler());
     $this->container->shouldReceive('make')->with(LockingMiddleware::class)->once()->andReturn(new LockingMiddleware());
     $result = $this->bus->dispatchFromArray(TacticianCommand::class, [], [LockingMiddleware::class]);
     $this->assertEquals('handled', $result);
 }

 /**
  * @test
  */
 public function it_adds_writes_error_to_output_on_fail()
 {
     $this->response_mock->shouldReceive('getSuccessful')->andReturn(false)->once();
     $this->response_mock->shouldReceive('getResponse')->andReturn("Error")->once();
     $this->output_mock->shouldReceive('writeln')->with("<error>Error</error>")->once();
     $this->stub->exposeOutputResponse($this->response_mock);
 }

 /**
  * @test getDashboard() sets the page title and makes the dashboard view
  */
 public function getDashboard_sets_the_page_title_and_makes_the_dashboard_view()
 {
     $this->helpers->shouldReceive('setPageTitle')->with('Dashboard')->once();
     $this->view->shouldReceive('make')->with('larapress::pages.cp.dashboard')->once()->andReturn('foo');
     $controller = $this->getControlPanelControllerInstance();
     $this->assertEquals('foo', $controller->getDashboard());
 }

 public function testSubmitValidDataDodajOrganizacje()
 {
     //dane formularza - pola i wartości wpisane
     $formData = ['nazwa' => 'Testowa nazwa', 'pnazwa' => 'Pełna nazwa'];
     // dodajOrganizacjeCommand
     $token = M::mock(AbstractToken::class);
     $token->shouldReceive('getUser')->once();
     $this->tokenStorage->shouldReceive('getToken')->once()->andReturn($token);
     $dodajOrganizacjeCommand = new DodajOrganizacjeCommand($this->tokenStorage);
     $dodajOrganizacjeCommand->setNazwa($formData['nazwa']);
     $dodajOrganizacjeCommand->setPnazwa($formData['pnazwa']);
     // formularz
     $form = $this->factory->create(OrganizacjaType::class, $dodajOrganizacjeCommand);
     // submit formularza
     $form->submit($formData);
     // this test checks that none of your data transformers used by the form failed
     $this->assertTrue($form->isSynchronized());
     // sprawdzamy czy obiekty są sobie równe
     $this->assertEquals($dodajOrganizacjeCommand, $form->getData());
     // sprawdzamy czy zgadzają się pola formularza
     $view = $form->createView();
     $children = $view->children;
     foreach (array_keys($formData) as $key) {
         $this->assertArrayHasKey($key, $children);
     }
 }

 protected function setUp()
 {
     $this->entityManager = M::mock(EntityManager::class);
     $classMetaData = new ClassMetadata('AppBundle\\Entity\\Organizacja');
     $this->entityManager->shouldReceive('getClassMetadata')->andReturn($classMetaData);
     $this->entityManager->shouldReceive('persist')->andReturn();
 }

 public function testGenerateThrowsException()
 {
     $this->repository->shouldReceive('referenceNumberExists')->andReturn(true)->times(3);
     $entity = new FakeReferenceNumberEntity();
     $this->setExpectedException(RuntimeException::class, 'Lookup limit reached');
     $this->hashSegmentGenerator->generate($entity);
 }

 /**
  * @test
  */
 public function getMessageCommitConfigurationReturnsSuccesfull()
 {
     $data = array('commit-msg' => array('regular-expression' => 'expression'));
     $this->configFileValidator->shouldReceive('validate');
     $this->configFileReader->setData($data);
     $this->assertTrue(is_array($this->configFile->getMessageCommitConfiguration()));
 }

 /**
  * @test
  * @dataProvider dataMethods
  */
 public function dataMethodsSendsProperRequestWithData($method, $expectedMethod)
 {
     $this->request->shouldReceive($expectedMethod)->with('http://test.example.com/foo/bar', '{"test":"boo"}')->andReturnSelf();
     $this->request->shouldReceive('send')->andReturn((object) ['body' => 'OK']);
     $actual = $this->client->callRestfulApi($method, 'foo/bar', json_encode(['test' => 'boo']));
     $this->assertEquals('OK', $actual);
 }

 public function testFindAll()
 {
     $cartPriceRule1 = $this->dummyData->getCartPriceRule();
     $this->cartPriceRuleRepository->shouldReceive('findAll')->andReturn([$cartPriceRule1])->once();
     $cartPriceRules = $this->cartPriceRuleService->findAll();
     $this->assertEntitiesEqual($cartPriceRule1, $cartPriceRules[0]);
 }