public function setUp()
{
parent::setUp();
$this->ids = array();
$groupA = new Group('groupA');
$groupB = new Group('groupB');
$profile = new Profile();
$profile->setFirstname('Timothy');
$tim = new User();
$tim->setUsername('Tim');
$tim->setHits(10);
$tim->addGroup($groupA);
$tim->addGroup($groupB);
$tim->setProfile($profile);
$this->dm->persist($tim);
$john = new User();
$john->setUsername('John');
$john->setHits(10);
$this->dm->persist($john);
$this->dm->flush();
$this->dm->clear();
$this->ids['tim'] = $tim->getId();
$this->ids['john'] = $john->getId();
$this->fc = $this->dm->getFilterCollection();
}
public function testFlushOptions()
{
$user = new User();
$user->setUsername('jwage');
$this->dm->persist($user);
$this->dm->flush(null, array('safe' => true));
$user->setUsername('ok');
$this->dm->flush(null, array('safe' => true));
}
public function testFlushOptions()
{
$user = new User();
$user->setUsername('jwage');
$this->dm->persist($user);
$this->dm->flush();
$user->setUsername('ok');
$this->dm->flush();
}
public function testDetatchNewDocumentDuringOnFlush()
{
// create a test document
$test = new User();
$test->setUsername('toby');
$this->dm->persist($test);
$this->dm->flush();
$this->dm->clear();
$repository = $this->dm->getRepository(get_class($test));
$test = $repository->find($test->getId());
$this->assertNull($test);
}
public function testFindAndModifyAlt()
{
$doc = new User();
$doc->setUsername('jwage');
$this->dm->persist($doc);
$this->dm->flush();
// test update findAndModify
$q = $this->dm->createQueryBuilder()->findAndUpdate('Documents\\User')->returnNew(true)->field('username')->equals('jwage')->field('username')->set('Romain Neutron')->getQuery();
$result = $q->execute();
// Test the username was set
$this->assertEquals('Romain Neutron', $result->getUsername());
}
public function testCountFoundOnlyBehavior()
{
$usernames = array('David', 'Xander', 'Alex', 'Kris', 'Jon');
foreach ($usernames as $username) {
$user = new User();
$user->setUsername($username);
$this->dm->persist($user);
}
$this->dm->flush();
$cursor = $this->dm->createQueryBuilder('Documents\\User')->sort('username', 'asc')->limit(2)->getQuery()->execute();
$this->assertEquals(5, $cursor->count());
$this->assertEquals(2, $cursor->count(true));
}
public function testOneReference()
{
$account = new Account();
$account->setName('Test Account');
$user = new User();
$user->setUsername('jwage');
$user->setAccount($account);
$this->dm->persist($user);
$this->dm->flush();
$this->dm->flush();
$this->dm->clear();
$accountId = $user->getAccount()->getId();
$user2 = $this->dm->createQuery('Documents\\User')->where('id', $user->getId())->getSingleResult();
}
public function testDetach()
{
$user = new User();
$user->setUsername('jon');
$user->setPassword('changeme');
$this->dm->persist($user);
$this->dm->flush();
$user->setUsername('whoop');
$this->dm->detach($user);
$this->dm->flush();
$this->dm->clear();
$user2 = $this->dm->find('Documents\\User', $user->getId());
$this->assertEquals('jon', $user2->getUsername());
}
public function testDates()
{
$user = new User();
$user->setUsername('w00ting');
$this->dm->persist($user);
$this->dm->flush();
$this->assertTrue($user->getCreatedAt() instanceof \DateTime);
$user->setCreatedAt('1985-09-01 00:00:00');
$this->dm->flush();
$this->dm->clear();
$user = $this->dm->getRepository('Documents\\User')->findOneByUsername('w00ting');
$this->assertEquals('w00ting', $user->getUsername());
$this->assertTrue($user->getCreatedAt() instanceof \DateTime);
$this->assertEquals('09/01/1985', $user->getCreatedAt()->format('m/d/Y'));
}
public function testOldDate()
{
$user = new User();
$user->setUsername('datetest');
$user->setCreatedAt('1900-01-01');
$this->dm->persist($user);
$this->dm->flush();
$user->setUsername('datetest2');
$this->dm->flush();
$this->dm->clear();
$test = $this->dm->getDocumentCollection('Documents\\User')->findOne(array('username' => 'datetest2'));
$this->assertTrue(isset($test['createdAt']));
$user = $this->dm->getRepository('Documents\\User')->findOneBy(array('username' => 'datetest2'));
$this->assertTrue($user->getCreatedAt() instanceof \DateTime);
$this->assertEquals('1900-01-01', $user->getCreatedAt()->format('Y-m-d'));
}
public function testOneReference()
{
$account = new Account();
$account->setName('Test Account');
$user = new User();
$user->setUsername('jwage');
$user->setAccount($account);
$this->dm->persist($user);
$this->dm->flush();
$this->dm->flush();
$this->dm->clear();
$accountId = $user->getAccount()->getId();
$qb = $this->dm->createQueryBuilder('Documents\\User')->field('id')->equals($user->getId());
$query = $qb->getQuery();
$user2 = $query->getSingleResult();
}
public function testRemove()
{
$account = new Account();
$account->setName('Jon Test Account');
$user = new User();
$user->setUsername('jon');
$user->setPassword('changeme');
$user->setAccount($account);
$this->dm->persist($user);
$this->dm->flush();
$this->dm->remove($user);
$this->dm->flush();
$account = $this->dm->find('Documents\\Account', $account->getId());
$this->assertNull($account);
$user = $this->dm->find('Documents\\User', $user->getId());
$this->assertNull($user);
}
public function testInsertIncludesAllNestedCollections()
{
$user = new User();
$user->setUsername('malarzm');
$privateBook = new Phonebook('Private');
$privateBook->addPhonenumber(new Phonenumber('12345678'));
$user->addPhonebook($privateBook);
$this->dm->persist($user);
$this->dm->flush();
$this->assertCount(1, $this->ql, 'Inserting a document includes all nested collections and requires one query');
$this->dm->clear();
$user = $this->dm->find(get_class($user), $user->getId());
$this->assertEquals('malarzm', $user->getUsername());
$this->assertCount(1, $user->getPhonebooks());
$this->assertEquals('Private', $user->getPhonebooks()->first()->getTitle());
$this->assertCount(1, $user->getPhonebooks()->first()->getPhonenumbers());
$this->assertEquals('12345678', $user->getPhonebooks()->first()->getPhonenumbers()->first()->getPhonenumber());
}
public function testUnsetFromEmbeddedCollection()
{
$user = new User();
$user->setUsername('jon');
$user->addGroup(new Group('test group 1'));
$user->addGroup(new Group('test group 2'));
$user->addGroup(new Group('test group 3'));
$this->dm->persist($user);
$this->dm->flush();
$this->dm->clear();
$user = $this->dm->find('Documents\\User', $user->getId());
$groups = $user->getGroups();
unset($groups[0]);
$this->assertEquals(2, count($user->getGroups()));
$this->dm->flush();
$this->dm->clear();
$user = $this->dm->getRepository('Documents\\User')->findOneBy(array('username' => 'jon'));
$this->assertEquals(2, count($user->getGroups()));
}
public function testUpdateCollectionDuringOnFlushAndRecomputSingleDocumentChangeSet()
{
// create a test document
$test = new User();
$test->setUsername('toby');
$test->addPhonenumber(new Phonenumber('1111'));
$this->dm->persist($test);
$this->dm->flush();
$test->setUsername('lucy');
$this->dm->flush();
$this->dm->clear();
$repository = $this->dm->getRepository(get_class($test));
$test = $repository->findOneBy(array('username' => 'lucy'));
$phonenumbers = array();
foreach ($test->getPhonenumbers() as $phonenumber) {
$phonenumbers[] = $phonenumber->getPhonenumber();
}
sort($phonenumbers);
$this->assertEquals(array('1111', '2222'), $phonenumbers);
}
public function testRecreateShouldPreserveSorting()
{
$usernames = array('David', 'Xander', 'Alex', 'Kris', 'Jon');
foreach ($usernames as $username) {
$user = new User();
$user->setUsername($username);
$this->dm->persist($user);
}
$this->dm->flush();
$qb = $this->dm->createQueryBuilder('Documents\\User')->sort('username', 'asc');
$cursor = $qb->getQuery()->execute();
sort($usernames);
foreach ($usernames as $username) {
$this->assertEquals($username, $cursor->getNext()->getUsername());
}
$cursor->recreate();
foreach ($usernames as $username) {
$this->assertEquals($username, $cursor->getNext()->getUsername());
}
}
/**
* Tests Bi-Directional Reference "one to many" with nullable=true flag
*
* @url http://docs.doctrine-project.org/projects/doctrine-mongodb-odm/en/latest/reference/bidirectional-references.html
*/
public function testOneToMany()
{
$user = new User();
$user->setUsername('w00ting');
$this->dm->persist($user);
$this->dm->flush();
$post1 = new BlogPost();
$post1->name = 'post1';
$post1->setUser($user);
$post2 = new BlogPost();
$post2->name = 'post2';
$post2->setUser($user);
$post3 = new BlogPost();
$post3->name = 'post3';
$post3->setUser($user);
$this->dm->persist($post1);
$this->dm->persist($post2);
$this->dm->persist($post3);
$this->dm->flush();
$post1->setUser(null);
$this->dm->flush();
$this->assertNull($post1->user);
}
public function testRemoveEmbeddedDocument()
{
$address = new Address();
$address->setAddress('6512 Mercomatic Ct.');
$user = new User();
$user->setUsername('jwagettt');
$user->setAddress($address);
$user->addPhonenumber(new Phonenumber('6155139185'));
$user->addPhonenumber(new Phonenumber('6155139185'));
$this->dm->persist($user);
$this->dm->flush();
$user->removeAddress();
$user->getPhonenumbers()->remove(0);
$user->getPhonenumbers()->remove(1);
$this->dm->flush();
$check = $this->dm->getDocumentCollection('Documents\\User')->findOne();
$this->assertEmpty($check['phonenumbers']);
$this->assertFalse(isset($check['address']));
}
public function testQueryReferences()
{
$group = new \Documents\Group('Test Group');
$user = new User();
$user->setUsername('cool');
$user->addGroup($group);
$this->dm->persist($user);
$this->dm->flush();
$qb = $this->dm->createQueryBuilder('Documents\\User')->field('groups')->references($group);
$query = $qb->getQuery();
$user2 = $query->getSingleResult();
$this->assertSame($user, $user2);
}
public function testMapReduce2()
{
$user = new User();
$user->setUsername('bob');
$event1 = new Event();
$event1->setUser($user);
$event1->setType('sale');
$event1->setTitle('Test 1');
$event2 = new Event();
$event2->setUser($user);
$event2->setType('sale');
$event2->setTitle('Test 2');
$event3 = new Event();
$event3->setUser($user);
$event3->setType('sale');
$event3->setTitle('Test 2');
$this->dm->persist($user);
$this->dm->persist($event1);
$this->dm->persist($event2);
$this->dm->persist($event3);
$this->dm->flush();
$query = $this->dm->createQuery('Documents\\Event')->where('type', 'sale')->map('function() { emit(this.user.$id, 1); }')->reduce("function(k, vals) {\n var sum = 0;\n for (var i in vals) {\n sum += vals[i]; \n }\n return sum;\n }");
$user2 = $query->getSingleResult();
$this->assertEquals($user->getId(), $user2['_id']);
$this->assertEquals(3, $user2['value']);
}
public function testPrimeEmbeddedReferenceOneLevelDeep()
{
$user1 = new User();
$user2 = new User();
$phone = new Phonenumber('555-GET-THIS', $user2);
$user1->addPhonenumber($phone);
$user1->setUsername('SomeName');
$this->dm->persist($user1);
$this->dm->persist($user2);
$this->dm->flush();
$this->dm->clear();
$qb = $this->dm->createQueryBuilder('Documents\\User')->field('username')->equals('SomeName')->field('phonenumbers.lastCalledBy')->prime(true);
$user = $qb->getQuery()->getSingleResult();
$phonenumbers = $user->getPhonenumbers();
$this->assertCount(1, $phonenumbers);
$phonenumber = $phonenumbers->current();
$this->assertNotInstanceOf('Doctrine\\ODM\\MongoDB\\Proxy\\Proxy', $phonenumber);
$this->assertInstanceOf('Documents\\Phonenumber', $phonenumber);
}
public function testReplaceEntireGroupsArray()
{
$account = new Account();
$account->setName('Jon Test Account');
$user = new User();
$user->setUsername('jon333');
$user->setPassword('changeme');
$user->setAccount($account);
$group2 = new Group('member');
$user->addGroup(new Group('administrator'));
$user->addGroup($group2);
$user->addGroup(new Group('moderator'));
$this->dm->persist($user);
$this->dm->flush();
$this->dm->clear();
$user = $this->dm->find('Documents\\User', $user->getId());
$this->assertNotNull($user);
// Issue is collection must be initialized
$groups = $user->getGroups();
$groups[0];
// initialize collection
// reffectively remove two of the groups
//$user->getGroups()->clear();
//$user->getGroups()->add($group2);
$user->setGroups(array($group2));
$this->assertEquals(1, count($user->getGroups()));
$this->dm->flush();
$this->dm->clear();
$user = $this->dm->find('Documents\\User', $user->getId());
$this->assertEquals(1, count($user->getGroups()));
}
public function testCollection()
{
$user = new \Documents\User();
$user->setUsername('joncolltest');
$user->log(array('test'));
$user->log(array('test'));
$this->dm->persist($user);
$this->dm->flush();
$this->dm->clear();
$coll = $this->dm->getDocumentCollection('Documents\\User');
$document = $coll->findOne(array('username' => 'joncolltest'));
$this->assertEquals(2, count($document['logs']));
$document = $this->dm->getRepository('Documents\\User')->findOneBy(array('username' => 'joncolltest'));
$this->assertEquals(2, count($document->getLogs()));
$document->log(array('test'));
$this->dm->flush();
$this->dm->clear();
$document = $this->dm->getRepository('Documents\\User')->findOneBy(array('username' => 'joncolltest'));
$this->assertEquals(3, count($document->getLogs()));
$document->setLogs(array('ok', 'test'));
$this->dm->flush();
$this->dm->clear();
$document = $this->dm->getRepository('Documents\\User')->findOneBy(array('username' => 'joncolltest'));
$this->assertEquals(array('ok', 'test'), $document->getLogs());
}
public function testFindUser()
{
$account = new Account();
$account->setName('Jon Test Account');
$user1 = new CustomUser();
$user1->setId('userId');
$user1->setUsername('user1');
$user1->setPassword('changeme');
$user1->setAccount($account);
$user2 = new User();
$user2->setUsername('user2');
$user2->setPassword('changeme');
$user2->setAccount($account);
$user3 = new User();
$user3->setUsername('user3');
$user3->setPassword('changeme');
$user3->setAccount($account);
$this->dm->persist($user1);
$this->dm->persist($user2);
$this->dm->persist($user3);
$this->dm->flush();
$this->dm->clear();
unset($user1, $user2, $user3);
$user = $this->dm->find('Documents\\CustomUser', 'userId');
$this->assertNotNull($user);
$this->assertEquals('userId', $user->getId());
$this->assertEquals('user1', $user->getUsername());
$this->dm->clear();
unset($user);
$this->assertNull($this->dm->find('Documents\\User', 'userId'));
$this->assertNull($this->dm->find('Documents\\CustomUser', 'asd'));
}
$classLoader->register();
$config = new Configuration();
/*
$config->setLoggerCallable(function(array $log) {
print_r($log);
});
$config->setMetadataCacheImpl(new ApcCache());
*/
$config->setProxyDir(__DIR__ . '/Proxies');
$config->setProxyNamespace('Proxies');
$reader = new AnnotationReader();
$reader->setDefaultAnnotationNamespace('Doctrine\\ODM\\MongoDB\\Mapping\\');
$config->setMetadataDriverImpl(new AnnotationDriver($reader, __DIR__ . '/Documents'));
//$config->setMetadataDriverImpl(new XmlDriver(__DIR__ . '/xml'));
//$config->setMetadataDriverImpl(new YamlDriver(__DIR__ . '/yaml'));
//$config->setMetadataDriverImpl(new PHPDriver());
$dm = DocumentManager::create(new Mongo(), $config);
$profile = new Profile();
$profile->setName('Jonathan H. Wage');
$profile->addSong(new Song('Testinfuckckcg'));
$user = new User();
$user->setUsername('jwage');
$user->setPassword('changeme');
$user->addPhonenumber(new Phonenumber('6155139185'));
$user->setProfile($profile);
$configuration = new ConfigurationDoc();
$configuration->setTimezone('Eastern');
$configuration->setTheme('doctrine');
$user->setConfiguration($configuration);
$dm->persist($user);
$dm->flush();
public function testReplaceGroups()
{
$this->dm->getUnitOfWork()->setDocumentPersister('Documents\\User', new BasicDocumentPersister($this->dm, $this->classMetadata));
$account = new Account();
$account->setName('Jon Test Account');
$user = new User();
$user->setUsername('jon');
$user->setPassword('changeme');
$user->setAccount($account);
$user->addGroup(new Group('administrator'));
$user->addGroup(new Group('member'));
$user->addGroup(new Group('moderator'));
$this->dm->persist($user);
$this->dm->flush();
$this->dm->clear();
unset($user, $account);
$user = $this->dm->findOne('Documents\\User');
$user->removeGroup('moderator');
$user->removeGroup('member');
$this->assertEquals(1, count($user->getGroups()));
$user->addGroup(new Group('seller'));
$user->addGroup(new Group('supplier'));
$this->assertEquals(3, count($user->getGroups()));
$this->dm->getUnitOfWork()->setDocumentPersister('Documents\\User', $this->persister);
$this->persister->expects($this->once())->method('update')->with($user);
$this->dm->getUnitOfWork()->computeChangeSets();
$update = $this->persister->prepareUpdateData($user);
$this->assertFalse(array_key_exists('$set', $update));
$this->assertFalse(array_key_exists('$unset', $update));
$this->assertTrue(array_key_exists('$pullAll', $update));
$this->assertTrue(array_key_exists('groups', $update['$pullAll']));
$this->assertEquals(2, count($update['$pullAll']['groups']));
$this->assertTrue(array_key_exists('$pushAll', $update));
$this->assertTrue(array_key_exists('groups', $update['$pushAll']));
$this->assertEquals(2, count($update['$pushAll']['groups']));
$this->dm->flush();
$this->dm->clear();
unset($user);
$user = $this->dm->findOne('Documents\\User');
$this->assertEquals(3, count($user->getGroups()));
}
