public function testProxyFactorySetsProxyMetadata()
{
$proxy = $this->dm->getReference($this->type, 1);
$proxyClass = get_class($proxy);
$this->assertTrue($this->dm->getClassMetadataFactory()->hasMetadataFor($proxyClass), "Proxy class '" . $proxyClass . "' should be registered as metadata.");
$this->assertSame($this->dm->getClassMetadata($proxyClass), $this->dm->getClassMetadata($this->type), "Metadata instances of proxy class and real instance have to be the same.");
}
public function setUp()
{
$this->db('PHPCR')->loadFixtures(array('Doctrine\\Bundle\\PHPCRBundle\\Tests\\Resources\\DataFixtures\\PHPCR\\LoadData'));
$this->dm = $this->db('PHPCR')->getOm();
$this->document = $this->dm->find(null, '/test/doc');
$this->assertNotNull($this->document, 'fixture loading not working');
$this->referrer = $this->dm->find(null, '/test/ref');
$this->assertNotNull($this->referrer, 'fixture loading not working');
}
public function testFind()
{
$doc = $this->dm->find($this->type, '/functional/thename');
$this->assertInstanceOf($this->type, $doc);
$this->assertEquals('/functional/thename', $doc->id);
$this->assertEquals('thename', $doc->nodename);
$this->assertNotNull($doc->parent);
$this->assertEquals('/functional', $doc->parent->getId());
return $doc;
}
public function testReferenceOneDifferentTargetDocuments()
{
$ref1 = new MODEL\RefType1TestObj();
$ref1->id = '/functional/ref1';
$ref1->name = 'Ref1';
$ref2 = new MODEL\RefType2TestObj();
$ref2->id = '/functional/ref2';
$ref2->name = 'Ref2';
$this->dm->persist($ref1);
$this->dm->persist($ref2);
$referer1 = new ReferenceOneObj();
$referer1->id = '/functional/referer1';
$referer1->reference = $ref1;
$this->dm->persist($referer1);
$referer2 = new ReferenceOneObj();
$referer2->id = '/functional/referer2';
$referer2->reference = $ref2;
$this->dm->persist($referer2);
$this->dm->flush();
$this->dm->clear();
$referer = $this->dm->find('Doctrine\\Tests\\ODM\\PHPCR\\Functional\\ReferenceOneObj', '/functional/referer1');
$this->assertTrue($referer->reference instanceof MODEL\RefType1TestObj);
$referer = $this->dm->find('Doctrine\\Tests\\ODM\\PHPCR\\Functional\\ReferenceOneObj', '/functional/referer2');
$this->assertTrue($referer->reference instanceof MODEL\RefType2TestObj);
}
public function testPropertyname()
{
$doc = new PropertyTestObj();
$doc->id = '/functional/p';
$doc->string = 'astring';
$doc->long = 123;
$doc->int = 321;
$doc->decimal = '343';
$doc->double = 3.14;
$doc->float = 2.8;
$date = new \DateTime();
$doc->date = $date;
$doc->boolean = true;
$doc->name = 'aname';
$doc->path = '../';
$doc->uri = 'http://cmf.symfony.com:8080/about.html#there';
$this->dm->persist($doc);
$this->dm->flush();
$this->dm->clear();
$this->assertTrue($this->node->getNode('p')->hasProperty('string'));
$this->assertTrue($this->node->getNode('p')->hasProperty('long'));
$this->assertTrue($this->node->getNode('p')->hasProperty('int'));
$this->assertTrue($this->node->getNode('p')->hasProperty('decimal'));
$this->assertTrue($this->node->getNode('p')->hasProperty('double'));
$this->assertTrue($this->node->getNode('p')->hasProperty('float'));
$this->assertTrue($this->node->getNode('p')->hasProperty('date'));
$this->assertTrue($this->node->getNode('p')->hasProperty('boolean'));
$this->assertTrue($this->node->getNode('p')->hasProperty('name'));
$this->assertTrue($this->node->getNode('p')->hasProperty('path'));
$this->assertTrue($this->node->getNode('p')->hasProperty('uri'));
$doc = $this->dm->find($this->type, '/functional/p');
$this->assertNotNull($doc->string);
$this->assertEquals('astring', $doc->string);
$this->assertNotNull($doc->long);
$this->assertEquals(123, $doc->long);
$this->assertNotNull($doc->int);
$this->assertEquals(321, $doc->int);
$this->assertNotNull($doc->decimal);
$this->assertEquals('343', $doc->decimal);
$this->assertNotNull($doc->double);
$this->assertEquals(3.14, $doc->double);
$this->assertNotNull($doc->float);
$this->assertEquals(2.8, $doc->float);
$this->assertNotNull($doc->date);
$this->assertEquals($date->getTimestamp(), $doc->date->getTimestamp());
$this->assertNotNull($doc->boolean);
$this->assertEquals(true, $doc->boolean);
$this->assertNotNull($doc->name);
$this->assertEquals('aname', $doc->name);
$this->assertNotNull($doc->path);
$this->assertEquals('../', $doc->path);
$this->assertNotNull($doc->uri);
$this->assertEquals('http://cmf.symfony.com:8080/about.html#there', $doc->uri);
}
/**
* @depends testCreateBulkUpdater
*/
public function testGetChanges()
{
$updater = $this->couchClient->createBulkUpdater();
$updater->updateDocument(array("_id" => "test1", "foo" => "bar"));
$updater->updateDocument(array("_id" => "test2", "bar" => "baz"));
$updater->execute();
$changes = $this->couchClient->getChanges();
$this->assertArrayHasKey('results', $changes);
$this->assertEquals(2, count($changes['results']));
$this->assertEquals(2, $changes['last_seq']);
}
public function testCreateFromFile()
{
$parent = new FixPHPCR1TestObj();
$parent->id = '/functional/filetest';
$this->dm->persist($parent);
$parent->file = new File();
$parent->file->setFileContentFromFilesystem(dirname(__FILE__) . '/_files/foo.txt');
$this->dm->flush();
$this->dm->clear();
$this->assertTrue($this->node->getNode('filetest')->hasNode('file'));
$this->assertTrue($this->node->getNode('filetest')->getNode('file')->hasNode('jcr:content'));
$this->assertTrue($this->node->getNode('filetest')->getNode('file')->getNode('jcr:content')->hasProperty('jcr:data'));
}
public function testCreatedDate()
{
$parent = new FileTestObj();
$parent->file = new File();
$parent->id = '/functional/filetest';
$parent->file->setFileContentFromFilesystem(dirname(__FILE__) . '/_files/foo.txt');
$this->dm->persist($parent);
$this->dm->flush();
$this->dm->clear();
$file = $this->dm->find('Doctrine\\ODM\\PHPCR\\Document\\File', '/functional/filetest/file');
$this->assertNotNull($file);
$this->assertNotNull($file->getCreated());
}
public function save(AbstractEntity $entity)
{
if ($entity->getStorageStructure() == AbstractEntity::DOCUMENT) {
$dm = new DocumentManager();
$document = $entity->toDocument();
$dm->persist($document);
}
if ($entity->getStorageStructure() == AbstractEntity::RELATIONAL) {
$rm = new RecordManager();
$record = $entity->toRecord();
$rm->save($record);
}
}
/**
* Finds a document by its identifier.
*
* @param $id The identifier.
* @param int $lockMode
* @param int $lockVersion
* @return object The document.
*/
public function find($id, $lockMode = LockMode::NONE, $lockVersion = null)
{
// Check identity map first
if ($document = $this->uow->tryGetById($id, $this->class->rootDocumentName)) {
if ($lockMode != LockMode::NONE) {
$this->dm->lock($document, $lockMode, $lockVersion);
}
return $document;
// Hit!
}
$id = array('_id' => $id);
if ($lockMode == LockMode::NONE) {
return $this->uow->getDocumentPersister($this->documentName)->load($id);
} else {
if ($lockMode == LockMode::OPTIMISTIC) {
if (!$this->class->isVersioned) {
throw LockException::notVersioned($this->documentName);
}
$document = $this->uow->getDocumentPersister($this->documentName)->load($id);
$this->uow->lock($document, $lockMode, $lockVersion);
return $document;
} else {
return $this->uow->getDocumentPersister($this->documentName)->load($id, null, array(), $lockMode);
}
}
}
/**
* @expectedException \InvalidArgumentException
*/
public function testDetachWithRemove()
{
$user = $this->dm->find($this->type, '/functional/user');
$user->username = "******";
$this->dm->detach($user);
$this->dm->remove($user);
}
function fixDocumentNameCallback($p_event, &$p_header)
{
global $remove_dir;
$files = Session::read('doc_files_to_download');
$storedFile = $remove_dir . $p_header['stored_filename'];
if (!isset($files[$storedFile])) {
return 0;
}
$documentData = $files[$storedFile];
$documentNameFixed = DocumentManager::undoFixDocumentName($documentData['path'], $documentData['c_id'], $documentData['session_id'], $documentData['to_group_id']);
// Changes file.phps to file.php
$basename = basename($documentNameFixed);
$basenamePHPFixed = str_replace('.phps', '.php', $basename);
$documentNameFixed = str_replace($basename, $basenamePHPFixed, $documentNameFixed);
if ($remove_dir != '/') {
$documentNameFixed = str_replace($remove_dir, '/', $documentNameFixed);
if (substr($documentNameFixed, 0, 1) == '/') {
$documentNameFixed = substr($documentNameFixed, 1, api_strlen($documentNameFixed));
}
} else {
$documentNameFixed = ltrim($documentNameFixed, '/');
}
$p_header['stored_filename'] = $documentNameFixed;
return 1;
}
public function testReorderChildren()
{
$this->testModifyChildren();
try {
$parent = $this->dm->find('Doctrine\\Tests\\ODM\\PHPCR\\Functional\\ChildrenTestObj', '/functional/parent');
$this->assertCount(2, $parent->allChildren);
$data = array('child-g' => $parent->allChildren->last(), 'child-f' => $parent->allChildren->first());
$parent->allChildren = new ArrayCollection($data);
$this->dm->flush();
$this->dm->clear();
$parent = $this->dm->find('Doctrine\\Tests\\ODM\\PHPCR\\Functional\\ChildrenTestObj', '/functional/parent');
$this->assertCount(count($data), $parent->allChildren);
$this->assertEquals(array_keys($data), $parent->allChildren->getKeys());
$child1 = new ChildrenTestObj();
$child1->name = 'Child H';
$child2 = new ChildrenTestObj();
$child2->name = 'Child I';
$child3 = new ChildrenTestObj();
$child3->name = 'Child J';
$data = array('child-i' => $child2, 'child-h' => $child1, 'child-f' => $parent->allChildren->last(), 'child-g' => $parent->allChildren->first(), 'child-j' => $child3);
$parent->allChildren = new ArrayCollection($data);
$this->dm->flush();
$this->dm->clear();
$parent = $this->dm->find('Doctrine\\Tests\\ODM\\PHPCR\\Functional\\ChildrenTestObj', '/functional/parent');
$this->assertCount(count($data), $parent->allChildren);
$this->assertEquals(array_keys($data), $parent->allChildren->getKeys());
} catch (UnsupportedRepositoryOperationException $e) {
$this->markTestSkipped('Reordering of children not supported');
}
}
public function testPropertyname()
{
$doc = new TestObj();
$doc->id = '/functional/pn';
$doc->name = 'Testname';
$doc->othername = 'Testothername';
$this->dm->persist($doc);
$this->dm->flush();
$this->dm->clear();
$this->assertTrue($this->node->getNode('pn')->hasProperty('name'));
$this->assertTrue($this->node->getNode('pn')->hasProperty('myname'));
$doc = $this->dm->find($this->type, '/functional/pn');
$this->assertNotNull($doc->name);
$this->assertEquals('Testname', $doc->name);
$this->assertNotNull($doc->othername);
$this->assertEquals('Testothername', $doc->othername);
}
function testProxyForChildIsUsed()
{
$doc = $this->dm->find($this->type, '/functional/thename');
$doc->child = new NameDoc();
$this->dm->flush();
$this->dm->clear();
$doc = $this->dm->find($this->type, '/functional/thename');
$this->assertTrue($doc->child instanceof Proxy);
}
public function testCascadeRemoveReferrer()
{
$user = new \Doctrine\Tests\Models\CMS\CmsUser();
$user->username = '******';
$user->name = 'Benjamin';
$this->dm->persist($user);
$this->dm->flush();
$this->dm->flush();
}
public function testCascadeRefresh()
{
$group1 = new \Doctrine\Tests\Models\CMS\CmsGroup();
$group1->name = "Test!";
$user = new \Doctrine\Tests\Models\CMS\CmsUser();
$user->username = "******";
$user->name = "Benjamin";
$user->addGroup($group1);
$this->dm->persist($user);
$this->dm->persist($group1);
$this->dm->flush();
$this->assertEquals(1, count($user->groups));
$group1->name = "Test2";
$user->username = "******";
$this->dm->refresh($user);
$this->assertEquals("beberlei", $user->username);
$this->assertEquals("Test!", $group1->name);
}
function testChildOfRoot()
{
$root = $this->dm->find(null, '/');
$child = new NameDoc();
$child->parent = $root;
$child->nodename = 'childOfRoot';
$this->dm->persist($child);
$this->dm->flush();
$this->assertEquals('/childOfRoot', $child->id);
}
public function testRemoveChildParent()
{
$parent = $this->dm->find('Doctrine\\Tests\\ODM\\PHPCR\\Functional\\ChildrenTestObj', '/functional/parent');
$this->assertCount(4, $parent->allChildren);
$this->dm->remove($parent);
$this->dm->flush();
$this->dm->clear();
$parent = $this->dm->find('Doctrine\\Tests\\ODM\\PHPCR\\Functional\\ChildrenTestObj', '/functional/parent');
$this->assertNull($parent);
}
public function testCreateCascade()
{
$folder = new Folder();
$folder->setId('/functional/folder');
$file = new File();
$file->setFileContent('Lorem ipsum dolor sit amet');
$file->setNodename('file');
$folder->addChild($file);
$this->dm->persist($folder);
$this->dm->flush();
$this->dm->clear();
$this->assertTrue($this->node->hasNode('folder'));
$this->assertTrue($this->node->getNode('folder')->hasNode('file'));
$this->assertTrue($this->node->getNode('folder')->getNode('file')->hasNode('jcr:content'));
$this->assertTrue($this->node->getNode('folder')->getNode('file')->getNode('jcr:content')->hasProperty('jcr:data'));
$binaryStream = $this->node->getNode('folder')->getNode('file')->getNode('jcr:content')->getProperty('jcr:data')->getBinary();
$content = stream_get_contents($binaryStream);
$this->assertEquals('Lorem ipsum dolor sit amet', $content);
}
public function testQueryLimit()
{
$query = $this->dm->createQuery('SELECT * FROM [nt:unstructured] WHERE ISCHILDNODE("/functional") ORDER BY username', \PHPCR\Query\QueryInterface::JCR_SQL2);
$this->assertInstanceOf('PHPCR\\Query\\QueryInterface', $query);
$query->setLimit(2);
$result = $this->dm->getDocumentsByQuery($query, $this->type);
$this->assertCount(2, $result);
$ids = array();
$vals = array();
$nums = array();
foreach ($result as $obj) {
$this->assertInstanceOf('Doctrine\\Tests\\ODM\\PHPCR\\Functional\\QuerySql2TestObj', $obj);
$ids[] = $obj->id;
$vals[] = $obj->username;
$this->assertInstanceOf('Doctrine\\Common\\Collections\\Collection', $obj->numbers);
$nums[] = $obj->numbers->toArray();
}
$this->assertEquals(array('/functional/node5', '/functional/node1'), $ids);
$this->assertEquals(array(null, 'dbu'), $vals);
$this->assertEquals(array(array(3, 1, 2), array(3, 1, 2)), $nums);
}
public function testLuceneIndexing()
{
$this->dm->getConfiguration()->addDesignDocument('lucene_users', 'Doctrine\\Tests\\ODM\\CouchDB\\Functional\\LuceneQueryDesignDoc', array());
$query = $this->dm->createLuceneQuery('lucene_users', 'by_name');
$response = $query->createDesignDocument();
$user1 = new \Doctrine\Tests\Models\CMS\CmsUser();
$user1->username = "******";
$user1->status = "active";
$user1->name = "Benjamin";
$user2 = new \Doctrine\Tests\Models\CMS\CmsUser();
$user2->username = "******";
$user2->status = "active";
$user2->name = "Lukas";
$this->dm->persist($user1);
$this->dm->persist($user2);
$this->dm->flush();
$query->setQuery("Lukas");
try {
$result = $query->execute();
} catch (\Doctrine\CouchDB\HTTP\HTTPException $e) {
if ($e->getCode() == 404) {
$this->markTestSkipped("Lucene is not integrated");
} else {
throw $e;
}
}
$this->assertEquals(1, count($result));
foreach ($result as $user) {
$this->assertEquals($user2->id, $user['id']);
$this->assertEquals(1, $user['score']);
}
$query->setIncludeDocs(true)->setDocumentName('Doctrine\\Tests\\Models\\CMS\\CmsUser');
$result = $query->execute();
$this->assertSame($user2, $result[0]['doc']);
}
public function testRemoveThenMove()
{
$this->dm->clear();
$user = $this->dm->find($this->type, '/functional/lsmith');
$this->assertNotNull($user, 'User must exist');
$this->dm->remove($user);
$this->dm->move($user, '/functional/user2');
$this->dm->flush();
$user = $this->dm->find($this->type, '/functional/user2');
$this->assertNotNull($user, 'User must exist');
$user = $this->dm->find($this->type, '/functional/lsmith');
$this->assertNull($user, 'User must be null after deletion');
}
public function testFindByManyConstraints()
{
for ($i = 0; $i < 10; $i++) {
$user = new \Doctrine\Tests\Models\CMS\CmsUser();
$user->username = "******" . $i;
$user->status = $i % 2 == 0 ? "active" : "inactive";
$user->name = "Benjamin" . $i;
$this->dm->persist($user);
}
$this->dm->flush();
$users = $this->dm->getRepository('Doctrine\\Tests\\Models\\CMS\\CmsUser')->findBy(array('username' => 'beberlei0'));
$this->assertEquals(1, count($users));
$this->assertEquals('beberlei0', $users[0]->username);
}
public function testFindByReusesIdentities()
{
$this->dm = $this->createDocumentManager();
$user = new \Doctrine\Tests\Models\CMS\CmsUser();
$user->username = "******";
$user->status = "active";
$user->name = "Benjamin";
$this->dm->persist($user);
$this->dm->flush();
$this->dm->clear();
$user1 = $this->dm->getRepository('Doctrine\\Tests\\Models\\CMS\\CmsUser')->findOneBy(array('username' => 'beberlei'));
$user2 = $this->dm->getRepository('Doctrine\\Tests\\Models\\CMS\\CmsUser')->findOneBy(array('username' => 'beberlei'));
$this->assertSame($user1, $user2);
}
public function testSecoundLevelOverwrite()
{
$localePrefs = array('en' => array('en', 'de'), 'de' => array('de', 'en'));
$this->dm->setLocaleChooserStrategy(new LocaleChooser($localePrefs, 'en'));
$secondTrans = new SecondLevelWithDuplicateOverwrite();
$secondTrans->id = '/functional/secondTrans';
$secondTrans->text = 'deutsch';
$this->dm->persist($secondTrans);
$this->dm->bindTranslation($secondTrans, 'de');
$secondTrans->text = 'english';
$this->dm->bindTranslation($secondTrans, 'en');
$this->dm->flush();
$tmpDocDe = $this->dm->findTranslation(null, '/functional/secondTrans', 'de');
$this->assertEquals($tmpDocDe->text, 'deutsch');
$tmpDocEn = $this->dm->findTranslation(null, '/functional/secondTrans', 'en');
$this->assertEquals($tmpDocEn->text, 'english');
}
public function testAddRemoveAttachment()
{
$fh = fopen(__DIR__ . '/_files/logo.jpg', 'r');
$user = $this->dm->find('Doctrine\\Tests\\Models\\CMS\\CmsUser', 'user_with_attachment');
$user->attachments['logo.jpg'] = Attachment::createFromBinaryData($fh, 'image/jpeg');
$this->dm->flush();
$this->dm->clear();
// dont re-use identity map
$user = $this->dm->find('Doctrine\\Tests\\Models\\CMS\\CmsUser', 'user_with_attachment');
unset($user->attachments['foo.txt']);
$this->dm->flush();
$this->dm->clear();
// dont re-use identity map
$user = $this->dm->find('Doctrine\\Tests\\Models\\CMS\\CmsUser', 'user_with_attachment');
$this->assertArrayHasKey('logo.jpg', $user->attachments);
$this->assertArrayNotHasKey('foo.txt', $user->attachments);
}
public function testCascadeRemoveSingleDocument()
{
$user = new \Doctrine\Tests\Models\CMS\CmsUser();
$user->username = "******";
$user->name = "Benjamin";
$article = new \Doctrine\Tests\Models\CMS\CmsArticle();
$article->text = "foo";
$article->topic = "bar";
$article->user = $user;
$this->dm->persist($article);
$this->dm->persist($user);
$this->dm->flush();
$this->dm->remove($article);
$this->dm->flush();
$this->assertFalse($this->dm->contains($user));
$this->assertFalse($this->dm->contains($article));
}
public function testCascadeManagedDocumentReferenceDuringFlush()
{
$article = new \Doctrine\Tests\Models\CMS\CmsArticle();
$article->text = "foo";
$article->topic = "bar";
$this->dm->persist($article);
$user = new \Doctrine\Tests\Models\CMS\CmsUser();
$user->username = "******";
$user->name = "Benjamin";
$article->user = $user;
$this->assertFalse($this->dm->contains($user));
$this->dm->flush();
$this->dm->clear();
$article = $this->dm->find('Doctrine\\Tests\\Models\\CMS\\CmsArticle', $article->id);
$this->assertEquals($user->id, $article->user->getId());
}
public function testIdStrategy()
{
$metadata = $this->dm->getClassMetadata('\\Doctrine\\Tests\\ODM\\PHPCR\\Functional\\Mapping\\ParentIdStrategy');
$this->assertEquals(ClassMetadata::GENERATOR_TYPE_PARENT, $metadata->idGenerator, 'parentId');
$metadata = $this->dm->getClassMetadata('\\Doctrine\\Tests\\ODM\\PHPCR\\Functional\\Mapping\\ParentIdStrategyDifferentOrder');
$this->assertEquals(ClassMetadata::GENERATOR_TYPE_PARENT, $metadata->idGenerator, 'parentId2');
$metadata = $this->dm->getClassMetadata('\\Doctrine\\Tests\\ODM\\PHPCR\\Functional\\Mapping\\AssignedIdStrategy');
$this->assertEquals(ClassMetadata::GENERATOR_TYPE_ASSIGNED, $metadata->idGenerator, 'assigned');
$metadata = $this->dm->getClassMetadata('\\Doctrine\\Tests\\ODM\\PHPCR\\Functional\\Mapping\\RepositoryIdStrategy');
$this->assertEquals(ClassMetadata::GENERATOR_TYPE_REPOSITORY, $metadata->idGenerator, 'repository');
$metadata = $this->dm->getClassMetadata('\\Doctrine\\Tests\\ODM\\PHPCR\\Functional\\Mapping\\AutoAssignedIdStrategy');
$this->assertEquals(ClassMetadata::GENERATOR_TYPE_ASSIGNED, $metadata->idGenerator, 'autoassigned');
$metadata = $this->dm->getClassMetadata('\\Doctrine\\Tests\\ODM\\PHPCR\\Functional\\Mapping\\StandardCase');
$this->assertEquals(ClassMetadata::GENERATOR_TYPE_ASSIGNED, $metadata->idGenerator, 'standardcase');
}