vendor/doctrine/orm/tests/Doctrine/Tests/ORM/Functional/ClassTableInheritanceTest.php

   1 <?php
   2
   3 namespace Doctrine\Tests\ORM\Functional;
   4
   5 use Doctrine\Tests\Models\Company\CompanyPerson,
   6     Doctrine\Tests\Models\Company\CompanyEmployee,
   7     Doctrine\Tests\Models\Company\CompanyManager,
   8     Doctrine\Tests\Models\Company\CompanyOrganization,
   9     Doctrine\Tests\Models\Company\CompanyEvent,
  10     Doctrine\Tests\Models\Company\CompanyAuction,
  11     Doctrine\Tests\Models\Company\CompanyRaffle,
  12     Doctrine\Tests\Models\Company\CompanyCar;
  13
  14 use Doctrine\Common\Collections\Criteria;
  15
  16 /**
  17  * Functional tests for the Class Table Inheritance mapping strategy.
  18  *
  19  * @author robo
  20  */
  21 class ClassTableInheritanceTest extends \Doctrine\Tests\OrmFunctionalTestCase
  22 {
  23     protected function setUp() {
  24         $this->useModelSet('company');
  25         parent::setUp();
  26         //$this->_em->getConnection()->getConfiguration()->setSQLLogger(new \Doctrine\DBAL\Logging\EchoSQLLogger);
  27     }
  28
  29     public function testCRUD()
  30     {
  31         $person = new CompanyPerson;
  32         $person->setName('Roman S. Borschel');
  33
  34         $this->_em->persist($person);
  35
  36         $employee = new CompanyEmployee;
  37         $employee->setName('Roman S. Borschel');
  38         $employee->setSalary(100000);
  39         $employee->setDepartment('IT');
  40
  41         $this->_em->persist($employee);
  42
  43         $employee->setName('Guilherme Blanco');
  44         $this->_em->flush();
  45
  46         $this->_em->clear();
  47
  48         $query = $this->_em->createQuery("select p from Doctrine\Tests\Models\Company\CompanyPerson p order by p.name desc");
  49
  50         $entities = $query->getResult();
  51
  52         $this->assertEquals(2, count($entities));
  53         $this->assertInstanceOf('Doctrine\Tests\Models\Company\CompanyPerson', $entities[0]);
  54         $this->assertInstanceOf('Doctrine\Tests\Models\Company\CompanyEmployee', $entities[1]);
  55         $this->assertTrue(is_numeric($entities[0]->getId()));
  56         $this->assertTrue(is_numeric($entities[1]->getId()));
  57         $this->assertEquals('Roman S. Borschel', $entities[0]->getName());
  58         $this->assertEquals('Guilherme Blanco', $entities[1]->getName());
  59         $this->assertEquals(100000, $entities[1]->getSalary());
  60
  61         $this->_em->clear();
  62
  63         $query = $this->_em->createQuery("select p from Doctrine\Tests\Models\Company\CompanyEmployee p");
  64
  65         $entities = $query->getResult();
  66
  67         $this->assertEquals(1, count($entities));
  68         $this->assertInstanceOf('Doctrine\Tests\Models\Company\CompanyEmployee', $entities[0]);
  69         $this->assertTrue(is_numeric($entities[0]->getId()));
  70         $this->assertEquals('Guilherme Blanco', $entities[0]->getName());
  71         $this->assertEquals(100000, $entities[0]->getSalary());
  72
  73         $this->_em->clear();
  74
  75         $guilherme = $this->_em->getRepository(get_class($employee))->findOneBy(array('name' => 'Guilherme Blanco'));
  76         $this->assertInstanceOf('Doctrine\Tests\Models\Company\CompanyEmployee', $guilherme);
  77         $this->assertEquals('Guilherme Blanco', $guilherme->getName());
  78
  79         $this->_em->clear();
  80
  81         $query = $this->_em->createQuery("update Doctrine\Tests\Models\Company\CompanyEmployee p set p.name = ?1, p.department = ?2 where p.name='Guilherme Blanco' and p.salary = ?3");
  82         $query->setParameter(1, 'NewName', 'string');
  83         $query->setParameter(2, 'NewDepartment');
  84         $query->setParameter(3, 100000);
  85         $query->getSql();
  86         $numUpdated = $query->execute();
  87         $this->assertEquals(1, $numUpdated);
  88
  89         $query = $this->_em->createQuery("delete from Doctrine\Tests\Models\Company\CompanyPerson p");
  90         $numDeleted = $query->execute();
  91         $this->assertEquals(2, $numDeleted);
  92     }
  93
  94     public function testMultiLevelUpdateAndFind() {
  95         $manager = new CompanyManager;
  96         $manager->setName('Roman S. Borschel');
  97         $manager->setSalary(100000);
  98         $manager->setDepartment('IT');
  99         $manager->setTitle('CTO');
 100         $this->_em->persist($manager);
 101         $this->_em->flush();
 102
 103         $manager->setName('Roman B.');
 104         $manager->setSalary(119000);
 105         $manager->setTitle('CEO');
 106         $this->_em->persist($manager);
 107         $this->_em->flush();
 108
 109         $this->_em->clear();
 110
 111         $manager = $this->_em->find('Doctrine\Tests\Models\Company\CompanyManager', $manager->getId());
 112
 113         $this->assertInstanceOf('Doctrine\Tests\Models\Company\CompanyManager', $manager);
 114         $this->assertEquals('Roman B.', $manager->getName());
 115         $this->assertEquals(119000, $manager->getSalary());
 116         $this->assertEquals('CEO', $manager->getTitle());
 117         $this->assertTrue(is_numeric($manager->getId()));
 118     }
 119
 120     public function testFindOnBaseClass() {
 121         $manager = new CompanyManager;
 122         $manager->setName('Roman S. Borschel');
 123         $manager->setSalary(100000);
 124         $manager->setDepartment('IT');
 125         $manager->setTitle('CTO');
 126         $this->_em->persist($manager);
 127         $this->_em->flush();
 128
 129         $this->_em->clear();
 130
 131         $person = $this->_em->find('Doctrine\Tests\Models\Company\CompanyPerson', $manager->getId());
 132
 133         $this->assertInstanceOf('Doctrine\Tests\Models\Company\CompanyManager', $person);
 134         $this->assertEquals('Roman S. Borschel', $person->getName());
 135         $this->assertEquals(100000, $person->getSalary());
 136         $this->assertEquals('CTO', $person->getTitle());
 137         $this->assertTrue(is_numeric($person->getId()));
 138         //$this->assertInstanceOf('Doctrine\Tests\Models\Company\CompanyCar', $person->getCar());
 139     }
 140
 141     public function testSelfReferencingOneToOne() {
 142         $manager = new CompanyManager;
 143         $manager->setName('John Smith');
 144         $manager->setSalary(100000);
 145         $manager->setDepartment('IT');
 146         $manager->setTitle('CTO');
 147
 148         $wife = new CompanyPerson;
 149         $wife->setName('Mary Smith');
 150         $wife->setSpouse($manager);
 151
 152         $this->assertSame($manager, $wife->getSpouse());
 153         $this->assertSame($wife, $manager->getSpouse());
 154
 155         $this->_em->persist($manager);
 156         $this->_em->persist($wife);
 157
 158         $this->_em->flush();
 159
 160         //var_dump($this->_em->getConnection()->fetchAll('select * from company_persons'));
 161         //var_dump($this->_em->getConnection()->fetchAll('select * from company_employees'));
 162         //var_dump($this->_em->getConnection()->fetchAll('select * from company_managers'));
 163
 164         $this->_em->clear();
 165
 166         $query = $this->_em->createQuery('select p, s from Doctrine\Tests\Models\Company\CompanyPerson p join p.spouse s where p.name=\'Mary Smith\'');
 167
 168         $result = $query->getResult();
 169         $this->assertEquals(1, count($result));
 170         $this->assertInstanceOf('Doctrine\Tests\Models\Company\CompanyPerson', $result[0]);
 171         $this->assertEquals('Mary Smith', $result[0]->getName());
 172         $this->assertInstanceOf('Doctrine\Tests\Models\Company\CompanyEmployee', $result[0]->getSpouse());
 173         $this->assertEquals('John Smith', $result[0]->getSpouse()->getName());
 174         $this->assertSame($result[0], $result[0]->getSpouse()->getSpouse());
 175     }
 176
 177     public function testSelfReferencingManyToMany()
 178     {
 179         $person1 = new CompanyPerson;
 180         $person1->setName('Roman');
 181
 182         $person2 = new CompanyPerson;
 183         $person2->setName('Jonathan');
 184
 185         $person1->addFriend($person2);
 186
 187         $this->assertEquals(1, count($person1->getFriends()));
 188         $this->assertEquals(1, count($person2->getFriends()));
 189
 190
 191         $this->_em->persist($person1);
 192         $this->_em->persist($person2);
 193
 194         $this->_em->flush();
 195
 196         $this->_em->clear();
 197
 198         $query = $this->_em->createQuery('select p, f from Doctrine\Tests\Models\Company\CompanyPerson p join p.friends f where p.name=?1');
 199         $query->setParameter(1, 'Roman');
 200
 201         $result = $query->getResult();
 202         $this->assertEquals(1, count($result));
 203         $this->assertEquals(1, count($result[0]->getFriends()));
 204         $this->assertEquals('Roman', $result[0]->getName());
 205
 206         $friends = $result[0]->getFriends();
 207         $this->assertEquals('Jonathan', $friends[0]->getName());
 208     }
 209
 210     public function testLazyLoading1()
 211     {
 212         $org = new CompanyOrganization;
 213         $event1 = new CompanyAuction;
 214         $event1->setData('auction');
 215         $org->addEvent($event1);
 216         $event2 = new CompanyRaffle;
 217         $event2->setData('raffle');
 218         $org->addEvent($event2);
 219
 220         $this->_em->persist($org);
 221         $this->_em->flush();
 222         $this->_em->clear();
 223
 224         $orgId = $org->getId();
 225
 226         $q = $this->_em->createQuery('select a from Doctrine\Tests\Models\Company\CompanyOrganization a where a.id = ?1');
 227         $q->setParameter(1, $orgId);
 228
 229         $result = $q->getResult();
 230
 231         $this->assertEquals(1, count($result));
 232         $this->assertInstanceOf('Doctrine\Tests\Models\Company\CompanyOrganization', $result[0]);
 233         $this->assertNull($result[0]->getMainEvent());
 234
 235         $events = $result[0]->getEvents();
 236
 237         $this->assertInstanceOf('Doctrine\ORM\PersistentCollection', $events);
 238         $this->assertFalse($events->isInitialized());
 239
 240         $this->assertEquals(2, count($events));
 241         if ($events[0] instanceof CompanyAuction) {
 242             $this->assertInstanceOf('Doctrine\Tests\Models\Company\CompanyRaffle', $events[1]);
 243         } else {
 244             $this->assertInstanceOf('Doctrine\Tests\Models\Company\CompanyRaffle', $events[0]);
 245             $this->assertInstanceOf('Doctrine\Tests\Models\Company\CompanyAuction', $events[1]);
 246         }
 247     }
 248
 249
 250     public function testLazyLoading2()
 251     {
 252         $org = new CompanyOrganization;
 253         $event1 = new CompanyAuction;
 254         $event1->setData('auction');
 255         $org->setMainEvent($event1);
 256
 257         $this->_em->persist($org);
 258         $this->_em->flush();
 259         $this->_em->clear();
 260
 261         $q = $this->_em->createQuery('select a from Doctrine\Tests\Models\Company\CompanyEvent a where a.id = ?1');
 262         $q->setParameter(1, $event1->getId());
 263
 264         $result = $q->getResult();
 265         $this->assertEquals(1, count($result));
 266         $this->assertInstanceOf('Doctrine\Tests\Models\Company\CompanyAuction', $result[0], sprintf("Is of class %s",get_class($result[0])));
 267
 268         $this->_em->clear();
 269
 270         $q = $this->_em->createQuery('select a from Doctrine\Tests\Models\Company\CompanyOrganization a where a.id = ?1');
 271         $q->setParameter(1, $org->getId());
 272
 273         $result = $q->getResult();
 274
 275         $this->assertEquals(1, count($result));
 276         $this->assertInstanceOf('Doctrine\Tests\Models\Company\CompanyOrganization', $result[0]);
 277
 278         $mainEvent = $result[0]->getMainEvent();
 279         // mainEvent should have been loaded because it can't be lazy
 280         $this->assertInstanceOf('Doctrine\Tests\Models\Company\CompanyAuction', $mainEvent);
 281         $this->assertNotInstanceOf('Doctrine\ORM\Proxy\Proxy', $mainEvent);
 282     }
 283
 284     /**
 285      * @group DDC-368
 286      */
 287     public function testBulkUpdateIssueDDC368()
 288     {
 289         $dql = 'UPDATE Doctrine\Tests\Models\Company\CompanyEmployee AS p SET p.salary = 1';
 290         $this->_em->createQuery($dql)->execute();
 291
 292         $this->assertTrue(count($this->_em->createQuery(
 293             'SELECT count(p.id) FROM Doctrine\Tests\Models\Company\CompanyEmployee p WHERE p.salary = 1')
 294             ->getResult()) > 0);
 295     }
 296
 297     /**
 298      * @group DDC-1341
 299      */
 300     public function testBulkUpdateNonScalarParameterDDC1341()
 301     {
 302         $dql   = 'UPDATE Doctrine\Tests\Models\Company\CompanyEmployee AS p SET p.startDate = ?0 WHERE p.department = ?1';
 303         $query = $this->_em->createQuery($dql)
 304             ->setParameter(0, new \DateTime())
 305             ->setParameter(1, 'IT');
 306
 307         $result = $query->execute();
 308
 309     }
 310
 311     /**
 312      * @group DDC-130
 313      */
 314     public function testDeleteJoinTableRecords()
 315     {
 316         #$this->markTestSkipped('Nightmare! friends adds both ID 6-7 and 7-6 into two rows of the join table. How to detect this?');
 317
 318         $employee1 = new CompanyEmployee();
 319         $employee1->setName('gblanco');
 320         $employee1->setSalary(0);
 321         $employee1->setDepartment('IT');
 322
 323         $employee2 = new CompanyEmployee();
 324         $employee2->setName('jwage');
 325         $employee2->setSalary(0);
 326         $employee2->setDepartment('IT');
 327
 328         $employee1->addFriend($employee2);
 329
 330         $this->_em->persist($employee1);
 331         $this->_em->persist($employee2);
 332         $this->_em->flush();
 333
 334         $employee1Id = $employee1->getId();
 335
 336         $this->_em->remove($employee1);
 337         $this->_em->flush();
 338
 339         $this->assertNull($this->_em->find(get_class($employee1), $employee1Id));
 340     }
 341
 342     /**
 343      * @group DDC-728
 344      */
 345     public function testQueryForInheritedSingleValuedAssociation()
 346     {
 347         $manager = new CompanyManager();
 348         $manager->setName('gblanco');
 349         $manager->setSalary(1234);
 350         $manager->setTitle('Awesome!');
 351         $manager->setDepartment('IT');
 352
 353         $person = new CompanyPerson();
 354         $person->setName('spouse');
 355
 356         $manager->setSpouse($person);
 357
 358         $this->_em->persist($manager);
 359         $this->_em->persist($person);
 360         $this->_em->flush();
 361         $this->_em->clear();
 362
 363         $dql = "SELECT m FROM Doctrine\Tests\Models\Company\CompanyManager m WHERE m.spouse = ?1";
 364         $dqlManager = $this->_em->createQuery($dql)->setParameter(1, $person->getId())->getSingleResult();
 365
 366         $this->assertEquals($manager->getId(), $dqlManager->getId());
 367         $this->assertEquals($person->getId(), $dqlManager->getSpouse()->getId());
 368     }
 369
 370     /**
 371      * @group DDC-817
 372      */
 373     public function testFindByAssociation()
 374     {
 375         $manager = new CompanyManager();
 376         $manager->setName('gblanco');
 377         $manager->setSalary(1234);
 378         $manager->setTitle('Awesome!');
 379         $manager->setDepartment('IT');
 380
 381         $person = new CompanyPerson();
 382         $person->setName('spouse');
 383
 384         $manager->setSpouse($person);
 385
 386         $this->_em->persist($manager);
 387         $this->_em->persist($person);
 388         $this->_em->flush();
 389         $this->_em->clear();
 390
 391         $repos = $this->_em->getRepository('Doctrine\Tests\Models\Company\CompanyManager');
 392         $pmanager = $repos->findOneBy(array('spouse' => $person->getId()));
 393
 394         $this->assertEquals($manager->getId(), $pmanager->getId());
 395
 396         $repos = $this->_em->getRepository('Doctrine\Tests\Models\Company\CompanyPerson');
 397         $pmanager = $repos->findOneBy(array('spouse' => $person->getId()));
 398
 399         $this->assertEquals($manager->getId(), $pmanager->getId());
 400     }
 401
 402     /**
 403      * @group DDC-834
 404      */
 405     public function testGetReferenceEntityWithSubclasses()
 406     {
 407         $manager = new CompanyManager();
 408         $manager->setName('gblanco');
 409         $manager->setSalary(1234);
 410         $manager->setTitle('Awesome!');
 411         $manager->setDepartment('IT');
 412
 413         $this->_em->persist($manager);
 414         $this->_em->flush();
 415         $this->_em->clear();
 416
 417         $ref = $this->_em->getReference('Doctrine\Tests\Models\Company\CompanyPerson', $manager->getId());
 418         $this->assertNotInstanceOf('Doctrine\ORM\Proxy\Proxy', $ref, "Cannot Request a proxy from a class that has subclasses.");
 419         $this->assertInstanceOf('Doctrine\Tests\Models\Company\CompanyPerson', $ref);
 420         $this->assertInstanceOf('Doctrine\Tests\Models\Company\CompanyEmployee', $ref, "Direct fetch of the reference has to load the child class Emplyoee directly.");
 421         $this->_em->clear();
 422
 423         $ref = $this->_em->getReference('Doctrine\Tests\Models\Company\CompanyManager', $manager->getId());
 424         $this->assertInstanceOf('Doctrine\ORM\Proxy\Proxy', $ref, "A proxy can be generated only if no subclasses exists for the requested reference.");
 425     }
 426
 427     /**
 428      * @group DDC-992
 429      */
 430     public function testGetSubClassManyToManyCollection()
 431     {
 432         $manager = new CompanyManager();
 433         $manager->setName('gblanco');
 434         $manager->setSalary(1234);
 435         $manager->setTitle('Awesome!');
 436         $manager->setDepartment('IT');
 437
 438         $person = new CompanyPerson();
 439         $person->setName('friend');
 440
 441         $manager->addFriend($person);
 442
 443         $this->_em->persist($manager);
 444         $this->_em->persist($person);
 445         $this->_em->flush();
 446         $this->_em->clear();
 447
 448         $manager = $this->_em->find('Doctrine\Tests\Models\Company\CompanyManager', $manager->getId());
 449         $this->assertEquals(1, count($manager->getFriends()));
 450     }
 451
 452     /**
 453      * @group DDC-1777
 454      */
 455     public function testExistsSubclass()
 456     {
 457         $manager = new CompanyManager();
 458         $manager->setName('gblanco');
 459         $manager->setSalary(1234);
 460         $manager->setTitle('Awesome!');
 461         $manager->setDepartment('IT');
 462
 463         $this->assertFalse($this->_em->getUnitOfWork()->getEntityPersister(get_class($manager))->exists($manager));
 464
 465         $this->_em->persist($manager);
 466         $this->_em->flush();
 467
 468         $this->assertTrue($this->_em->getUnitOfWork()->getEntityPersister(get_class($manager))->exists($manager));
 469     }
 470
 471     /**
 472      * @group DDC-1637
 473      */
 474     public function testMatching()
 475     {
 476         $manager = new CompanyManager();
 477         $manager->setName('gblanco');
 478         $manager->setSalary(1234);
 479         $manager->setTitle('Awesome!');
 480         $manager->setDepartment('IT');
 481
 482         $this->_em->persist($manager);
 483         $this->_em->flush();
 484
 485         $repository = $this->_em->getRepository("Doctrine\Tests\Models\Company\CompanyEmployee");
 486         $users = $repository->matching(new Criteria(
 487             Criteria::expr()->eq('department', 'IT')
 488         ));
 489         $this->assertEquals(1, count($users));
 490
 491         $repository = $this->_em->getRepository("Doctrine\Tests\Models\Company\CompanyManager");
 492         $users = $repository->matching(new Criteria(
 493             Criteria::expr()->eq('department', 'IT')
 494         ));
 495         $this->assertEquals(1, count($users));
 496     }
 497 }