TheSportsDb\Test\TheSportsDbTest

Complexity

Total Complexity

61

Size/Duplication

Total Lines	697
Duplicated Lines	51.51 %

Coupling/Cohesion

Components	1
Dependencies	8

Importance

Changes	1
Bugs	0	Features	0

<?php
class TheSportsDbTest extends \PHPUnit_Framework_TestCase {

  /**
   * @var TheSportsDb
   */
  protected $db;

  /**
   * Sets up the fixture, for example, opens a network connection.
   * This method is called before a test is executed.
   */
  protected function setUp() {
    include __DIR__ . '/../../default_bootstrap.php';
    $this->db = $db;
  }

  /**
   * Tears down the fixture, for example, closes a network connection.
   * This method is called after a test is executed.
   */
  protected function tearDown() {
    $this->db = NULL;
  }

  /**
   * @covers TheSportsDb\TheSportsDb::getSports
   */
  public function testGetSports() {
    $sports = $this->db->getSports();
    $this->assertNotEmpty($sports);
    foreach ($sports as $sport) {
      // Should be a sport.
      $this->assertInstanceOf(SportInterface::class, $sport);
    }
  }

  /**
   * @covers TheSportsDb\TheSportsDb::getSport
   */
  public function testGetSport() {
    $sport = $this->db->getSport('Soccer');
    // Should be a sport.
    $this->assertInstanceOf(SportInterface::class, $sport);
    $this->assertEquals('Soccer', $sport->getName());

    // Try a fake sport.
    $sport = $this->db->getSport('FakeSport123');
    // Should be a sport.
    $this->assertInstanceOf(SportInterface::class, $sport);
    $this->assertEquals('FakeSport123', $sport->getName());

    // Sport doesn't exist, so exception when we try to load its leagues.
    $this->expectException(\Exception::class);
    $this->expectExceptionMessage('Could not fully load sport with id FakeSport123.');
    $sport->getLeagues();
  }

  /**
   * @covers TheSportsDb\TheSportsDb::getLeagues
   */
  public function testGetLeagues() {
    $leagues = $this->db->getLeagues();
    $this->assertNotEmpty($leagues);
    foreach ($leagues as $league) {
      // Should be a league.
      $this->assertInstanceOf(LeagueInterface::class, $league);
    }
  }

  /**
   * @covers TheSportsDb\TheSportsDb::getLeague
   */
  public function testGetLeague() {
    $league = $this->db->getLeague(4328);
    // Should be a sport.
    $this->assertInstanceOf(LeagueInterface::class, $league);
    $this->assertEquals('English Premier League', $league->getName());

    // Try a fake league.
    $league = $this->db->getLeague('FakeLeague123');
    // Should be a league.
    $this->assertInstanceOf(LeagueInterface::class, $league);
    $this->assertEquals('FakeLeague123', $league->getId());

    // League doesn't exist, so exception when we try to load its name.
    $this->expectException(\Exception::class);
    $this->expectExceptionMessage('Could not fully load league with id FakeLeague123.');
    $league->getName();
  }

  /**
   * @covers TheSportsDb\TheSportsDb::getLeaguesByCountry
   */
  public function testGetLeaguesByCountry() {
    $leagues = $this->db->getLeaguesByCountry('Belgium');
    $this->assertNotEmpty($leagues);
    foreach ($leagues as $league) {
      // Should be a league.
      $this->assertInstanceOf(LeagueInterface::class, $league);
      $this->assertEquals('Belgium', $league->getCountry());
    }

    // Try a fake country.
    $leagues = $this->db->getLeaguesByCountry('FakeCountry123');
    $this->assertEmpty($leagues);
  }

  /**
   * @covers TheSportsDb\TheSportsDb::getLeaguesBySport
   */
  public function testGetLeaguesBySport() {
    $leagues = $this->db->getLeaguesBySport('Soccer');
    $this->assertNotEmpty($leagues);
    foreach ($leagues as $league) {
      // Should be a league.
      $this->assertInstanceOf(LeagueInterface::class, $league);
      $this->assertEquals('Soccer', $league->getSport()->getName());
    }

    // Try a fake sport.
    $leagues = $this->db->getLeaguesByCountry('FakeSport123');
    $this->assertEmpty($leagues);
  }

  /**
   * @covers TheSportsDb\TheSportsDb::getLeaguesByCountryAndSport
   */
  public function testGetLeaguesByCountryAndSport() {
    $leagues = $this->db->getLeaguesByCountryAndSport('Belgium', 'Soccer');
    $this->assertNotEmpty($leagues);
    foreach ($leagues as $league) {
      // Should be a league.
      $this->assertInstanceOf(LeagueInterface::class, $league);
      $this->assertEquals('Belgium', $league->getCountry());
      $this->assertEquals('Soccer', $league->getSport()->getName());
    }

    // Try a fake country.
    $leagues = $this->db->getLeaguesByCountryAndSport('FakeCountry123', 'Soccer');
    $this->assertEmpty($leagues);

    // Try a fake sport.
    $leagues = $this->db->getLeaguesByCountryAndSport('Belgium', 'FakeSport123');
    $this->assertEmpty($leagues);

    // Try a fake country and sport.
    $leagues = $this->db->getLeaguesByCountryAndSport('FakeCountry123', 'FakeSport123');
    $this->assertEmpty($leagues);
  }

  /**
   * @covers TheSportsDb\TheSportsDb::getTeam
   */
  public function testGetTeam() {
    $team = $this->db->getTeam(133604);
    // Should be a sport.
    $this->assertInstanceOf(TeamInterface::class, $team);
    $this->assertEquals('Arsenal', $team->getName());

    // Try a fake team.
    $team = $this->db->getTeam('FakeTeam123');
    // Should be a team.
    $this->assertInstanceOf(TeamInterface::class, $team);
    $this->assertEquals('FakeTeam123', $team->getId());

    // Sport doesn't exist, so exception when we try to load its teams.
    $this->expectException(\Exception::class);
    $this->expectExceptionMessage('Could not fully load team with id FakeTeam123.');
    $team->getName();
  }

  /**
   * @covers TheSportsDb\TheSportsDb::getTeamsByName
   */
  public function testGetTeamsByName() {
    $teams = $this->db->getTeamsByName('Arsenal');
    $this->assertNotEmpty($teams);

    foreach ($teams as $team) {
      // Should be a team.
      $this->assertInstanceOf(TeamInterface::class, $team);
      $this->assertContains('Arsenal', $team->getName());
    }

    // Try a fake team.
    $teams = $this->db->getTeamsByName('FakeTeam123');
    $this->assertEmpty($teams);
  }

  /**
   * @covers TheSportsDb\TheSportsDb::getTeamsByLeague
   */
  public function testGetTeamsByLeague() {
    $teams = $this->db->getTeamsByLeague(4328);
    $this->assertNotEmpty($teams);

    foreach ($teams as $team) {
      // Should be a team.
      $this->assertInstanceOf(TeamInterface::class, $team);
      $this->assertEquals(4328, $team->getLeague()->getId());
    }

    // Try a fake league.
    $teams = $this->db->getTeamsByLeague('FakeLeague123');
    $this->assertEmpty($teams);
  }

  /**
   * @covers TheSportsDb\TheSportsDb::getTeamsByLeagueName
   */
  public function testGetTeamsByLeagueName() {
    $teams = $this->db->getTeamsByLeagueName('English Premier League');
    $this->assertNotEmpty($teams);

    foreach ($teams as $team) {
      // Should be a team.
      $this->assertInstanceOf(TeamInterface::class, $team);
      $this->assertEquals('English Premier League', $team->getLeague()->getName());
    }

    // Try a fake league.
    $teams = $this->db->getTeamsByLeagueName('FakeLeague123');
    $this->assertEmpty($teams);
  }

  /**
   * @covers TheSportsDb\TheSportsDb::getTeamsBySportAndCountry
   */
  public function testGetTeamsBySportAndCountry() {
    $teams = $this->db->getTeamsBySportAndCountry('Soccer', 'Belgium');
    $this->assertNotEmpty($teams);
    foreach ($teams as $team) {
      // Should be a team.
      $this->assertInstanceOf(TeamInterface::class, $team);
      $this->assertEquals('Belgium', $team->getCountry());
      $this->assertEquals('Soccer', $team->getSport()->getName());
    }

    // Try a fake country.
    $teams = $this->db->getTeamsBySportAndCountry('Soccer', 'FakeCountry123');
    $this->assertEmpty($teams);

    // Try a fake sport.
    $teams = $this->db->getTeamsBySportAndCountry('FakeSport123', 'Belgium');
    $this->assertEmpty($teams);

    // Try a fake country and sport.
    $teams = $this->db->getTeamsBySportAndCountry('FakeSport123', 'FakeCountry123');
    $this->assertEmpty($teams);
  }

  /**
   * @covers TheSportsDb\TheSportsDb::getPlayer
   */
  public function testGetPlayer() {
    $player = $this->db->getPlayer(34145937);
    // Should be a sport.
    $this->assertInstanceOf(PlayerInterface::class, $player);
    $this->assertEquals('Mario Balotelli', $player->getName());

    // Try a fake player.
    $player = $this->db->getPlayer('FakePlayer123');
    // Should be a player.
    $this->assertInstanceOf(PlayerInterface::class, $player);
    $this->assertEquals('FakePlayer123', $player->getId());

    // Player doesn't exist, so exception when we try to load its sport.
    $this->expectException(\Exception::class);
    $this->expectExceptionMessage('Could not fully load player with id FakePlayer123.');
    $player->getSport();
  }

  /**
   * @covers TheSportsDb\TheSportsDb::getPlayersByTeam
   */
  public function testGetPlayersByTeam() {
    $players = $this->db->getPlayersByTeam(133604);
    $this->assertNotEmpty($players);

    foreach ($players as $player) {
      // Should be a player.
      $this->assertInstanceOf(PlayerInterface::class, $player);
      $this->assertEquals(133604, $player->getTeam()->getId());
    }

    // Try a fake team.
    $players = $this->db->getPlayersByTeam('FakeTeam123');
    $this->assertEmpty($players);
  }

  /**
   * @covers TheSportsDb\TheSportsDb::getPlayersByTeamName
   */
  public function testGetPlayersByTeamName() {
    $players = $this->db->getPlayersByTeamName('Arsenal');
    $this->assertNotEmpty($players);

    foreach ($players as $player) {
      // Should be a player.
      $this->assertInstanceOf(PlayerInterface::class, $player);
      $this->assertContains('Arsenal', $player->getTeam()->getName(), '', FALSE);
    }

    // Try a fake team.
    $players = $this->db->getPlayersByTeamName('FakeTeam123');
    $this->assertEmpty($players);
  }

  /**
   * @covers TheSportsDb\TheSportsDb::getPlayersByName
   */
  public function testGetPlayersByName() {
    $players = $this->db->getPlayersByName('mario');
    $this->assertNotEmpty($players);

    foreach ($players as $player) {
      // Should be a player.
      $this->assertInstanceOf(PlayerInterface::class, $player);
      $this->assertContains('mario', $player->getName(), '', TRUE);
    }

    // Try a fake name.
    $players = $this->db->getPlayersByName('FakePlayer123');
    $this->assertEmpty($players);
  }

  /**
   * @covers TheSportsDb\TheSportsDb::getPlayersByTeamNameAndName
   */
  public function testGetPlayersByTeamNameAndName() {
    $players = $this->db->getPlayersByTeamNameAndName('Arsenal', 'Ivan');
    $this->assertNotEmpty($players);

    foreach ($players as $player) {
      // Should be a player.
      $this->assertInstanceOf(PlayerInterface::class, $player);
      $this->assertContains('Ivan', $player->getName(), '', TRUE);
      $this->assertContains('Arsenal', $player->getTeam()->getName(), '', TRUE);
    }

    // Try a fake team.
    $players = $this->db->getPlayersByTeamNameAndName('FakeTeam123', 'Ivan');
    $this->assertEmpty($players);

    // Try a fake name.
    $players = $this->db->getPlayersByTeamNameAndName('Arsenal', 'FakePlayer123');
    $this->assertEmpty($players);

    // Try a fake team and name.
    $players = $this->db->getPlayersByTeamNameAndName('FakeTeam123', 'FakePlayer123');
    $this->assertEmpty($players);
  }

  /**
   * @covers TheSportsDb\TheSportsDb::getEvent
   */
  public function testGetEvent() {
    $event = $this->db->getEvent(441613);
    // Should be an event.
    $this->assertInstanceOf(EventInterface::class, $event);
    $this->assertEquals('Liverpool vs Swansea', $event->getName());

    // Try a fake event.
    $event = $this->db->getEvent('FakeEvent123');
    // Should be an event.
    $this->assertInstanceOf(EventInterface::class, $event);
    $this->assertEquals('FakeEvent123', $event->getId());

    // Event doesn't exist, so exception when we try to load its sport.
    $this->expectException(\Exception::class);
    $this->expectExceptionMessage('Could not fully load event with id FakeEvent123.');
    $event->getLeague();
  }

  /**
   * @covers TheSportsDb\TheSportsDb::getEventsByName
   */
  public function testGetEventsByName() {
    $events = $this->db->getEventsByName('Arsenal vs');
    $this->assertNotEmpty($events);

    foreach ($events as $event) {
      // Should be an event.
      $this->assertInstanceOf(EventInterface::class, $event);
      $this->assertContains('Arsenal vs', $event->getName(), '', TRUE);
    }

    // Try a fake name.
    $events = $this->db->getEventsByName('FakeTeam1 vs FakeTeam2');
    $this->assertEmpty($events);
  }

  /**
   * @covers TheSportsDb\TheSportsDb::getEventsByFileName
   */
  public function testGetEventsByFileName() {
    $events = $this->db->getEventsByFileName('English Premier League');
    $this->assertNotEmpty($events);

    foreach ($events as $event) {
      // Should be an event.
      $this->assertInstanceOf(EventInterface::class, $event);
      $this->assertContains('English Premier League', $event->getFilename(), '', TRUE);
    }

    // Try a fake name.
    $events = $this->db->getEventsByFileName('FakeTeam1 vs FakeTeam2');
    $this->assertEmpty($events);
  }

  /**
   * @covers TheSportsDb\TheSportsDb::getEventsByNameAndSeason
   */
  public function testGetEventsByNameAndSeason() {
    $events = $this->db->getEventsByNameAndSeason('Arsenal vs', '1415');
    $this->assertNotEmpty($events);

    foreach ($events as $event) {
      // Should be an event.
      $this->assertInstanceOf(EventInterface::class, $event);
      $this->assertContains('Arsenal vs', $event->getName(), '', TRUE);
      $this->assertEquals('1415', $event->getSeason()->getName());
    }

    // Try a fake name.
    $events = $this->db->getEventsByNameAndSeason('FakeTeam1 vs FakeTeam2', '1415');
    $this->assertEmpty($events);

    // Try a fake season.
    $events = $this->db->getEventsByNameAndSeason('Arsenal vs', 'FakeSeason123');
    $this->assertEmpty($events);

    // Try a fake name and season.
    $events = $this->db->getEventsByNameAndSeason('FakeTeam1 vs FakeTeam2', 'FakeSeason123');
    $this->assertEmpty($events);
  }

  /**
   * @covers TheSportsDb\TheSportsDb::getNextFiveEventsByTeam
   */
  public function testGetNextFiveEventsByTeam() {
    $events = $this->db->getNextFiveEventsByTeam(133604);
    $this->assertNotEmpty($events);
    $this->assertEquals(5, count($events));

    foreach ($events as $event) {
      // Should be an event.
      $this->assertInstanceOf(EventInterface::class, $event);
      $this->assertContains(133604, array($event->getHomeTeam()->getId(), $event->getAwayTeam()->getId()));
    }

    // Try a fake name.
    // Bug in the api, see http://www.thesportsdb.com/forum/viewtopic.php?f=6&t=196&sid=99a29ba57ec8ee0a1b12d5f429348121
    //$events = $this->db->getNextFiveEventsByTeam('FakeTeam123');
    //$this->assertEmpty($events);
  }

  /**
   * @covers TheSportsDb\TheSportsDb::getNextFifteenEventsByLeague
   */
  public function testGetNextFifteenEventsByLeague() {
    $events = $this->db->getNextFifteenEventsByLeague(4328);
    $this->assertNotEmpty($events);
    $this->assertEquals(15, count($events));

    foreach ($events as $event) {
      // Should be an event.
      $this->assertInstanceOf(EventInterface::class, $event);
      $this->assertEquals(4328, $event->getLeague()->getId());
    }

    // Try a fake name.
    $events = $this->db->getNextFifteenEventsByLeague('FakeLeague123');
    $this->assertEmpty($events);
  }

  /**
   * @covers TheSportsDb\TheSportsDb::getNextFifteenEventsByLeagueAndRound
   */
  public function testGetNextFifteenEventsByLeagueAndRound() {
    $events = $this->db->getNextFifteenEventsByLeagueAndRound(4328, 38);
    $this->assertNotEmpty($events);
    $this->assertLessThanOrEqual(15, count($events));

    foreach ($events as $event) {
      // Should be an event.
      $this->assertInstanceOf(EventInterface::class, $event);
      $this->assertEquals(4328, $event->getLeague()->getId());
      $this->assertEquals(38, $event->getRound());
    }

    // Try a fake name.
    $events = $this->db->getNextFifteenEventsByLeague('FakeLeague123');
    $this->assertEmpty($events);
  }

  /**
   * @covers TheSportsDb\TheSportsDb::getLastFiveEventsByTeam
   */
  public function testGetLastFiveEventsByTeam() {
    $events = $this->db->getLastFiveEventsByTeam(133604);
    $this->assertNotEmpty($events);
    $this->assertLessThanOrEqual(5, count($events));

    foreach ($events as $event) {
      // Should be an event.
      $this->assertInstanceOf(EventInterface::class, $event);
      $this->assertContains(133604, array($event->getHomeTeam()->getId(), $event->getAwayTeam()->getId()));
    }

    // Try a fake name.
    // Bug in the api, see http://www.thesportsdb.com/forum/viewtopic.php?f=6&t=196&sid=99a29ba57ec8ee0a1b12d5f429348121
    //$events = $this->db->getLastFiveEventsByTeam('FakeTeam123');
    //$this->assertEmpty($events);
  }

  /**
   * @covers TheSportsDb\TheSportsDb::getLastFifteenEventsByLeague
   */
  public function testGetLastFifteenEventsByLeague() {
    $events = $this->db->getLastFifteenEventsByLeague(4328);
    $this->assertNotEmpty($events);
    $this->assertLessThanOrEqual(15, count($events));

    foreach ($events as $event) {
      // Should be an event.
      $this->assertInstanceOf(EventInterface::class, $event);
      $this->assertEquals(4328, $event->getLeague()->getId());
    }

    // Try a fake name.
    $events = $this->db->getLastFifteenEventsByLeague('FakeLeague123');
    $this->assertEmpty($events);
  }

  /**
   * @covers TheSportsDb\TheSportsDb::getEventsByDay
   */
  public function testGetEventsByDay() {
    //http://www.thesportsdb.com/api/v1/json/1/eventsday.php?d=2014-10-10
    $day = new \DateTime();
    $day->setDate(2014, 1, 13);
    $events = $this->db->getEventsByDay($day);
    $this->assertNotEmpty($events);

    foreach ($events as $event) {
      // Should be an event.
      $this->assertInstanceOf(EventInterface::class, $event);
      $this->assertEquals($day->format('Y-m-d'), $event->getDate());
    }

    $events = $this->db->getEventsByDay($day, 'Soccer');
    $this->assertNotEmpty($events);

    foreach ($events as $event) {
      // Should be an event.
      $this->assertInstanceOf(EventInterface::class, $event);
      $this->assertEquals($day->format('Y-m-d'), $event->getDate());
      $this->assertEquals('Soccer', $event->getLeague()->getSport()->getName());
    }

    $events = $this->db->getEventsByDay($day, NULL, 'English Premier League');
    $this->assertNotEmpty($events);

    foreach ($events as $event) {
      // Should be an event.
      $this->assertInstanceOf(EventInterface::class, $event);
      $this->assertEquals($day->format('Y-m-d'), $event->getDate());
      $this->assertEquals('English Premier League', $event->getLeague()->getName());
    }

    $events = $this->db->getEventsByDay($day, 'Soccer', 'English Premier League');
    $this->assertNotEmpty($events);

    foreach ($events as $event) {
      // Should be an event.
      $this->assertInstanceOf(EventInterface::class, $event);
      $this->assertEquals($day->format('Y-m-d'), $event->getDate());
      $this->assertEquals('English Premier League', $event->getLeague()->getName());
      $this->assertEquals('Soccer', $event->getLeague()->getSport()->getName());
    }

    // Fake sport.
    // Bug in the api, see http://www.thesportsdb.com/forum/viewtopic.php?f=6&t=196&sid=99a29ba57ec8ee0a1b12d5f429348121
    //$events = $this->db->getEventsByDay($day, 'FakeSport123', 'English Premier League');
    //$this->assertEmpty($events);

    // Fake league.
    $events = $this->db->getEventsByDay($day, 'Soccer', 'FakeLeague123');
    $this->assertEmpty($events);

    // Fake sport and league.
    $events = $this->db->getEventsByDay($day, 'FakeSport123', 'FakeLeague123');
    $this->assertEmpty($events);

  }

  /**
   * @covers TheSportsDb\TheSportsDb::getEventsByLeagueRoundAndSeason
   */
  public function testGetEventsByLeagueRoundAndSeason() {
    $events = $this->db->getEventsByLeagueRoundAndSeason(4328, 38, '1415');
    $this->assertNotEmpty($events);

    foreach ($events as $event) {
      // Should be an event.
      $this->assertInstanceOf(EventInterface::class, $event);
      $this->assertEquals(4328, $event->getLeague()->getId());
      $this->assertEquals(38, $event->getRound());
      $this->assertEquals('1415', $event->getSeason()->getName());
    }

    // Fake league.
    $events = $this->db->getEventsByLeagueRoundAndSeason('FakeLeague123', 38, '1415');
    $this->assertEmpty($events);

    // Fake round.
    $events = $this->db->getEventsByLeagueRoundAndSeason(4328, 'FakeRound123', '1415');
    $this->assertEmpty($events);

    // Fake season.
    $events = $this->db->getEventsByLeagueRoundAndSeason(4328, 38, 'FakeSeason123');
    $this->assertEmpty($events);

    // Fake league and round.
    $events = $this->db->getEventsByLeagueRoundAndSeason('FakeLeague123', 'FakeRound123', '1415');
    $this->assertEmpty($events);

    // Fake round and season.
    $events = $this->db->getEventsByLeagueRoundAndSeason(4328, 'FakeRound123', 'FakeSeason123');
    $this->assertEmpty($events);

    // Fake league and season.
    $events = $this->db->getEventsByLeagueRoundAndSeason('FakeLeague123', 38, 'FakeSeason123');
    $this->assertEmpty($events);

    // Fake league round and season.
    $events = $this->db->getEventsByLeagueRoundAndSeason('FakeLeague123', 'FakeRound123', 'FakeSeason123');
    $this->assertEmpty($events);
  }

  /**
   * @covers TheSportsDb\TheSportsDb::getEventsByLeagueAndSeason
   */
  public function testGetEventsByLeagueAndSeason() {
    $events = $this->db->getEventsByLeagueAndSeason(4328, '1415');
    $this->assertNotEmpty($events);

    foreach ($events as $event) {
      // Should be an event.
      $this->assertInstanceOf(EventInterface::class, $event);
      $this->assertEquals(4328, $event->getLeague()->getId());
      $this->assertEquals('1415', $event->getSeason()->getName());
    }

    // Fake league.
    $events = $this->db->getEventsByLeagueAndSeason('FakeLeague123', 38);
    $this->assertEmpty($events);

    // Fake season.
    $events = $this->db->getEventsByLeagueAndSeason(4328, 'FakeSeason123');
    $this->assertEmpty($events);

    // Fake league and season.
    $events = $this->db->getEventsByLeagueAndSeason('FakeLeague123', 'FakeSeason123');
    $this->assertEmpty($events);
  }

  /**
   * @covers TheSportsDb\TheSportsDb::getSeasonsByLeague
   */
  public function testGetSeasonsByLeague() {
    $seasons = $this->db->getSeasonsByLeague(4328);
    $this->assertNotEmpty($seasons);

    foreach ($seasons as $season) {
      // Should be an event.
      $this->assertInstanceOf(SeasonInterface::class, $season);
      $this->assertEquals(4328, $season->getLeague()->getId());
    }

    // Try a fake league.
    $seasons = $this->db->getSeasonsByLeague('FakeLeague123');
    $this->assertEmpty($seasons);
  }

  /**
   * @covers TheSportsDb\TheSportsDb::setEntityManager
   */
  public function testSetEntityManager() {
    // Entity manager should be set during bootstrap.
    $this->expectException(\Exception::class);
    $this->expectExceptionMessage('Entity manager already set.');
    $this->db->setEntityManager($this->createMock(EntityManagerInterface::class));
  }

}