/**
  * @param $request
  * @param $response
  * @param $attributesToCheck
  *
  * @dataProvider matchUpdatesWithRequests
  */
 public function testUpdateMatchScore($request, $response, $attributesToCheck)
 {
     $member = Factory::create('App\\Models\\Member');
     Auth::login($member);
     /**
      * @var $tournament Tournament
      * @var $league League
      * @var $homeTeam Team
      * @var $awayTeam Team
      * @var $homeTournamentTeam TournamentTeam
      * @var $awayTournamentTeam TournamentTeam
      * @var $match Match
      */
     $tournament = Factory::create('App\\Models\\Tournament');
     $league = Factory::create('App\\Models\\League');
     $homeTeam = Factory::create('App\\Models\\Team', ['leagueId' => $league->id]);
     $awayTeam = Factory::create('App\\Models\\Team', ['leagueId' => $league->id]);
     $homeTournamentTeam = Factory::create('App\\Models\\TournamentTeam', ['teamId' => $homeTeam->id, 'tournamentId' => $tournament->id]);
     $awayTournamentTeam = Factory::create('App\\Models\\TournamentTeam', ['teamId' => $awayTeam->id, 'tournamentId' => $tournament->id]);
     $match = Factory::create('App\\Models\\Match', ['tournamentId' => $tournament->id, 'homeTournamentTeamId' => $homeTournamentTeam->id, 'awayTournamentTeamId' => $awayTournamentTeam->id]);
     $this->put('/api/v1/matches/' . $match->id, ['match' => $request], ['HTTP_X-Requested-With' => 'XMLHttpRequest', 'HTTP_CONTENT_TYPE' => 'application/json', 'HTTP_ACCEPT' => 'application/json']);
     $this->assertResponseStatus($response['status']);
     if (!empty($result)) {
         $updatedRow = Match::find($match->id);
         foreach ($result as $property => $value) {
             $this->assertEquals($value, $updatedRow->getAttribute($property));
         }
     }
 }

 /**
  * Tests if the remove function works correctly.
  */
 public function testRepoRemovePlayerSuccessRemoval()
 {
     $player = Factory::create('App\\Models\\Player');
     $success = $this->repository->removePlayer($player->nickname);
     $this->assertTrue($success);
     $this->assertNull(Player::find($player->id));
 }

 public function testStoreWithIncorrectCredentials()
 {
     $user = Factory::create('User', ['email' => '[email protected]']);
     $this->action('POST', 'Admin\\SessionsController@store', ['email' => $user->email, 'password' => 'foo']);
     $this->assertRedirectedToRoute('admin.sessions.create');
     $this->assertSessionHas('error', 'Your login credentials were invalid.');
 }

 public function testDestroy()
 {
     $series = Factory::create('Series');
     $this->action('DELETE', 'Admin\\SeriesController@destroy', $series->slug);
     $this->assertRedirectedToRoute('admin.series.index');
     $this->assertEquals(0, Series::count());
 }

 private function makeUser($overrides = [])
 {
     # $user = factory(User::class)->make($overrides);
     $user = Factory::build('Timegridio\\Tests\\Models\\User', $overrides);
     $user->email = '[email protected]';
     return $user;
 }

 /**
  * Tests if the repo removeAdministrator removes an
  * admin properly.
  */
 public function testRepoRemoveAdminSuccessRemoval()
 {
     $admin = Factory::create('App\\Models\\Administrator');
     $wasDeleted = $this->repository->removeAdministrator($admin->nickname);
     $this->assertTrue($wasDeleted);
     $this->assertNull(Administrator::find($admin->id));
 }

 private function makeDomain(User $owner, $overrides = [])
 {
     $domain = Factory::build(Domain::class, $overrides);
     $domain->save();
     $domain->owners()->attach($owner);
     return $domain;
 }

 public function testDestroy()
 {
     $user = Factory::create('User');
     $this->action('DELETE', 'Admin\\UsersController@destroy', $user->id);
     $this->assertRedirectedToRoute('admin.users.index');
     $this->assertEquals(0, User::count());
 }

 /**
  * @param $teamsAmount
  * @param $matcheAmount
  *
  * @dataProvider tournamentTeamsProvider
  */
 public function testSuccessLeagueDrawWithDifferrentTeamsAmount($teamsAmount, $matchesAmount)
 {
     /**
      * @var $tournament Tournament
      */
     $tournament = Factory::create('App\\Models\\Tournament');
     /**
      * @var $tournament Tournament
      */
     $league = Factory::create('App\\Models\\League');
     Factory::times($teamsAmount)->create('App\\Models\\Team', ['leagueId' => $league->id])->each(function ($team, $key) use($tournament) {
         $tournament->tournamentTeams()->create(['teamId' => $team->id, 'tournamentId' => $tournament->id]);
     });
     $tournament->status = Tournament::STATUS_STARTED;
     $tournament->save();
     $this->assertTrue($tournament instanceof Tournament);
     // verify total matches amount
     $this->assertEquals($matchesAmount, $tournament->matches()->getResults()->count());
     /**
      * @var $matches Collection
      * @var $team TournamentTeam
      */
     $matches = Match::where(['tournamentId' => $tournament->id])->get();
     foreach ($tournament->tournamentTeams()->getResults() as $team) {
         // verify matches per team
         $this->assertEquals(($teamsAmount - 1) * 2, $matches->filter(function ($match) use($team) {
             return $match->homeTournamentTeamId == $team->id || $match->awayTournamentTeamId == $team->id;
         })->count());
     }
 }

 public function testDestroy()
 {
     $project = Factory::create('Project');
     $this->action('DELETE', 'Admin\\ProjectsController@destroy', $project->slug);
     $this->assertRedirectedToRoute('admin.projects.index');
     $this->assertEquals(0, Project::count());
 }

 private function makeBusiness(User $owner, $overrides = [])
 {
     $business = Factory::build(Business::class, $overrides);
     $business->save();
     $business->owners()->attach($owner);
     return $business;
 }

 public function test_it_saves_a_todo_for_a_given_todolist()
 {
     $todolist = Factory::create(App\Umbrella\Todo\TodoList::class, ['user_id' => 1]);
     $todoRepository = $this->app->make(App\Umbrella\Todo\Repository\TodoRepositoryInterface::class);
     $todo = $todoRepository->create('Finish up homework', $todolist);
     $this->seeInDatabase('todo', ['name' => 'Finish up homework', 'todo_list_id' => $todolist->id]);
 }

 public function testUserRelationshipReturnsModel()
 {
     $meta = Factory::create('PostMeta', ['meta_key' => 'pal_user_id', 'meta_value' => 1]);
     Factory::create('User', ['id' => 1]);
     $user = $meta->user;
     assertThat($user, is(anInstanceof('User')));
 }

 public function test_it_updates_a_todo()
 {
     $todo = Factory::create(App\Umbrella\Todo\Todo::class);
     $todoRepository = $this->app->make(App\Umbrella\Todo\Repository\TodoRepositoryInterface::class);
     $todoRepository->update($todo, ['finished' => true]);
     $this->seeInDatabase('todo', ['id' => $todo->id, 'finished' => 1]);
 }

 public function test_it_persists_a_todolist_for_a_given_user()
 {
     $user = \Laracasts\TestDummy\Factory::create(App\Umbrella\User\User::class);
     $todolistRepo = App::make('App\\Umbrella\\Todo\\Repository\\TodolistRepositoryInterface');
     $todolist = $todolistRepo->create('Private', $user);
     $this->seeInDatabase('todolist', ['name' => 'Private']);
 }

 public function testSendingAmessageToAnotherUser()
 {
     $currentUser = Factory::create('App\\User');
     $otherUser = Factory::create('App\\User');
     Auth::login($currentUser);
     $this->visit('/messages/compose/' . $otherUser->id)->submitForm('Submit', ['body' => 'This is the new message to you.'])->verifyInDatabase('messages', ['body' => 'This is the new message to you.'])->verifyInDatabase('message_responses', ['body' => 'This is the new message to you.']);
 }

 public function testHandleReturnsTrueOnsuccesfulLogin()
 {
     $currentUser = Factory::create('App\\User');
     $loginUserCommand = new LoginUserCommand($currentUser->email, $currentUser->password);
     $loginUserCommand->handle();
     // $this->assertTrue($response);
     // $this->assertTrue($response);
 }

 public function testGetPublishedByUserAndFriendsAjaxReturnArrayWithResults()
 {
     $user = Factory::create('App\\User');
     $feeds = Factory::times(20)->create('App\\Feed', ['user_id' => $user->id]);
     $repository = new EloquentFeedRepository();
     $feedCount = $repository->getPublishedByUserAndFriends($user);
     $this->assertEquals(10, count($feedCount));
 }

 public function testHandleReturnsTheNewlyCreatedFeed()
 {
     $currentUser = Factory::create('App\\User');
     Auth::login($currentUser);
     $createFeedCommand = new CreateFeedCommand('This is the feed body', 'postername', 'http://image/sampleimage.jpg');
     $response = $createFeedCommand->handle();
     $this->assertInstanceOf('App\\Feed', $response);
 }

 public function testAddNewFriendRequest()
 {
     $currentUser = Factory::create('App\\User');
     $otherUser = Factory::create('App\\User');
     Auth::login($currentUser);
     $this->visit('users')->click('Add friend');
     $this->assertResponseOk();
 }