vendor/doctrine/orm/tests/Doctrine/Tests/ORM/Mapping/AbstractMappingDriverTest.php

   1 <?php
   2
   3 namespace Doctrine\Tests\ORM\Mapping;
   4
   5 use Doctrine\ORM\Mapping\ClassMetadata,
   6     Doctrine\ORM\Mapping\ClassMetadataInfo,
   7     Doctrine\ORM\Mapping\Driver\XmlDriver,
   8     Doctrine\ORM\Mapping\Driver\YamlDriver;
   9
  10 require_once __DIR__ . '/../../TestInit.php';
  11
  12 abstract class AbstractMappingDriverTest extends \Doctrine\Tests\OrmTestCase
  13 {
  14     abstract protected function _loadDriver();
  15
  16     public function createClassMetadata($entityClassName)
  17     {
  18         $mappingDriver = $this->_loadDriver();
  19
  20         $class = new ClassMetadata($entityClassName);
  21         $class->initializeReflection(new \Doctrine\Common\Persistence\Mapping\RuntimeReflectionService);
  22         $mappingDriver->loadMetadataForClass($entityClassName, $class);
  23
  24         return $class;
  25     }
  26
  27     /**
  28      * @param \Doctrine\ORM\EntityManager $entityClassName
  29      * @return \Doctrine\ORM\Mapping\ClassMetadataFactory
  30      */
  31     protected function createClassMetadataFactory(\Doctrine\ORM\EntityManager $em = null)
  32     {
  33         $driver     = $this->_loadDriver();
  34         $em         = $em ?: $this->_getTestEntityManager();
  35         $factory    = new \Doctrine\ORM\Mapping\ClassMetadataFactory();
  36         $em->getConfiguration()->setMetadataDriverImpl($driver);
  37         $factory->setEntityManager($em);
  38
  39         return $factory;
  40     }
  41
  42     public function testLoadMapping()
  43     {
  44         $entityClassName = 'Doctrine\Tests\ORM\Mapping\User';
  45         return $this->createClassMetadata($entityClassName);
  46     }
  47
  48     /**
  49      * @depends testLoadMapping
  50      * @param ClassMetadata $class
  51      */
  52     public function testEntityTableNameAndInheritance($class)
  53     {
  54         $this->assertEquals('cms_users', $class->getTableName());
  55         $this->assertEquals(ClassMetadata::INHERITANCE_TYPE_NONE, $class->inheritanceType);
  56
  57         return $class;
  58     }
  59
  60     /**
  61      * @depends testEntityTableNameAndInheritance
  62      * @param ClassMetadata $class
  63      */
  64     public function testEntityIndexes($class)
  65     {
  66         $this->assertArrayHasKey('indexes', $class->table, 'ClassMetadata should have indexes key in table property.');
  67         $this->assertEquals(array(
  68             'name_idx' => array('columns' => array('name')),
  69             0 => array('columns' => array('user_email'))
  70         ), $class->table['indexes']);
  71
  72         return $class;
  73     }
  74
  75     /**
  76      * @depends testEntityTableNameAndInheritance
  77      * @param ClassMetadata $class
  78      */
  79     public function testEntityUniqueConstraints($class)
  80     {
  81         $this->assertArrayHasKey('uniqueConstraints', $class->table,
  82             'ClassMetadata should have uniqueConstraints key in table property when Unique Constraints are set.');
  83
  84         $this->assertEquals(array(
  85             "search_idx" => array("columns" => array("name", "user_email"))
  86         ), $class->table['uniqueConstraints']);
  87
  88         return $class;
  89     }
  90
  91     /**
  92      * @depends testEntityTableNameAndInheritance
  93      * @param ClassMetadata $class
  94      */
  95     public function testEntityOptions($class)
  96     {
  97         $this->assertArrayHasKey('options', $class->table, 'ClassMetadata should have options key in table property.');
  98
  99         $this->assertEquals(array(
 100             'foo' => 'bar', 'baz' => array('key' => 'val')
 101         ), $class->table['options']);
 102
 103         return $class;
 104     }
 105
 106     /**
 107      * @depends testEntityOptions
 108      * @param ClassMetadata $class
 109      */
 110     public function testEntitySequence($class)
 111     {
 112         $this->assertInternalType('array', $class->sequenceGeneratorDefinition, 'No Sequence Definition set on this driver.');
 113         $this->assertEquals(
 114             array(
 115                 'sequenceName' => 'tablename_seq',
 116                 'allocationSize' => 100,
 117                 'initialValue' => 1,
 118             ),
 119             $class->sequenceGeneratorDefinition
 120         );
 121     }
 122
 123     public function testEntityCustomGenerator()
 124     {
 125         $class = $this->createClassMetadata('Doctrine\Tests\ORM\Mapping\Animal');
 126
 127         $this->assertEquals(ClassMetadata::GENERATOR_TYPE_CUSTOM,
 128             $class->generatorType, "Generator Type");
 129         $this->assertEquals(
 130             array("class" => "stdClass"),
 131             $class->customGeneratorDefinition,
 132             "Custom Generator Definition");
 133     }
 134
 135
 136     /**
 137      * @depends testEntityTableNameAndInheritance
 138      * @param ClassMetadata $class
 139      */
 140     public function testFieldMappings($class)
 141     {
 142         $this->assertEquals(3, count($class->fieldMappings));
 143         $this->assertTrue(isset($class->fieldMappings['id']));
 144         $this->assertTrue(isset($class->fieldMappings['name']));
 145         $this->assertTrue(isset($class->fieldMappings['email']));
 146
 147         return $class;
 148     }
 149
 150     /**
 151      * @depends testEntityTableNameAndInheritance
 152      * @param ClassMetadata $class
 153      */
 154     public function testFieldMappingsColumnNames($class)
 155     {
 156         $this->assertEquals("id", $class->fieldMappings['id']['columnName']);
 157         $this->assertEquals("name", $class->fieldMappings['name']['columnName']);
 158         $this->assertEquals("user_email", $class->fieldMappings['email']['columnName']);
 159
 160         return $class;
 161     }
 162
 163     /**
 164      * @depends testEntityTableNameAndInheritance
 165      * @param ClassMetadata $class
 166      */
 167     public function testStringFieldMappings($class)
 168     {
 169         $this->assertEquals('string', $class->fieldMappings['name']['type']);
 170         $this->assertEquals(50, $class->fieldMappings['name']['length']);
 171         $this->assertTrue($class->fieldMappings['name']['nullable']);
 172         $this->assertTrue($class->fieldMappings['name']['unique']);
 173
 174         $expected = array('foo' => 'bar', 'baz' => array('key' => 'val'));
 175         $this->assertEquals($expected, $class->fieldMappings['name']['options']);
 176
 177         return $class;
 178     }
 179
 180     /**
 181      * @depends testFieldMappings
 182      * @param ClassMetadata $class
 183      */
 184     public function testIdentifier($class)
 185     {
 186         $this->assertEquals(array('id'), $class->identifier);
 187         $this->assertEquals('integer', $class->fieldMappings['id']['type']);
 188         $this->assertEquals(ClassMetadata::GENERATOR_TYPE_AUTO, $class->generatorType, "ID-Generator is not ClassMetadata::GENERATOR_TYPE_AUTO");
 189
 190         return $class;
 191     }
 192
 193     /**
 194      * @depends testIdentifier
 195      * @param ClassMetadata $class
 196      */
 197     public function testAssocations($class)
 198     {
 199         $this->assertEquals(3, count($class->associationMappings));
 200
 201         return $class;
 202     }
 203
 204     /**
 205      * @depends testAssocations
 206      * @param ClassMetadata $class
 207      */
 208     public function testOwningOneToOneAssocation($class)
 209     {
 210         $this->assertTrue(isset($class->associationMappings['address']));
 211         $this->assertTrue($class->associationMappings['address']['isOwningSide']);
 212         $this->assertEquals('user', $class->associationMappings['address']['inversedBy']);
 213         // Check cascading
 214         $this->assertTrue($class->associationMappings['address']['isCascadeRemove']);
 215         $this->assertFalse($class->associationMappings['address']['isCascadePersist']);
 216         $this->assertFalse($class->associationMappings['address']['isCascadeRefresh']);
 217         $this->assertFalse($class->associationMappings['address']['isCascadeDetach']);
 218         $this->assertFalse($class->associationMappings['address']['isCascadeMerge']);
 219
 220         return $class;
 221     }
 222
 223     /**
 224      * @depends testOwningOneToOneAssocation
 225      * @param ClassMetadata $class
 226      */
 227     public function testInverseOneToManyAssociation($class)
 228     {
 229         $this->assertTrue(isset($class->associationMappings['phonenumbers']));
 230         $this->assertFalse($class->associationMappings['phonenumbers']['isOwningSide']);
 231         $this->assertTrue($class->associationMappings['phonenumbers']['isCascadePersist']);
 232         $this->assertTrue($class->associationMappings['phonenumbers']['isCascadeRemove']);
 233         $this->assertFalse($class->associationMappings['phonenumbers']['isCascadeRefresh']);
 234         $this->assertFalse($class->associationMappings['phonenumbers']['isCascadeDetach']);
 235         $this->assertFalse($class->associationMappings['phonenumbers']['isCascadeMerge']);
 236         $this->assertTrue($class->associationMappings['phonenumbers']['orphanRemoval']);
 237
 238         // Test Order By
 239         $this->assertEquals(array('number' => 'ASC'), $class->associationMappings['phonenumbers']['orderBy']);
 240
 241         return $class;
 242     }
 243
 244     /**
 245      * @depends testInverseOneToManyAssociation
 246      * @param ClassMetadata $class
 247      */
 248     public function testManyToManyAssociationWithCascadeAll($class)
 249     {
 250         $this->assertTrue(isset($class->associationMappings['groups']));
 251         $this->assertTrue($class->associationMappings['groups']['isOwningSide']);
 252         // Make sure that cascade-all works as expected
 253         $this->assertTrue($class->associationMappings['groups']['isCascadeRemove']);
 254         $this->assertTrue($class->associationMappings['groups']['isCascadePersist']);
 255         $this->assertTrue($class->associationMappings['groups']['isCascadeRefresh']);
 256         $this->assertTrue($class->associationMappings['groups']['isCascadeDetach']);
 257         $this->assertTrue($class->associationMappings['groups']['isCascadeMerge']);
 258
 259         $this->assertFalse(isset($class->associationMappings['groups']['orderBy']));
 260
 261         return $class;
 262     }
 263
 264     /**
 265      * @depends testManyToManyAssociationWithCascadeAll
 266      * @param ClassMetadata $class
 267      */
 268     public function testLifecycleCallbacks($class)
 269     {
 270         $this->assertEquals(count($class->lifecycleCallbacks), 2);
 271         $this->assertEquals($class->lifecycleCallbacks['prePersist'][0], 'doStuffOnPrePersist');
 272         $this->assertEquals($class->lifecycleCallbacks['postPersist'][0], 'doStuffOnPostPersist');
 273
 274         return $class;
 275     }
 276
 277     /**
 278      * @depends testManyToManyAssociationWithCascadeAll
 279      * @param ClassMetadata $class
 280      */
 281     public function testLifecycleCallbacksSupportMultipleMethodNames($class)
 282     {
 283         $this->assertEquals(count($class->lifecycleCallbacks['prePersist']), 2);
 284         $this->assertEquals($class->lifecycleCallbacks['prePersist'][1], 'doOtherStuffOnPrePersistToo');
 285
 286         return $class;
 287     }
 288
 289     /**
 290      * @depends testLifecycleCallbacksSupportMultipleMethodNames
 291      * @param ClassMetadata $class
 292      */
 293     public function testJoinColumnUniqueAndNullable($class)
 294     {
 295         // Non-Nullability of Join Column
 296         $this->assertFalse($class->associationMappings['groups']['joinTable']['joinColumns'][0]['nullable']);
 297         $this->assertFalse($class->associationMappings['groups']['joinTable']['joinColumns'][0]['unique']);
 298
 299         return $class;
 300     }
 301
 302     /**
 303      * @depends testJoinColumnUniqueAndNullable
 304      * @param ClassMetadata $class
 305      */
 306     public function testColumnDefinition($class)
 307     {
 308         $this->assertEquals("CHAR(32) NOT NULL", $class->fieldMappings['email']['columnDefinition']);
 309         $this->assertEquals("INT NULL", $class->associationMappings['groups']['joinTable']['inverseJoinColumns'][0]['columnDefinition']);
 310
 311         return $class;
 312     }
 313
 314     /**
 315      * @depends testColumnDefinition
 316      * @param ClassMetadata $class
 317      */
 318     public function testJoinColumnOnDelete($class)
 319     {
 320         $this->assertEquals('CASCADE', $class->associationMappings['address']['joinColumns'][0]['onDelete']);
 321
 322         return $class;
 323     }
 324
 325     /**
 326      * @group DDC-514
 327      */
 328     public function testDiscriminatorColumnDefaults()
 329     {
 330         if (strpos(get_class($this), 'PHPMappingDriver') !== false) {
 331             $this->markTestSkipped('PHP Mapping Drivers have no defaults.');
 332         }
 333
 334         $class = $this->createClassMetadata('Doctrine\Tests\ORM\Mapping\Animal');
 335
 336         $this->assertEquals(
 337             array('name' => 'discr', 'type' => 'string', 'length' => '32', 'fieldName' => 'discr', 'columnDefinition' => null),
 338             $class->discriminatorColumn
 339         );
 340     }
 341
 342     /**
 343      * @group DDC-869
 344      */
 345     public function testMappedSuperclassWithRepository()
 346     {
 347         $em         = $this->_getTestEntityManager();
 348         $factory    = $this->createClassMetadataFactory($em);
 349
 350
 351         $class = $factory->getMetadataFor('Doctrine\Tests\Models\DDC869\DDC869CreditCardPayment');
 352
 353         $this->assertTrue(isset($class->fieldMappings['id']));
 354         $this->assertTrue(isset($class->fieldMappings['value']));
 355         $this->assertTrue(isset($class->fieldMappings['creditCardNumber']));
 356         $this->assertEquals($class->customRepositoryClassName, "Doctrine\Tests\Models\DDC869\DDC869PaymentRepository");
 357         $this->assertInstanceOf("Doctrine\Tests\Models\DDC869\DDC869PaymentRepository",
 358              $em->getRepository("Doctrine\Tests\Models\DDC869\DDC869CreditCardPayment"));
 359         $this->assertTrue($em->getRepository("Doctrine\Tests\Models\DDC869\DDC869ChequePayment")->isTrue());
 360
 361
 362
 363         $class = $factory->getMetadataFor('Doctrine\Tests\Models\DDC869\DDC869ChequePayment');
 364
 365         $this->assertTrue(isset($class->fieldMappings['id']));
 366         $this->assertTrue(isset($class->fieldMappings['value']));
 367         $this->assertTrue(isset($class->fieldMappings['serialNumber']));
 368         $this->assertEquals($class->customRepositoryClassName, "Doctrine\Tests\Models\DDC869\DDC869PaymentRepository");
 369         $this->assertInstanceOf("Doctrine\Tests\Models\DDC869\DDC869PaymentRepository",
 370              $em->getRepository("Doctrine\Tests\Models\DDC869\DDC869ChequePayment"));
 371         $this->assertTrue($em->getRepository("Doctrine\Tests\Models\DDC869\DDC869ChequePayment")->isTrue());
 372     }
 373
 374     /**
 375      * @group DDC-1476
 376      */
 377     public function testDefaultFieldType()
 378     {
 379         $factory    = $this->createClassMetadataFactory();
 380         $class      = $factory->getMetadataFor('Doctrine\Tests\Models\DDC1476\DDC1476EntityWithDefaultFieldType');
 381
 382
 383         $this->assertArrayHasKey('id', $class->fieldMappings);
 384         $this->assertArrayHasKey('name', $class->fieldMappings);
 385
 386
 387         $this->assertArrayHasKey('type', $class->fieldMappings['id']);
 388         $this->assertArrayHasKey('type', $class->fieldMappings['name']);
 389
 390         $this->assertEquals('string', $class->fieldMappings['id']['type']);
 391         $this->assertEquals('string', $class->fieldMappings['name']['type']);
 392
 393
 394
 395         $this->assertArrayHasKey('fieldName', $class->fieldMappings['id']);
 396         $this->assertArrayHasKey('fieldName', $class->fieldMappings['name']);
 397
 398         $this->assertEquals('id', $class->fieldMappings['id']['fieldName']);
 399         $this->assertEquals('name', $class->fieldMappings['name']['fieldName']);
 400
 401
 402
 403         $this->assertArrayHasKey('columnName', $class->fieldMappings['id']);
 404         $this->assertArrayHasKey('columnName', $class->fieldMappings['name']);
 405
 406         $this->assertEquals('id', $class->fieldMappings['id']['columnName']);
 407         $this->assertEquals('name', $class->fieldMappings['name']['columnName']);
 408
 409         $this->assertEquals(ClassMetadataInfo::GENERATOR_TYPE_NONE, $class->generatorType);
 410     }
 411
 412     /**
 413      * @group DDC-1170
 414      */
 415     public function testIdentifierColumnDefinition()
 416     {
 417         $class = $this->createClassMetadata(__NAMESPACE__ . '\DDC1170Entity');
 418
 419
 420         $this->assertArrayHasKey('id', $class->fieldMappings);
 421         $this->assertArrayHasKey('value', $class->fieldMappings);
 422
 423         $this->assertArrayHasKey('columnDefinition', $class->fieldMappings['id']);
 424         $this->assertArrayHasKey('columnDefinition', $class->fieldMappings['value']);
 425
 426         $this->assertEquals("INT unsigned NOT NULL", $class->fieldMappings['id']['columnDefinition']);
 427         $this->assertEquals("VARCHAR(255) NOT NULL", $class->fieldMappings['value']['columnDefinition']);
 428     }
 429
 430     /**
 431      * @group DDC-559
 432      */
 433     public function testNamingStrategy()
 434     {
 435         $em         = $this->_getTestEntityManager();
 436         $factory    = $this->createClassMetadataFactory($em);
 437
 438
 439         $this->assertInstanceOf('Doctrine\ORM\Mapping\DefaultNamingStrategy', $em->getConfiguration()->getNamingStrategy());
 440         $em->getConfiguration()->setNamingStrategy(new \Doctrine\ORM\Mapping\UnderscoreNamingStrategy(CASE_UPPER));
 441         $this->assertInstanceOf('Doctrine\ORM\Mapping\UnderscoreNamingStrategy', $em->getConfiguration()->getNamingStrategy());
 442
 443         $class = $factory->getMetadataFor('Doctrine\Tests\Models\DDC1476\DDC1476EntityWithDefaultFieldType');
 444
 445         $this->assertEquals('ID', $class->columnNames['id']);
 446         $this->assertEquals('NAME', $class->columnNames['name']);
 447         $this->assertEquals('DDC1476ENTITY_WITH_DEFAULT_FIELD_TYPE', $class->table['name']);
 448     }
 449
 450     /**
 451      * @group DDC-807
 452      * @group DDC-553
 453      */
 454     public function testDiscriminatorColumnDefinition()
 455     {
 456         $class = $this->createClassMetadata(__NAMESPACE__ . '\DDC807Entity');
 457
 458         $this->assertArrayHasKey('columnDefinition', $class->discriminatorColumn);
 459         $this->assertArrayHasKey('name', $class->discriminatorColumn);
 460
 461         $this->assertEquals("ENUM('ONE','TWO')", $class->discriminatorColumn['columnDefinition']);
 462         $this->assertEquals("dtype", $class->discriminatorColumn['name']);
 463     }
 464
 465     /**
 466      * @group DDC-889
 467      * @expectedException Doctrine\ORM\Mapping\MappingException
 468      * @expectedExceptionMessage Class "Doctrine\Tests\Models\DDC889\DDC889Class" sub class of "Doctrine\Tests\Models\DDC889\DDC889SuperClass" is not a valid entity or mapped super class.
 469      */
 470     public function testInvalidEntityOrMappedSuperClassShouldMentionParentClasses()
 471     {
 472         $this->createClassMetadata('Doctrine\Tests\Models\DDC889\DDC889Class');
 473     }
 474
 475     /**
 476      * @group DDC-889
 477      * @expectedException Doctrine\ORM\Mapping\MappingException
 478      * @expectedExceptionMessage No identifier/primary key specified for Entity "Doctrine\Tests\Models\DDC889\DDC889Entity" sub class of "Doctrine\Tests\Models\DDC889\DDC889SuperClass". Every Entity must have an identifier/primary key.
 479      */
 480     public function testIdentifierRequiredShouldMentionParentClasses()
 481     {
 482
 483         $factory = $this->createClassMetadataFactory();
 484
 485         $factory->getMetadataFor('Doctrine\Tests\Models\DDC889\DDC889Entity');
 486     }
 487
 488     public function testNamedQuery()
 489     {
 490         $driver = $this->_loadDriver();
 491         $class = $this->createClassMetadata(__NAMESPACE__.'\User');
 492
 493         $this->assertCount(1, $class->getNamedQueries(), sprintf("Named queries not processed correctly by driver %s", get_class($driver)));
 494     }
 495
 496     /**
 497      * @group DDC-1663
 498      */
 499     public function testNamedNativeQuery()
 500     {
 501
 502         $class = $this->createClassMetadata('Doctrine\Tests\Models\CMS\CmsAddress');
 503
 504         //named native query
 505         $this->assertCount(3, $class->namedNativeQueries);
 506         $this->assertArrayHasKey('find-all', $class->namedNativeQueries);
 507         $this->assertArrayHasKey('find-by-id', $class->namedNativeQueries);
 508
 509
 510         $findAllQuery = $class->getNamedNativeQuery('find-all');
 511         $this->assertEquals('find-all', $findAllQuery['name']);
 512         $this->assertEquals('mapping-find-all', $findAllQuery['resultSetMapping']);
 513         $this->assertEquals('SELECT id, country, city FROM cms_addresses', $findAllQuery['query']);
 514
 515         $findByIdQuery = $class->getNamedNativeQuery('find-by-id');
 516         $this->assertEquals('find-by-id', $findByIdQuery['name']);
 517         $this->assertEquals('Doctrine\Tests\Models\CMS\CmsAddress',$findByIdQuery['resultClass']);
 518         $this->assertEquals('SELECT * FROM cms_addresses WHERE id = ?',  $findByIdQuery['query']);
 519
 520         $countQuery = $class->getNamedNativeQuery('count');
 521         $this->assertEquals('count', $countQuery['name']);
 522         $this->assertEquals('mapping-count', $countQuery['resultSetMapping']);
 523         $this->assertEquals('SELECT COUNT(*) AS count FROM cms_addresses',  $countQuery['query']);
 524
 525         // result set mapping
 526         $this->assertCount(3, $class->sqlResultSetMappings);
 527         $this->assertArrayHasKey('mapping-count', $class->sqlResultSetMappings);
 528         $this->assertArrayHasKey('mapping-find-all', $class->sqlResultSetMappings);
 529         $this->assertArrayHasKey('mapping-without-fields', $class->sqlResultSetMappings);
 530
 531         $findAllMapping = $class->getSqlResultSetMapping('mapping-find-all');
 532         $this->assertEquals('mapping-find-all', $findAllMapping['name']);
 533         $this->assertEquals('Doctrine\Tests\Models\CMS\CmsAddress', $findAllMapping['entities'][0]['entityClass']);
 534         $this->assertEquals(array('name'=>'id','column'=>'id'), $findAllMapping['entities'][0]['fields'][0]);
 535         $this->assertEquals(array('name'=>'city','column'=>'city'), $findAllMapping['entities'][0]['fields'][1]);
 536         $this->assertEquals(array('name'=>'country','column'=>'country'), $findAllMapping['entities'][0]['fields'][2]);
 537
 538         $withoutFieldsMapping = $class->getSqlResultSetMapping('mapping-without-fields');
 539         $this->assertEquals('mapping-without-fields', $withoutFieldsMapping['name']);
 540         $this->assertEquals('Doctrine\Tests\Models\CMS\CmsAddress', $withoutFieldsMapping['entities'][0]['entityClass']);
 541         $this->assertEquals(array(), $withoutFieldsMapping['entities'][0]['fields']);
 542
 543         $countMapping = $class->getSqlResultSetMapping('mapping-count');
 544         $this->assertEquals('mapping-count', $countMapping['name']);
 545         $this->assertEquals(array('name'=>'count'), $countMapping['columns'][0]);
 546
 547     }
 548
 549     /**
 550      * @group DDC-1663
 551      */
 552     public function testSqlResultSetMapping()
 553     {
 554
 555         $userMetadata   = $this->createClassMetadata('Doctrine\Tests\Models\CMS\CmsUser');
 556         $personMetadata = $this->createClassMetadata('Doctrine\Tests\Models\Company\CompanyPerson');
 557
 558         // user asserts
 559         $this->assertCount(4, $userMetadata->getSqlResultSetMappings());
 560
 561         $mapping = $userMetadata->getSqlResultSetMapping('mappingJoinedAddress');
 562         $this->assertEquals(array(),$mapping['columns']);
 563         $this->assertEquals('mappingJoinedAddress', $mapping['name']);
 564         $this->assertNull($mapping['entities'][0]['discriminatorColumn']);
 565         $this->assertEquals(array('name'=>'id','column'=>'id'),                     $mapping['entities'][0]['fields'][0]);
 566         $this->assertEquals(array('name'=>'name','column'=>'name'),                 $mapping['entities'][0]['fields'][1]);
 567         $this->assertEquals(array('name'=>'status','column'=>'status'),             $mapping['entities'][0]['fields'][2]);
 568         $this->assertEquals(array('name'=>'address.zip','column'=>'zip'),           $mapping['entities'][0]['fields'][3]);
 569         $this->assertEquals(array('name'=>'address.city','column'=>'city'),         $mapping['entities'][0]['fields'][4]);
 570         $this->assertEquals(array('name'=>'address.country','column'=>'country'),   $mapping['entities'][0]['fields'][5]);
 571         $this->assertEquals(array('name'=>'address.id','column'=>'a_id'),           $mapping['entities'][0]['fields'][6]);
 572         $this->assertEquals($userMetadata->name,                                    $mapping['entities'][0]['entityClass']);
 573
 574
 575         $mapping = $userMetadata->getSqlResultSetMapping('mappingJoinedPhonenumber');
 576         $this->assertEquals(array(),$mapping['columns']);
 577         $this->assertEquals('mappingJoinedPhonenumber', $mapping['name']);
 578         $this->assertNull($mapping['entities'][0]['discriminatorColumn']);
 579         $this->assertEquals(array('name'=>'id','column'=>'id'),                             $mapping['entities'][0]['fields'][0]);
 580         $this->assertEquals(array('name'=>'name','column'=>'name'),                         $mapping['entities'][0]['fields'][1]);
 581         $this->assertEquals(array('name'=>'status','column'=>'status'),                     $mapping['entities'][0]['fields'][2]);
 582         $this->assertEquals(array('name'=>'phonenumbers.phonenumber','column'=>'number'),   $mapping['entities'][0]['fields'][3]);
 583         $this->assertEquals($userMetadata->name,                                            $mapping['entities'][0]['entityClass']);
 584
 585         $mapping = $userMetadata->getSqlResultSetMapping('mappingUserPhonenumberCount');
 586         $this->assertEquals(array('name'=>'numphones'),$mapping['columns'][0]);
 587         $this->assertEquals('mappingUserPhonenumberCount', $mapping['name']);
 588         $this->assertNull($mapping['entities'][0]['discriminatorColumn']);
 589         $this->assertEquals(array('name'=>'id','column'=>'id'),         $mapping['entities'][0]['fields'][0]);
 590         $this->assertEquals(array('name'=>'name','column'=>'name'),     $mapping['entities'][0]['fields'][1]);
 591         $this->assertEquals(array('name'=>'status','column'=>'status'), $mapping['entities'][0]['fields'][2]);
 592         $this->assertEquals($userMetadata->name,                        $mapping['entities'][0]['entityClass']);
 593
 594         $mapping = $userMetadata->getSqlResultSetMapping('mappingMultipleJoinsEntityResults');
 595         $this->assertEquals(array('name'=>'numphones'),$mapping['columns'][0]);
 596         $this->assertEquals('mappingMultipleJoinsEntityResults', $mapping['name']);
 597         $this->assertNull($mapping['entities'][0]['discriminatorColumn']);
 598         $this->assertEquals(array('name'=>'id','column'=>'u_id'),           $mapping['entities'][0]['fields'][0]);
 599         $this->assertEquals(array('name'=>'name','column'=>'u_name'),       $mapping['entities'][0]['fields'][1]);
 600         $this->assertEquals(array('name'=>'status','column'=>'u_status'),   $mapping['entities'][0]['fields'][2]);
 601         $this->assertEquals($userMetadata->name,                            $mapping['entities'][0]['entityClass']);
 602         $this->assertNull($mapping['entities'][1]['discriminatorColumn']);
 603         $this->assertEquals(array('name'=>'id','column'=>'a_id'),           $mapping['entities'][1]['fields'][0]);
 604         $this->assertEquals(array('name'=>'zip','column'=>'a_zip'),         $mapping['entities'][1]['fields'][1]);
 605         $this->assertEquals(array('name'=>'country','column'=>'a_country'), $mapping['entities'][1]['fields'][2]);
 606         $this->assertEquals('Doctrine\Tests\Models\CMS\CmsAddress',         $mapping['entities'][1]['entityClass']);
 607
 608         //person asserts
 609         $this->assertCount(1, $personMetadata->getSqlResultSetMappings());
 610
 611         $mapping = $personMetadata->getSqlResultSetMapping('mappingFetchAll');
 612         $this->assertEquals(array(),$mapping['columns']);
 613         $this->assertEquals('mappingFetchAll', $mapping['name']);
 614         $this->assertEquals('discriminator',                            $mapping['entities'][0]['discriminatorColumn']);
 615         $this->assertEquals(array('name'=>'id','column'=>'id'),         $mapping['entities'][0]['fields'][0]);
 616         $this->assertEquals(array('name'=>'name','column'=>'name'),     $mapping['entities'][0]['fields'][1]);
 617         $this->assertEquals($personMetadata->name,                      $mapping['entities'][0]['entityClass']);
 618     }
 619
 620      /*
 621      * @group DDC-964
 622      */
 623     public function testAssociationOverridesMapping()
 624     {
 625
 626         $factory        = $this->createClassMetadataFactory();
 627         $adminMetadata  = $factory->getMetadataFor('Doctrine\Tests\Models\DDC964\DDC964Admin');
 628         $guestMetadata  = $factory->getMetadataFor('Doctrine\Tests\Models\DDC964\DDC964Guest');
 629
 630
 631         // assert groups association mappings
 632         $this->assertArrayHasKey('groups', $guestMetadata->associationMappings);
 633         $this->assertArrayHasKey('groups', $adminMetadata->associationMappings);
 634
 635         $guestGroups = $guestMetadata->associationMappings['groups'];
 636         $adminGroups = $adminMetadata->associationMappings['groups'];
 637
 638         // assert not override attributes
 639         $this->assertEquals($guestGroups['fieldName'], $adminGroups['fieldName']);
 640         $this->assertEquals($guestGroups['type'], $adminGroups['type']);
 641         $this->assertEquals($guestGroups['mappedBy'], $adminGroups['mappedBy']);
 642         $this->assertEquals($guestGroups['inversedBy'], $adminGroups['inversedBy']);
 643         $this->assertEquals($guestGroups['isOwningSide'], $adminGroups['isOwningSide']);
 644         $this->assertEquals($guestGroups['fetch'], $adminGroups['fetch']);
 645         $this->assertEquals($guestGroups['isCascadeRemove'], $adminGroups['isCascadeRemove']);
 646         $this->assertEquals($guestGroups['isCascadePersist'], $adminGroups['isCascadePersist']);
 647         $this->assertEquals($guestGroups['isCascadeRefresh'], $adminGroups['isCascadeRefresh']);
 648         $this->assertEquals($guestGroups['isCascadeMerge'], $adminGroups['isCascadeMerge']);
 649         $this->assertEquals($guestGroups['isCascadeDetach'], $adminGroups['isCascadeDetach']);
 650
 651          // assert not override attributes
 652         $this->assertEquals('ddc964_users_groups', $guestGroups['joinTable']['name']);
 653         $this->assertEquals('user_id', $guestGroups['joinTable']['joinColumns'][0]['name']);
 654         $this->assertEquals('group_id', $guestGroups['joinTable']['inverseJoinColumns'][0]['name']);
 655
 656         $this->assertEquals(array('user_id'=>'id'), $guestGroups['relationToSourceKeyColumns']);
 657         $this->assertEquals(array('group_id'=>'id'), $guestGroups['relationToTargetKeyColumns']);
 658         $this->assertEquals(array('user_id','group_id'), $guestGroups['joinTableColumns']);
 659
 660
 661         $this->assertEquals('ddc964_users_admingroups', $adminGroups['joinTable']['name']);
 662         $this->assertEquals('adminuser_id', $adminGroups['joinTable']['joinColumns'][0]['name']);
 663         $this->assertEquals('admingroup_id', $adminGroups['joinTable']['inverseJoinColumns'][0]['name']);
 664
 665         $this->assertEquals(array('adminuser_id'=>'id'), $adminGroups['relationToSourceKeyColumns']);
 666         $this->assertEquals(array('admingroup_id'=>'id'), $adminGroups['relationToTargetKeyColumns']);
 667         $this->assertEquals(array('adminuser_id','admingroup_id'), $adminGroups['joinTableColumns']);
 668
 669
 670         // assert address association mappings
 671         $this->assertArrayHasKey('address', $guestMetadata->associationMappings);
 672         $this->assertArrayHasKey('address', $adminMetadata->associationMappings);
 673
 674         $guestAddress = $guestMetadata->associationMappings['address'];
 675         $adminAddress = $adminMetadata->associationMappings['address'];
 676
 677         // assert not override attributes
 678         $this->assertEquals($guestAddress['fieldName'], $adminAddress['fieldName']);
 679         $this->assertEquals($guestAddress['type'], $adminAddress['type']);
 680         $this->assertEquals($guestAddress['mappedBy'], $adminAddress['mappedBy']);
 681         $this->assertEquals($guestAddress['inversedBy'], $adminAddress['inversedBy']);
 682         $this->assertEquals($guestAddress['isOwningSide'], $adminAddress['isOwningSide']);
 683         $this->assertEquals($guestAddress['fetch'], $adminAddress['fetch']);
 684         $this->assertEquals($guestAddress['isCascadeRemove'], $adminAddress['isCascadeRemove']);
 685         $this->assertEquals($guestAddress['isCascadePersist'], $adminAddress['isCascadePersist']);
 686         $this->assertEquals($guestAddress['isCascadeRefresh'], $adminAddress['isCascadeRefresh']);
 687         $this->assertEquals($guestAddress['isCascadeMerge'], $adminAddress['isCascadeMerge']);
 688         $this->assertEquals($guestAddress['isCascadeDetach'], $adminAddress['isCascadeDetach']);
 689
 690         // assert override
 691         $this->assertEquals('address_id', $guestAddress['joinColumns'][0]['name']);
 692         $this->assertEquals(array('address_id'=>'id'), $guestAddress['sourceToTargetKeyColumns']);
 693         $this->assertEquals(array('address_id'=>'address_id'), $guestAddress['joinColumnFieldNames']);
 694         $this->assertEquals(array('id'=>'address_id'), $guestAddress['targetToSourceKeyColumns']);
 695
 696
 697         $this->assertEquals('adminaddress_id', $adminAddress['joinColumns'][0]['name']);
 698         $this->assertEquals(array('adminaddress_id'=>'id'), $adminAddress['sourceToTargetKeyColumns']);
 699         $this->assertEquals(array('adminaddress_id'=>'adminaddress_id'), $adminAddress['joinColumnFieldNames']);
 700         $this->assertEquals(array('id'=>'adminaddress_id'), $adminAddress['targetToSourceKeyColumns']);
 701     }
 702
 703     /**
 704      * @group DDC-964
 705      */
 706     public function testAttributeOverridesMapping()
 707     {
 708
 709         $factory       = $this->createClassMetadataFactory();
 710         $guestMetadata = $factory->getMetadataFor('Doctrine\Tests\Models\DDC964\DDC964Guest');
 711         $adminMetadata = $factory->getMetadataFor('Doctrine\Tests\Models\DDC964\DDC964Admin');
 712
 713         $this->assertTrue($adminMetadata->fieldMappings['id']['id']);
 714         $this->assertEquals('id', $adminMetadata->fieldMappings['id']['fieldName']);
 715         $this->assertEquals('user_id', $adminMetadata->fieldMappings['id']['columnName']);
 716         $this->assertEquals(array('user_id'=>'id','user_name'=>'name'), $adminMetadata->fieldNames);
 717         $this->assertEquals(array('id'=>'user_id','name'=>'user_name'), $adminMetadata->columnNames);
 718         $this->assertEquals(150, $adminMetadata->fieldMappings['id']['length']);
 719
 720
 721         $this->assertEquals('name', $adminMetadata->fieldMappings['name']['fieldName']);
 722         $this->assertEquals('user_name', $adminMetadata->fieldMappings['name']['columnName']);
 723         $this->assertEquals(250, $adminMetadata->fieldMappings['name']['length']);
 724         $this->assertTrue($adminMetadata->fieldMappings['name']['nullable']);
 725         $this->assertFalse($adminMetadata->fieldMappings['name']['unique']);
 726
 727
 728         $this->assertTrue($guestMetadata->fieldMappings['id']['id']);
 729         $this->assertEquals('guest_id', $guestMetadata->fieldMappings['id']['columnName']);
 730         $this->assertEquals('id', $guestMetadata->fieldMappings['id']['fieldName']);
 731         $this->assertEquals(array('guest_id'=>'id','guest_name'=>'name'), $guestMetadata->fieldNames);
 732         $this->assertEquals(array('id'=>'guest_id','name'=>'guest_name'), $guestMetadata->columnNames);
 733         $this->assertEquals(140, $guestMetadata->fieldMappings['id']['length']);
 734
 735         $this->assertEquals('name', $guestMetadata->fieldMappings['name']['fieldName']);
 736         $this->assertEquals('guest_name', $guestMetadata->fieldMappings['name']['columnName']);
 737         $this->assertEquals(240, $guestMetadata->fieldMappings['name']['length']);
 738         $this->assertFalse($guestMetadata->fieldMappings['name']['nullable']);
 739         $this->assertTrue($guestMetadata->fieldMappings['name']['unique']);
 740     }
 741
 742 }
 743
 744 /**
 745  * @Entity
 746  * @HasLifecycleCallbacks
 747  * @Table(
 748  *  name="cms_users",
 749  *  uniqueConstraints={@UniqueConstraint(name="search_idx", columns={"name", "user_email"})},
 750  *  indexes={@Index(name="name_idx", columns={"name"}), @Index(name="0", columns={"user_email"})},
 751  *  options={"foo": "bar", "baz": {"key": "val"}}
 752  * )
 753  * @NamedQueries({@NamedQuery(name="all", query="SELECT u FROM __CLASS__ u")})
 754  */
 755 class User
 756 {
 757     /**
 758      * @Id
 759      * @Column(type="integer")
 760      * @generatedValue(strategy="AUTO")
 761      * @SequenceGenerator(sequenceName="tablename_seq", initialValue=1, allocationSize=100)
 762      **/
 763     public $id;
 764
 765     /**
 766      * @Column(length=50, nullable=true, unique=true, options={"foo": "bar", "baz": {"key": "val"}})
 767      */
 768     public $name;
 769
 770     /**
 771      * @Column(name="user_email", columnDefinition="CHAR(32) NOT NULL")
 772      */
 773     public $email;
 774
 775     /**
 776      * @OneToOne(targetEntity="Address", cascade={"remove"}, inversedBy="user")
 777      * @JoinColumn(onDelete="CASCADE")
 778      */
 779     public $address;
 780
 781     /**
 782      * @OneToMany(targetEntity="Phonenumber", mappedBy="user", cascade={"persist"}, orphanRemoval=true)
 783      * @OrderBy({"number"="ASC"})
 784      */
 785     public $phonenumbers;
 786
 787     /**
 788      * @ManyToMany(targetEntity="Group", cascade={"all"})
 789      * @JoinTable(name="cms_user_groups",
 790      *    joinColumns={@JoinColumn(name="user_id", referencedColumnName="id", nullable=false, unique=false)},
 791      *    inverseJoinColumns={@JoinColumn(name="group_id", referencedColumnName="id", columnDefinition="INT NULL")}
 792      * )
 793      */
 794     public $groups;
 795
 796
 797     /**
 798      * @PrePersist
 799      */
 800     public function doStuffOnPrePersist()
 801     {
 802     }
 803
 804     /**
 805      * @PrePersist
 806      */
 807     public function doOtherStuffOnPrePersistToo() {
 808     }
 809
 810     /**
 811      * @PostPersist
 812      */
 813     public function doStuffOnPostPersist()
 814     {
 815
 816     }
 817
 818     public static function loadMetadata(ClassMetadataInfo $metadata)
 819     {
 820         $metadata->setInheritanceType(ClassMetadataInfo::INHERITANCE_TYPE_NONE);
 821         $metadata->setPrimaryTable(array(
 822            'name' => 'cms_users',
 823            'options' => array('foo' => 'bar', 'baz' => array('key' => 'val')),
 824           ));
 825         $metadata->setChangeTrackingPolicy(ClassMetadataInfo::CHANGETRACKING_DEFERRED_IMPLICIT);
 826         $metadata->addLifecycleCallback('doStuffOnPrePersist', 'prePersist');
 827         $metadata->addLifecycleCallback('doOtherStuffOnPrePersistToo', 'prePersist');
 828         $metadata->addLifecycleCallback('doStuffOnPostPersist', 'postPersist');
 829         $metadata->mapField(array(
 830            'id' => true,
 831            'fieldName' => 'id',
 832            'type' => 'integer',
 833            'columnName' => 'id',
 834           ));
 835         $metadata->mapField(array(
 836            'fieldName' => 'name',
 837            'type' => 'string',
 838            'length' => 50,
 839            'unique' => true,
 840            'nullable' => true,
 841            'columnName' => 'name',
 842            'options' => array('foo' => 'bar', 'baz' => array('key' => 'val')),
 843           ));
 844         $metadata->mapField(array(
 845            'fieldName' => 'email',
 846            'type' => 'string',
 847            'columnName' => 'user_email',
 848            'columnDefinition' => 'CHAR(32) NOT NULL',
 849           ));
 850         $metadata->setIdGeneratorType(ClassMetadataInfo::GENERATOR_TYPE_AUTO);
 851         $metadata->mapOneToOne(array(
 852            'fieldName' => 'address',
 853            'targetEntity' => 'Doctrine\\Tests\\ORM\\Mapping\\Address',
 854            'cascade' =>
 855            array(
 856            0 => 'remove',
 857            ),
 858            'mappedBy' => NULL,
 859            'inversedBy' => 'user',
 860            'joinColumns' =>
 861            array(
 862            0 =>
 863            array(
 864             'name' => 'address_id',
 865             'referencedColumnName' => 'id',
 866             'onDelete' => 'CASCADE',
 867            ),
 868            ),
 869            'orphanRemoval' => false,
 870           ));
 871         $metadata->mapOneToMany(array(
 872            'fieldName' => 'phonenumbers',
 873            'targetEntity' => 'Doctrine\\Tests\\ORM\\Mapping\\Phonenumber',
 874            'cascade' =>
 875            array(
 876            1 => 'persist',
 877            ),
 878            'mappedBy' => 'user',
 879            'orphanRemoval' => true,
 880            'orderBy' =>
 881            array(
 882            'number' => 'ASC',
 883            ),
 884           ));
 885         $metadata->mapManyToMany(array(
 886            'fieldName' => 'groups',
 887            'targetEntity' => 'Doctrine\\Tests\\ORM\\Mapping\\Group',
 888            'cascade' =>
 889            array(
 890            0 => 'remove',
 891            1 => 'persist',
 892            2 => 'refresh',
 893            3 => 'merge',
 894            4 => 'detach',
 895            ),
 896            'mappedBy' => NULL,
 897            'joinTable' =>
 898            array(
 899            'name' => 'cms_users_groups',
 900            'joinColumns' =>
 901            array(
 902             0 =>
 903             array(
 904             'name' => 'user_id',
 905             'referencedColumnName' => 'id',
 906             'unique' => false,
 907             'nullable' => false,
 908             ),
 909            ),
 910            'inverseJoinColumns' =>
 911            array(
 912             0 =>
 913             array(
 914             'name' => 'group_id',
 915             'referencedColumnName' => 'id',
 916             'columnDefinition' => 'INT NULL',
 917             ),
 918            ),
 919            ),
 920            'orderBy' => NULL,
 921           ));
 922         $metadata->table['uniqueConstraints'] = array(
 923             'search_idx' => array('columns' => array('name', 'user_email')),
 924         );
 925         $metadata->table['indexes'] = array(
 926             'name_idx' => array('columns' => array('name')), 0 => array('columns' => array('user_email'))
 927         );
 928         $metadata->setSequenceGeneratorDefinition(array(
 929                 'sequenceName' => 'tablename_seq',
 930                 'allocationSize' => 100,
 931                 'initialValue' => 1,
 932             ));
 933         $metadata->addNamedQuery(array(
 934                 'name' => 'all',
 935                 'query' => 'SELECT u FROM __CLASS__ u'
 936             ));
 937     }
 938 }
 939
 940 /**
 941  * @Entity
 942  * @InheritanceType("SINGLE_TABLE")
 943  * @DiscriminatorMap({"cat" = "Cat", "dog" = "Dog"})
 944  * @DiscriminatorColumn(name="discr", length=32, type="string")
 945  */
 946 abstract class Animal
 947 {
 948     /**
 949      * @Id @Column(type="string") @GeneratedValue(strategy="CUSTOM")
 950      * @CustomIdGenerator(class="stdClass")
 951      */
 952     public $id;
 953
 954     public static function loadMetadata(ClassMetadataInfo $metadata)
 955     {
 956         $metadata->setIdGeneratorType(ClassMetadataInfo::GENERATOR_TYPE_CUSTOM);
 957         $metadata->setCustomGeneratorDefinition(array("class" => "stdClass"));
 958     }
 959 }
 960
 961 /** @Entity */
 962 class Cat extends Animal
 963 {
 964     public static function loadMetadata(ClassMetadataInfo $metadata)
 965     {
 966
 967     }
 968 }
 969
 970 /** @Entity */
 971 class Dog extends Animal
 972 {
 973     public static function loadMetadata(ClassMetadataInfo $metadata)
 974     {
 975
 976     }
 977 }
 978
 979
 980 /**
 981  * @Entity
 982  */
 983 class DDC1170Entity
 984 {
 985
 986     /**
 987      * @param string $value
 988      */
 989     function __construct($value = null)
 990     {
 991         $this->value = $value;
 992     }
 993
 994     /**
 995      * @Id
 996      * @GeneratedValue(strategy="NONE")
 997      * @Column(type="integer", columnDefinition = "INT unsigned NOT NULL")
 998      **/
 999     private $id;
1000
1001     /**
1002      * @Column(columnDefinition = "VARCHAR(255) NOT NULL")
1003      */
1004     private $value;
1005
1006     /**
1007      * @return integer
1008      */
1009     public function getId()
1010     {
1011         return $this->id;
1012     }
1013
1014     /**
1015      * @return string
1016      */
1017     public function getValue()
1018     {
1019         return $this->value;
1020     }
1021
1022     public static function loadMetadata(ClassMetadataInfo $metadata)
1023     {
1024         $metadata->mapField(array(
1025            'id'                 => true,
1026            'fieldName'          => 'id',
1027            'columnDefinition'   => 'INT unsigned NOT NULL',
1028         ));
1029
1030         $metadata->mapField(array(
1031             'fieldName'         => 'value',
1032             'columnDefinition'  => 'VARCHAR(255) NOT NULL'
1033         ));
1034
1035         $metadata->setIdGeneratorType(ClassMetadataInfo::GENERATOR_TYPE_NONE);
1036     }
1037
1038 }
1039
1040 /**
1041  * @Entity
1042  * @InheritanceType("SINGLE_TABLE")
1043  * @DiscriminatorMap({"ONE" = "DDC807SubClasse1", "TWO" = "DDC807SubClasse2"})
1044  * @DiscriminatorColumn(name = "dtype", columnDefinition="ENUM('ONE','TWO')")
1045  */
1046 class DDC807Entity
1047 {
1048     /**
1049      * @Id
1050      * @Column(type="integer")
1051      * @GeneratedValue(strategy="NONE")
1052      **/
1053    public $id;
1054
1055    public static function loadMetadata(ClassMetadataInfo $metadata)
1056     {
1057          $metadata->mapField(array(
1058            'id'                 => true,
1059            'fieldName'          => 'id',
1060         ));
1061
1062         $metadata->setDiscriminatorColumn(array(
1063             'name'              => "dtype",
1064             'type'              => "string",
1065             'columnDefinition'  => "ENUM('ONE','TWO')"
1066         ));
1067
1068         $metadata->setIdGeneratorType(ClassMetadataInfo::GENERATOR_TYPE_NONE);
1069     }
1070 }
1071
1072
1073 class DDC807SubClasse1 {}
1074 class DDC807SubClasse2 {}
1075
1076 class Address {}
1077 class Phonenumber {}
1078 class Group {}