public function testRealSimpleTournament()
{
/** @var Tournament $tournament */
$tournament = $this->fixtures->getReference('tournament-0');
$engine = $this->getContainer()->get('fda.tournament.engine');
$engine->setTournament($tournament);
/** @var Player $referee */
$referee = $this->fixtures->getReference('player-3');
/** @var Board $board */
$board = $this->fixtures->getReference('board-0');
$ledger = $this->getContainer()->get('fda.ledger');
$ledger->setOwner($referee);
$ledger->setBoard($board);
// --- init done
// we should have 1 group
$this->assertCount(1, $engine->getCurrentRoundGears()->getGameGearsGrouped());
// 3 players ava should result in 3 games
$this->assertCount(3, $engine->getCurrentRoundGears()->getGameGearsGrouped()[0]);
// - select first game and play ...
$this->playGame0($engine, $ledger);
$this->checkLeaderBoard0($engine->getCurrentRoundGears()->getLeaderBoard());
// - play the rest
$this->playGame1($engine, $ledger);
$this->playGame2($engine, $ledger);
$this->checkLeaderBoardFinal($engine->getCurrentRoundGears()->getLeaderBoard());
}
/**
* Populates identities for stored references
*
* @param LifecycleEventArgs $args
*/
public function postPersist(LifecycleEventArgs $args)
{
$object = $args->getDocument();
if (($name = $this->referenceRepository->getReferenceName($object)) !== false) {
$identity = $args->getDocumentManager()->getUnitOfWork()->getDocumentIdentifier($object);
$this->referenceRepository->setReferenceIdentity($name, $identity);
}
}
/**
* Populates identities for stored references
*
* @param LifecycleEventArgs $args
*/
public function postPersist(LifecycleEventArgs $args)
{
$object = $args->getEntity();
if (($names = $this->referenceRepository->getReferenceNames($object)) !== false) {
foreach ($names as $name) {
$identity = $args->getEntityManager()->getUnitOfWork()->getEntityIdentifier($object);
$this->referenceRepository->setReferenceIdentity($name, $identity);
}
}
}
/**
* @param string $name
*
* @return object
*/
protected function getFixture($name)
{
$manager = $this->getKernel()->getContainer()->get('doctrine.orm.default_entity_manager');
if (!$this->referenceRepository->hasReference($name)) {
if (isset(static::$referenceRepositoryData[$name])) {
$reference = $manager->getReference(static::$referenceRepositoryData[$name]['class'], static::$referenceRepositoryData[$name]['identifier']);
$this->referenceRepository->setReference($name, $reference);
}
}
return $this->referenceRepository->getReference($name);
}
/**
* {@inheritdoc}
*/
public function load(ObjectManager $manager)
{
$menuRecords = [['icon' => 'user', 'position' => 1, 'title' => 'A propos', 'page' => $this->referenceRepository->getReference('page-1')]];
foreach ($menuRecords as $menuRecord) {
$menu = new Menu();
$menu->setIcon($menuRecord['icon']);
$menu->setPosition($menuRecord['position']);
$menu->setTitle($menuRecord['title']);
$menu->setPage($menuRecord['page']);
$manager->persist($menu);
}
$manager->flush();
}
public function testReferenceEntry()
{
$em = $this->getMockAnnotationReaderEntityManager();
$role = new TestEntity\Role();
$role->setName('admin');
$meta = $em->getClassMetadata(self::TEST_ENTITY_ROLE);
$meta->getReflectionProperty('id')->setValue($role, 1);
$referenceRepo = new ReferenceRepository($em);
$referenceRepo->addReference('test', $role);
$references = $referenceRepo->getReferences();
$this->assertEquals(1, count($references));
$this->assertArrayHasKey('test', $references);
$this->assertInstanceOf(self::TEST_ENTITY_ROLE, $references['test']);
}
/**
* {@inheritdoc}
*/
public function load(ObjectManager $manager)
{
$blogTagRecords = [];
for ($i = 0; $i < 10; ++$i) {
$blogTagRecords[] = ['title' => 'Tag #' . ($i + 1), 'description' => 'Description of the Tag #' . ($i + 1)];
}
foreach ($blogTagRecords as $blogTagRecord) {
$blogTag = new BlogTag();
$blogTag->setTitle($blogTagRecord['title']);
$blogTag->setDescription($blogTagRecord['description']);
$manager->persist($blogTag);
$manager->flush();
$this->referenceRepository->addReference('blog-tag-' . $blogTag->getId(), $blogTag);
}
}
/**
* @param string $referenceName
* @param bool $persist
* @param callable $objectLoader
* @return mixed
*/
protected function load($referenceName, $persist, \Closure $objectLoader, $defaultReferenceName = '')
{
if (is_null($referenceName)) {
$referenceName = $defaultReferenceName;
}
if ($this->referenceRepository->hasReference($referenceName)) {
return $this->referenceRepository->getReference($referenceName);
}
$object = $objectLoader($this, $referenceName);
if ($persist) {
$this->objectManager->persist($object);
}
$this->referenceRepository->setReference($referenceName, $object);
return $object;
}
/**
* @param ReferenceRepository $referenceRepository
*
* @throws \RuntimeException
*
* @return string
*/
public function serialize(ReferenceRepository $referenceRepository)
{
$references = array();
$isORM = $referenceRepository->getManager() instanceof EntityManager;
foreach ($referenceRepository->getReferences() as $name => $reference) {
$reference = $referenceRepository->getReference($name);
$references[$name]['identifier'] = $referenceRepository->getManager()->getUnitOfWork()->getEntityIdentifier($reference);
if ($reference instanceof Proxy) {
$ro = new \ReflectionObject($reference);
$references[$name]['class'] = $ro->getParentClass()->getName();
} else {
$references[$name]['class'] = get_class($reference);
}
}
return serialize($references);
}
/**
* {@inheritdoc}
*/
public function load(ObjectManager $manager)
{
$pageRecords = [['name' => 'about', 'title' => 'A propos', 'content' => '
**ok** *about* ***a propos***
### Hey
']];
foreach ($pageRecords as $pageRecord) {
$page = new Page();
$page->setName($pageRecord['name']);
$page->setTitle($pageRecord['title']);
$page->setContent($pageRecord['content']);
$manager->persist($page);
$manager->flush();
$this->referenceRepository->addReference('page-' . $page->getId(), $page);
}
}
/**
* {@inheritdoc}
*/
public function load(ObjectManager $manager)
{
$blogArticleRecords = [];
for ($i = 0; $i < 10; ++$i) {
$blogArticleRecords[] = ['title' => 'Article #' . ($i + 1), 'description' => 'Description of Article #' . ($i + 1), 'content' => 'Content of Article #' . ($i + 1)];
}
foreach ($blogArticleRecords as $blogArticleRecord) {
$blogArticle = new BlogArticle();
$blogArticle->setTitle($blogArticleRecord['title']);
$blogArticle->setDescription($blogArticleRecord['description']);
$blogArticle->setContent($blogArticleRecord['content']);
$blogArticle->setImageUrl('');
$blogArticle->setPublicationDate(new \DateTime());
$manager->persist($blogArticle);
$manager->flush();
$this->referenceRepository->addReference('blog-article-' . $blogArticle->getId(), $blogArticle);
}
}
/**
* {@inheritdoc}
*/
public function load(ObjectManager $manager)
{
$blogArticleTagRecords = [];
$blogTagIds = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
for ($i = 0; $i < 10; ++$i) {
$numberOfTags = rand(1, 10);
shuffle($blogTagIds);
for ($j = 0; $j < $numberOfTags; ++$j) {
$blogArticleTagRecords[] = ['article' => $this->referenceRepository->getReference('blog-article-' . ($i + 1)), 'tag' => $this->referenceRepository->getReference('blog-tag-' . $blogTagIds[$j])];
}
}
foreach ($blogArticleTagRecords as $blogArticleTagRecord) {
$blogArticleTag = new BlogArticleTag();
$blogArticleTag->setArticle($blogArticleTagRecord['article']);
$blogArticleTag->setTag($blogArticleTagRecord['tag']);
$manager->persist($blogArticleTag);
}
$manager->flush();
}
/**
* Returns an object from the manager
*
* @param string $class
* @param string $code
*
* @throws \Exception
*
* @return object
*/
protected function findObject($class, $code)
{
$reference = $class . '.' . $code;
if ($this->referenceRepository && $this->referenceRepository->hasReference($reference)) {
return $this->referenceRepository->getReference($reference);
} else {
$repository = $this->doctrine->getManagerForClass($class)->getRepository($class);
if (!$repository instanceof IdentifiableObjectRepositoryInterface) {
throw new \Exception(sprintf('Repository "%s" of class "%s" does not implement ' . '"Akeneo\\Component\\StorageUtils\\Repository\\IdentifiableObjectRepositoryInterface".', get_class($repository), $class));
}
return $repository->findOneByIdentifier($code);
}
}
protected function getRealSimpleTournament()
{
/** @var Board[] $boards */
$boards = array($this->fixtures->getReference('board-0'));
/** @var Player[] $players */
$players = array($this->fixtures->getReference('player-0'), $this->fixtures->getReference('player-1'), $this->fixtures->getReference('player-2'));
$tournamentSetup = new TournamentSetup();
$tournamentSetup->setSeed(RoundSetupSeed::create([[$players[0]->getId(), $players[1]->getId(), $players[2]->getId()]]));
$round1 = RoundSetupAva::createStraight();
$round1->setGameMode(new GameMode(GameMode::FIRST_TO, 3));
$round1->setLegMode(new LegMode(LegMode::SINGLE_OUT_301));
$tournamentSetup->addRound($round1);
$tournament = new Tournament();
$tournament->setName('real simple');
$tournament->setSetup($tournamentSetup);
$tournament->setBoards($boards);
$tournament->setPlayers($players);
/** @var \Doctrine\ORM\EntityManager $entityManager */
$entityManager = $this->getContainer()->get('doctrine.orm.default_entity_manager');
$entityManager->persist($tournament);
return $tournament;
}
/**
* Returns an object from the manager
*
* @param string $class
* @param string $code
*
* @return object
*/
protected function findObject($class, $code)
{
$reference = $class . '.' . $code;
if ($this->referenceRepository && $this->referenceRepository->hasReference($reference)) {
return $this->referenceRepository->getReference($reference);
} else {
$repository = $this->doctrine->getManagerForClass($class)->getRepository($class);
if (!$repository instanceof ReferableEntityRepositoryInterface) {
throw new \Exception(sprintf('Repository "%s" of class "%s" is not referable', get_class($repository), $class));
}
return $repository->findByReference($code);
}
}
public function testReferenceMultipleEntries()
{
$em = $this->getMockSqliteEntityManager();
$referenceRepository = new ReferenceRepository($em);
$em->getEventManager()->addEventSubscriber(new ORMReferenceListener($referenceRepository));
$schemaTool = new SchemaTool($em);
$schemaTool->createSchema(array($em->getClassMetadata(self::TEST_ENTITY_ROLE)));
$role = new TestEntity\Role();
$role->setName('admin');
$em->persist($role);
$referenceRepository->addReference('admin', $role);
$referenceRepository->addReference('duplicate', $role);
$em->flush();
$em->clear();
$this->assertInstanceOf('Doctrine\\ORM\\Proxy\\Proxy', $referenceRepository->getReference('admin'));
$this->assertInstanceOf('Doctrine\\ORM\\Proxy\\Proxy', $referenceRepository->getReference('duplicate'));
}
/**
* Check if an object is stored using reference
* named by $name
*
* @param string $name
* @see Doctrine\Common\DataFixtures\ReferenceRepository::hasReference
* @return boolean
*/
public function hasReference($name)
{
return $this->referenceRepository->hasReference($name);
}
/**
* {@inheritdoc}
*/
protected function getReference($name)
{
return $this->referenceRepository->getReference($name);
}
public function testGetIdentifierWhenHasNotBeenManagedYetByUnitOfWork()
{
$role = new Role();
$identitiesExpected = ['id' => 1];
/** @var UnitOfWork | ProphecyInterface $uow */
$uow = $this->prophesize(UnitOfWork::class);
$uow->isInIdentityMap($role)->shouldBeCalledTimes(2)->willReturn(true, false);
/** @var ClassMetadata $classMetadata */
$classMetadata = $this->prophesize(ClassMetadata::class);
$classMetadata->getIdentifierValues($role)->shouldBeCalled()->willReturn($identitiesExpected);
/** @var EntityManagerInterface | ProphecyInterface $em */
$em = $this->prophesize(EntityManagerInterface::class);
$em->getUnitOfWork()->shouldBeCalled()->willReturn($uow);
$em->getClassMetadata(Role::class)->shouldBeCalled()->willReturn($classMetadata);
$referenceRepository = new ReferenceRepository($em->reveal());
$referenceRepository->setReference('entity', $role);
$identities = $referenceRepository->getIdentities();
$this->assertEquals($identitiesExpected, $identities['entity']);
}
/**
* @expectedException OutOfBoundsException
* @expectedExceptionMessage Reference to: (foo) does not exist
*/
public function testUndefinedReference()
{
$em = $this->getMockSqliteEntityManager();
$referenceRepository = new ReferenceRepository($em);
$referenceRepository->getReference('foo');
}
public function testUndefinedReference()
{
$referenceRepository = new ReferenceRepository($this->getMockSqliteEntityManager());
$this->expectException(\OutOfBoundsException::class);
$this->expectExceptionMessage('Reference to: (foo) does not exist');
$referenceRepository->getReference('foo');
}
