/**
* Testing race conditions of new entities, without a flush between persist calls
*
* @see: docs/RaceConditions.md
* @dataProvider entityManagerDataProvider
* @param EntityManager $em
*/
public function testOneToManyRaceNoFlush(EntityManager $em)
{
$time = new \DateTime();
$article1 = new Article();
$article1->setId(201)->setTitle('Article 201')->setTimeCreated($time)->setLastModified($time);
$category1 = new Category();
$category1->setId(201)->setName('Category 201');
$category1->addArticle($article1);
$em->persist($category1)->persist($article1)->flush();
/** @var Article|OrmProxyInterface $r_article */
$r_article = $em->retrieve(Article::class, 201);
$this->assertEquals('Article 201', $r_article->getTitle());
// Should make DB query here
$r_category = $r_article->getCanonicalCategory();
$this->assertTrue($r_category instanceof Category);
// Check inverse side too -
/** @var Category|OrmProxyInterface $ir_category */
$ir_category = $em->retrieve(Category::class, 201);
$this->assertEquals('Category 201', $ir_category->getName());
// Should make DB query here
$ir_articles = $ir_category->getArticles();
$this->assertCount(1, $ir_articles);
$ir_article = $ir_articles[0];
$this->assertTrue($ir_article instanceof Article);
}
/**
* Loads the user for the given username.
*
* @param string $username The username
* @return UserInterface
* @throws UsernameNotFoundException if the user is not found
*
*/
public function loadUserByUsername($username)
{
try {
return $this->entity_manager->retrieve($this->user_class, $username);
} catch (NotFoundException $e) {
throw new UsernameNotFoundException("User '" . $username . "' not found");
}
}
/**
* Reads the session data.
*
* @param string $sessionId Session ID, see http://php.net/function.session-id
* @return string Same session data as passed in write() or empty string when non-existent or on failure
*/
public function read($sessionId)
{
try {
/** @var SessionInterface $entity */
$entity = $this->entity_manager->retrieve($this->session_class, $sessionId);
return $entity->getData();
} catch (NotFoundException $e) {
return '';
}
}
/**
* @dataProvider entityManagerDataProvider
* @param EntityManager $em
*/
public function testForwardConditionalRelationship(EntityManager $em)
{
$category = new Category();
$category->setId(1000)->setName('Conditional Category');
$em->persist($category)->flush();
for ($i = 45; $i < 56; $i++) {
$article = new Article();
$article->setId($i)->setTitle('Conditional Article #' . $i);
if ($i == 53) {
$article->setPublished(false);
} else {
$article->setPublished(true);
}
$category->addArticle($article);
$em->persist($article);
}
for ($i = 45; $i < 56; $i++) {
$asset = new Asset();
$asset->setId($i)->setTitle('Conditional Asset #' . $i);
if ($i == 53) {
$asset->setPublished(false);
} else {
$asset->setPublished(true);
}
$category->addAsset($asset);
$em->persist($asset);
}
$em->persist($category)->flush();
$articles = $em->sortedQuery(new SortedQuery($category, 'articles', 'last_modified'));
$this->assertCount(4, $articles);
$articles = $em->sortedQuery(new SortedQuery($category, 'articles', 'last_modified_all'));
$this->assertCount(10, $articles);
$articles = $em->sortedQuery(new SortedQuery($category, 'articles', 'id'));
$this->assertCount(11, $articles);
// Update an entity to make it fail the condition -
$article = $em->retrieve(Article::class, 54);
$article->setPublished(false);
$em->persist($article)->flush();
$articles = $em->sortedQuery(new SortedQuery($category, 'articles', 'last_modified'));
$this->assertCount(3, $articles);
/**
* Assert against Assets
*/
$assets = $em->sortedQuery(new SortedQuery($category, 'assets', 'last_modified'));
$this->assertCount(4, $assets);
$assets = $em->sortedQuery(new SortedQuery($category, 'assets', 'id'));
$this->assertCount(11, $assets);
// Update an entity to make it fail the condition -
$asset = $em->retrieve(Asset::class, 54);
$asset->setPublished(false);
$em->persist($asset)->flush();
$assets = $em->sortedQuery(new SortedQuery($category, 'assets', 'last_modified'));
$this->assertCount(3, $assets);
}
/**
* Hydrate an entity
*
* @param string $id
* @return $this
*/
private function hydrateEntity($id)
{
try {
$this->entities[$id] = $this->entity_manager->retrieve($this->query->getClassName(), $id, $this->use_cache);
} catch (NotFoundException $e) {
throw new CorruptedEntityException("Entity in sorted index not found: " . $e->getMessage(), 0, $e);
}
return $this;
}
/**
* Testing race conditions of new entities, without a flush between persist calls
* @see: docs/RaceConditions.md
* @dataProvider entityManagerDataProvider
* @param EntityManager $em
*/
public function testOneToOneRaceNoFlush(EntityManager $em)
{
$user = new User();
$user->setId(102)->setName('Ray');
$address = new Address();
$address->setId(502)->setStreet('Purchase St');
$user->setAddress($address);
$em->persist($user)->persist($address)->flush();
/** @var User|OrmProxyInterface $r_user */
$r_user = $em->retrieve(User::class, 102);
$this->assertEquals('Ray', $r_user->getName());
// Should make DB query here
$r_address = $r_user->getAddress();
$this->assertTrue($r_address instanceof Address);
$this->assertTrue($r_address instanceof OrmProxyInterface);
}
/**
* @dataProvider entityManagerDataProvider
* @param EntityManager $em
*/
public function testIndex(EntityManager $em)
{
$entity = new IndexedEntity();
$entity->setId1(100)->setId2('id2');
$entity->setAlpha('alpha')->setBravo('200')->setCharlie(true);
$metadata = $em->getMapper()->getEntityMetadata($entity);
$reader = new Reader($metadata, $entity);
$this->assertEquals('100.id2', $reader->getId());
$indices = $metadata->getIndices();
$this->assertCount(3, $indices);
$ab = $metadata->getIndexByName('ab');
$this->assertContains('alpha', $ab->getColumns());
$this->assertContains('bravo', $ab->getColumns());
$this->assertCount(2, $ab->getColumns());
$this->assertEquals('alpha.200', $reader->getIndexValue($ab));
$bc = $metadata->getIndexByName('bc');
$this->assertContains('bravo', $bc->getColumns());
$this->assertContains('getCharlie', $bc->getMethods());
$this->assertCount(1, $bc->getColumns());
$this->assertCount(1, $bc->getMethods());
$this->assertEquals('200.1', $reader->getIndexValue($bc));
$b = $metadata->getIndexByName('b');
$this->assertContains('bravo', $b->getColumns());
$this->assertCount(1, $b->getColumns());
$this->assertEquals('200', $reader->getIndexValue($b));
$em->persist($entity)->flush();
/** @var IndexedEntity $retrieved */
$retrieved = $em->retrieve(self::INDEXED_ENTITY, '100.id2');
$retrieved->setAlpha('omega')->setId1(101);
$em->persist($retrieved)->flush();
try {
$em->retrieveByIndex(self::INDEXED_ENTITY, 'ab', 'alpha.200');
$this->fail("Former index was found");
} catch (NotFoundException $e) {
}
/** @var IndexedEntity $retrieved_by_index */
$retrieved_by_index = $em->retrieveByIndex(self::INDEXED_ENTITY, 'ab', 'omega.200');
$this->assertEquals(101, $retrieved_by_index->getId1());
$this->assertEquals('id2', $retrieved_by_index->getId2());
$this->assertSame('omega', $retrieved_by_index->getAlpha());
$this->assertSame(200, $retrieved_by_index->getBravo());
$this->assertSame(true, $retrieved_by_index->getCharlie());
}
/**
* @dataProvider entityManagerDataProvider
* @param EntityManager $em
* @expectedException \Bravo3\Orm\Exceptions\CorruptedEntityException
*/
public function testSortedQueryThrowsNotFoundException(EntityManager $em)
{
$category = (new Category())->setId(5000);
$article1 = (new Article())->setId(5001)->setTitle('A');
$article2 = (new Article())->setId(5002)->setTitle('B');
$article3 = (new Article())->setId(5003)->setTitle('C');
$category->addArticle($article1);
$category->addArticle($article2);
$category->addArticle($article3);
$em->persist($article1)->persist($article2)->persist($article3)->persist($category)->flush();
// Forcefully break the relationship via the driver manually
$em->getDriver()->delete($em->getKeyScheme()->getEntityKey('article', '5001'));
$em->getDriver()->flush();
$category = $em->retrieve(Category::class, 5000, false);
$results = $em->sortedQuery(new SortedQuery($category, 'articles', 'sort_date'));
// Iterating through these results should trigger an exception
foreach ($results as $result) {
}
}
/**
* Hydrate a relationship
*
* @param Relationship $relative
* @return $this
*/
public function hydrateRelative(Relationship $relative)
{
$this->entity_manager->getDriver()->debugLog("Hydrating relative for " . $this->metadata->getTableName() . "[" . $this->getReader()->getId() . "]::" . $relative->getName());
$setter = $relative->getSetter();
$key = $this->entity_manager->getKeyScheme()->getRelationshipKey($relative, $this->entity_manager->getMapper()->getEntityMetadata($relative->getSource())->getTableName(), $this->entity_manager->getMapper()->getEntityMetadata($relative->getTarget())->getTableName(), $this->getReader()->getId());
if (RelationshipType::isMultiIndex($relative->getRelationshipType())) {
$items = [];
$ids = $this->entity_manager->getDriver()->getMultiValueIndex($key);
foreach ($ids as $id) {
$items[] = $this->entity_manager->retrieveEntityOrNew($relative->getTarget(), $id);
}
$this->proxy->{$setter}($items);
} else {
$id = $this->entity_manager->getDriver()->getSingleValueIndex($key);
if ($id) {
$this->proxy->{$setter}($this->entity_manager->retrieve($relative->getTarget(), $id));
}
}
return $this;
}
/**
* @dataProvider entityManagerDataProvider
* @param EntityManager $em
*/
public function testRebuildIndicesManyToMany(EntityManager $em)
{
$charlie = new Charlie();
$charlie->setId('charlie')->setName('Charlie');
$delta = new Delta();
$delta->setId('delta')->setName('Delta');
$charlie->setDelta([$delta]);
$em->persist($charlie)->persist($delta)->flush();
$c = $em->retrieve(Charlie::class, 'charlie');
$this->assertEquals('Charlie', $c->getName());
$this->assertCount(1, $c->getDelta());
/** @var Delta $d */
$d = $c->getDelta()[0];
$this->assertEquals('Delta', $d->getName());
$maintenance = new Maintenance($em);
$maintenance->rebuild(CharlieRevised::class);
/** @var DeltaRevised $d */
$d = $em->retrieve(DeltaRevised::class, 'delta');
$this->assertEquals('Delta', $d->getName());
$this->assertCount(1, $d->getCharlie());
/** @var CharlieRevised $c */
$c = $d->getCharlie()[0];
$this->assertEquals('Charlie', $c->getName());
}
/**
* @dataProvider entityManagerDataProvider
* @param EntityManager $em
*/
public function testSortOrder(EntityManager $em)
{
$category = new Category();
$category->setId(600);
$em->persist($category);
for ($i = 0; $i < 15; $i++) {
$article = new Article();
$article->setId(601 + $i);
$article->setTitle('Art ' . (601 + $i));
$time = new \DateTime();
$time->modify('+' . ($i + 1) . ' minutes');
$article->setSortDate($time);
$article->setCanonicalCategory($category);
$em->persist($article);
}
$em->flush();
/** @var Article $article */
// Date sorting -
$results = $em->sortedQuery(new SortedQuery($category, 'articles', 'sort_date'));
$this->assertCount(15, $results);
$article = $results[0];
$this->assertEquals('Art 601', $article->getTitle());
$results = $em->sortedQuery(new SortedQuery($category, 'articles', 'sort_date', Direction::DESC()));
$this->assertCount(15, $results);
$this->assertEquals(15, $results->getFullSize());
$article = $results[0];
$this->assertEquals('Art 615', $article->getTitle());
$results = $em->sortedQuery(new SortedQuery($category, 'articles', 'sort_date', Direction::DESC(), 5, -6), true);
$this->assertCount(5, $results);
$this->assertEquals(15, $results->getFullSize());
$article = $results[0];
$this->assertEquals('Art 610', $article->getTitle());
$article = $results[4];
$this->assertEquals('Art 606', $article->getTitle());
$results = $em->sortedQuery(new SortedQuery($category, 'articles', 'sort_date', Direction::ASC(), 2, 5));
$this->assertCount(4, $results);
$this->assertNull($results->getFullSize());
$article = $results[0];
$this->assertEquals('Art 603', $article->getTitle());
$results = $em->sortedQuery(new SortedQuery($category, 'articles', 'sort_date', Direction::ASC(), 20, 29));
$this->assertCount(0, $results);
$results = $em->sortedQuery(new SortedQuery($category, 'articles', 'title'));
$this->assertCount(15, $results);
$article = $results[0];
$this->assertEquals('Art 601', $article->getTitle());
// Lexicographic sorting -
$results = $em->sortedQuery(new SortedQuery($category, 'articles', 'title'));
$this->assertCount(15, $results);
$article = $results[0];
$this->assertEquals('Art 601', $article->getTitle());
$results = $em->sortedQuery(new SortedQuery($category, 'articles', 'title', Direction::DESC()));
$this->assertCount(15, $results);
$article = $results[0];
$this->assertEquals('Art 615', $article->getTitle());
// Modify an entity's sort-by column
$article = $em->retrieve(Article::class, 609);
$time = $article->getSortDate();
$time->modify('+1 day');
$article->setSortDate($time);
$em->persist($article)->flush();
$results = $em->sortedQuery(new SortedQuery($category, 'articles', 'sort_date', Direction::DESC()));
$this->assertCount(15, $results);
$article = $results[0];
$this->assertEquals('Art 609', $article->getTitle());
}
/**
* @dataProvider entityManagerDataProvider
* @param EntityManager $em
*/
public function testNullObjectSerialisation(EntityManager $em)
{
$product = new Product();
$product->setId(701)->setEnum(null);
$em->persist($product)->flush();
/** @var Product $r_product */
$r_product = $em->retrieve(Product::class, '701');
$this->assertNull($r_product->getEnum());
}
