952 lines
39 KiB
PHP
952 lines
39 KiB
PHP
<?php
|
|
|
|
namespace Doctrine\Tests\ORM\Mapping;
|
|
|
|
use Doctrine\ORM\Mapping\ClassMetadata;
|
|
use Doctrine\ORM\Events;
|
|
|
|
require_once __DIR__ . '/../../TestInit.php';
|
|
require_once __DIR__ . '/../../Models/Global/GlobalNamespaceModel.php';
|
|
|
|
class ClassMetadataTest extends \Doctrine\Tests\OrmTestCase
|
|
{
|
|
public function testClassMetadataInstanceSerialization()
|
|
{
|
|
$cm = new ClassMetadata('Doctrine\Tests\Models\CMS\CmsUser');
|
|
$cm->initializeReflection(new \Doctrine\Common\Persistence\Mapping\RuntimeReflectionService);
|
|
|
|
// Test initial state
|
|
$this->assertTrue(count($cm->getReflectionProperties()) == 0);
|
|
$this->assertInstanceOf('ReflectionClass', $cm->reflClass);
|
|
$this->assertEquals('Doctrine\Tests\Models\CMS\CmsUser', $cm->name);
|
|
$this->assertEquals('Doctrine\Tests\Models\CMS\CmsUser', $cm->rootEntityName);
|
|
$this->assertEquals(array(), $cm->subClasses);
|
|
$this->assertEquals(array(), $cm->parentClasses);
|
|
$this->assertEquals(ClassMetadata::INHERITANCE_TYPE_NONE, $cm->inheritanceType);
|
|
|
|
// Customize state
|
|
$cm->setInheritanceType(ClassMetadata::INHERITANCE_TYPE_SINGLE_TABLE);
|
|
$cm->setSubclasses(array("One", "Two", "Three"));
|
|
$cm->setParentClasses(array("UserParent"));
|
|
$cm->setCustomRepositoryClass("UserRepository");
|
|
$cm->setDiscriminatorColumn(array('name' => 'disc', 'type' => 'integer'));
|
|
$cm->mapOneToOne(array('fieldName' => 'phonenumbers', 'targetEntity' => 'CmsAddress', 'mappedBy' => 'foo'));
|
|
$cm->markReadOnly();
|
|
$cm->addNamedQuery(array('name' => 'dql', 'query' => 'foo'));
|
|
$this->assertEquals(1, count($cm->associationMappings));
|
|
|
|
$serialized = serialize($cm);
|
|
$cm = unserialize($serialized);
|
|
$cm->wakeupReflection(new \Doctrine\Common\Persistence\Mapping\RuntimeReflectionService);
|
|
|
|
// Check state
|
|
$this->assertTrue(count($cm->getReflectionProperties()) > 0);
|
|
$this->assertEquals('Doctrine\Tests\Models\CMS', $cm->namespace);
|
|
$this->assertInstanceOf('ReflectionClass', $cm->reflClass);
|
|
$this->assertEquals('Doctrine\Tests\Models\CMS\CmsUser', $cm->name);
|
|
$this->assertEquals('UserParent', $cm->rootEntityName);
|
|
$this->assertEquals(array('Doctrine\Tests\Models\CMS\One', 'Doctrine\Tests\Models\CMS\Two', 'Doctrine\Tests\Models\CMS\Three'), $cm->subClasses);
|
|
$this->assertEquals(array('UserParent'), $cm->parentClasses);
|
|
$this->assertEquals('Doctrine\Tests\Models\CMS\UserRepository', $cm->customRepositoryClassName);
|
|
$this->assertEquals(array('name' => 'disc', 'type' => 'integer', 'fieldName' => 'disc'), $cm->discriminatorColumn);
|
|
$this->assertTrue($cm->associationMappings['phonenumbers']['type'] == ClassMetadata::ONE_TO_ONE);
|
|
$this->assertEquals(1, count($cm->associationMappings));
|
|
$oneOneMapping = $cm->getAssociationMapping('phonenumbers');
|
|
$this->assertTrue($oneOneMapping['fetch'] == ClassMetadata::FETCH_LAZY);
|
|
$this->assertEquals('phonenumbers', $oneOneMapping['fieldName']);
|
|
$this->assertEquals('Doctrine\Tests\Models\CMS\CmsAddress', $oneOneMapping['targetEntity']);
|
|
$this->assertTrue($cm->isReadOnly);
|
|
$this->assertEquals(array('dql' => array('name'=>'dql','query'=>'foo','dql'=>'foo')), $cm->namedQueries);
|
|
}
|
|
|
|
public function testFieldIsNullable()
|
|
{
|
|
$cm = new ClassMetadata('Doctrine\Tests\Models\CMS\CmsUser');
|
|
$cm->initializeReflection(new \Doctrine\Common\Persistence\Mapping\RuntimeReflectionService);
|
|
|
|
// Explicit Nullable
|
|
$cm->mapField(array('fieldName' => 'status', 'nullable' => true, 'type' => 'string', 'length' => 50));
|
|
$this->assertTrue($cm->isNullable('status'));
|
|
|
|
// Explicit Not Nullable
|
|
$cm->mapField(array('fieldName' => 'username', 'nullable' => false, 'type' => 'string', 'length' => 50));
|
|
$this->assertFalse($cm->isNullable('username'));
|
|
|
|
// Implicit Not Nullable
|
|
$cm->mapField(array('fieldName' => 'name', 'type' => 'string', 'length' => 50));
|
|
$this->assertFalse($cm->isNullable('name'), "By default a field should not be nullable.");
|
|
}
|
|
|
|
/**
|
|
* @group DDC-115
|
|
*/
|
|
public function testMapAssocationInGlobalNamespace()
|
|
{
|
|
require_once __DIR__."/../../Models/Global/GlobalNamespaceModel.php";
|
|
|
|
$cm = new ClassMetadata('DoctrineGlobal_Article');
|
|
$cm->initializeReflection(new \Doctrine\Common\Persistence\Mapping\RuntimeReflectionService);
|
|
$cm->mapManyToMany(array(
|
|
'fieldName' => 'author',
|
|
'targetEntity' => 'DoctrineGlobal_User',
|
|
'joinTable' => array(
|
|
'name' => 'bar',
|
|
'joinColumns' => array(array('name' => 'bar_id', 'referencedColumnName' => 'id')),
|
|
'inverseJoinColumns' => array(array('name' => 'baz_id', 'referencedColumnName' => 'id')),
|
|
),
|
|
));
|
|
|
|
$this->assertEquals("DoctrineGlobal_User", $cm->associationMappings['author']['targetEntity']);
|
|
}
|
|
|
|
public function testMapManyToManyJoinTableDefaults()
|
|
{
|
|
$cm = new ClassMetadata('Doctrine\Tests\Models\CMS\CmsUser');
|
|
$cm->initializeReflection(new \Doctrine\Common\Persistence\Mapping\RuntimeReflectionService);
|
|
$cm->mapManyToMany(
|
|
array(
|
|
'fieldName' => 'groups',
|
|
'targetEntity' => 'CmsGroup'
|
|
));
|
|
|
|
$assoc = $cm->associationMappings['groups'];
|
|
//$this->assertInstanceOf('Doctrine\ORM\Mapping\ManyToManyMapping', $assoc);
|
|
$this->assertEquals(array(
|
|
'name' => 'cmsuser_cmsgroup',
|
|
'joinColumns' => array(array('name' => 'cmsuser_id', 'referencedColumnName' => 'id', 'onDelete' => 'CASCADE')),
|
|
'inverseJoinColumns' => array(array('name' => 'cmsgroup_id', 'referencedColumnName' => 'id', 'onDelete' => 'CASCADE'))
|
|
), $assoc['joinTable']);
|
|
$this->assertTrue($assoc['isOnDeleteCascade']);
|
|
}
|
|
|
|
public function testSerializeManyToManyJoinTableCascade()
|
|
{
|
|
$cm = new ClassMetadata('Doctrine\Tests\Models\CMS\CmsUser');
|
|
$cm->initializeReflection(new \Doctrine\Common\Persistence\Mapping\RuntimeReflectionService);
|
|
$cm->mapManyToMany(
|
|
array(
|
|
'fieldName' => 'groups',
|
|
'targetEntity' => 'CmsGroup'
|
|
));
|
|
|
|
/* @var $assoc \Doctrine\ORM\Mapping\ManyToManyMapping */
|
|
$assoc = $cm->associationMappings['groups'];
|
|
$assoc = unserialize(serialize($assoc));
|
|
|
|
$this->assertTrue($assoc['isOnDeleteCascade']);
|
|
}
|
|
|
|
/**
|
|
* @group DDC-115
|
|
*/
|
|
public function testSetDiscriminatorMapInGlobalNamespace()
|
|
{
|
|
require_once __DIR__."/../../Models/Global/GlobalNamespaceModel.php";
|
|
|
|
$cm = new ClassMetadata('DoctrineGlobal_User');
|
|
$cm->initializeReflection(new \Doctrine\Common\Persistence\Mapping\RuntimeReflectionService);
|
|
$cm->setDiscriminatorMap(array('descr' => 'DoctrineGlobal_Article', 'foo' => 'DoctrineGlobal_User'));
|
|
|
|
$this->assertEquals("DoctrineGlobal_Article", $cm->discriminatorMap['descr']);
|
|
$this->assertEquals("DoctrineGlobal_User", $cm->discriminatorMap['foo']);
|
|
}
|
|
|
|
/**
|
|
* @group DDC-115
|
|
*/
|
|
public function testSetSubClassesInGlobalNamespace()
|
|
{
|
|
require_once __DIR__."/../../Models/Global/GlobalNamespaceModel.php";
|
|
|
|
$cm = new ClassMetadata('DoctrineGlobal_User');
|
|
$cm->initializeReflection(new \Doctrine\Common\Persistence\Mapping\RuntimeReflectionService);
|
|
$cm->setSubclasses(array('DoctrineGlobal_Article'));
|
|
|
|
$this->assertEquals("DoctrineGlobal_Article", $cm->subClasses[0]);
|
|
}
|
|
|
|
/**
|
|
* @group DDC-268
|
|
*/
|
|
public function testSetInvalidVersionMapping_ThrowsException()
|
|
{
|
|
$field = array();
|
|
$field['fieldName'] = 'foo';
|
|
$field['type'] = 'string';
|
|
|
|
$cm = new ClassMetadata('Doctrine\Tests\Models\CMS\CmsUser');
|
|
$cm->initializeReflection(new \Doctrine\Common\Persistence\Mapping\RuntimeReflectionService);
|
|
|
|
$this->setExpectedException('Doctrine\ORM\Mapping\MappingException');
|
|
$cm->setVersionMapping($field);
|
|
}
|
|
|
|
public function testGetSingleIdentifierFieldName_MultipleIdentifierEntity_ThrowsException()
|
|
{
|
|
$cm = new ClassMetadata('Doctrine\Tests\Models\CMS\CmsUser');
|
|
$cm->initializeReflection(new \Doctrine\Common\Persistence\Mapping\RuntimeReflectionService);
|
|
$cm->isIdentifierComposite = true;
|
|
|
|
$this->setExpectedException('Doctrine\ORM\Mapping\MappingException');
|
|
$cm->getSingleIdentifierFieldName();
|
|
}
|
|
|
|
public function testDuplicateAssociationMappingException()
|
|
{
|
|
$cm = new ClassMetadata('Doctrine\Tests\Models\CMS\CmsUser');
|
|
$cm->initializeReflection(new \Doctrine\Common\Persistence\Mapping\RuntimeReflectionService);
|
|
|
|
$a1 = array('fieldName' => 'foo', 'sourceEntity' => 'stdClass', 'targetEntity' => 'stdClass', 'mappedBy' => 'foo');
|
|
$a2 = array('fieldName' => 'foo', 'sourceEntity' => 'stdClass', 'targetEntity' => 'stdClass', 'mappedBy' => 'foo');
|
|
|
|
$cm->addInheritedAssociationMapping($a1);
|
|
$this->setExpectedException('Doctrine\ORM\Mapping\MappingException');
|
|
$cm->addInheritedAssociationMapping($a2);
|
|
}
|
|
|
|
public function testDuplicateColumnName_ThrowsMappingException()
|
|
{
|
|
$cm = new ClassMetadata('Doctrine\Tests\Models\CMS\CmsUser');
|
|
$cm->initializeReflection(new \Doctrine\Common\Persistence\Mapping\RuntimeReflectionService);
|
|
|
|
$cm->mapField(array('fieldName' => 'name', 'columnName' => 'name'));
|
|
|
|
$this->setExpectedException('Doctrine\ORM\Mapping\MappingException');
|
|
$cm->mapField(array('fieldName' => 'username', 'columnName' => 'name'));
|
|
}
|
|
|
|
public function testDuplicateColumnName_DiscriminatorColumn_ThrowsMappingException()
|
|
{
|
|
$cm = new ClassMetadata('Doctrine\Tests\Models\CMS\CmsUser');
|
|
$cm->initializeReflection(new \Doctrine\Common\Persistence\Mapping\RuntimeReflectionService);
|
|
|
|
$cm->mapField(array('fieldName' => 'name', 'columnName' => 'name'));
|
|
|
|
$this->setExpectedException('Doctrine\ORM\Mapping\MappingException');
|
|
$cm->setDiscriminatorColumn(array('name' => 'name'));
|
|
}
|
|
|
|
public function testDuplicateColumnName_DiscriminatorColumn2_ThrowsMappingException()
|
|
{
|
|
$cm = new ClassMetadata('Doctrine\Tests\Models\CMS\CmsUser');
|
|
$cm->initializeReflection(new \Doctrine\Common\Persistence\Mapping\RuntimeReflectionService);
|
|
|
|
$cm->setDiscriminatorColumn(array('name' => 'name'));
|
|
|
|
$this->setExpectedException('Doctrine\ORM\Mapping\MappingException');
|
|
$cm->mapField(array('fieldName' => 'name', 'columnName' => 'name'));
|
|
}
|
|
|
|
public function testDuplicateFieldAndAssocationMapping1_ThrowsException()
|
|
{
|
|
$cm = new ClassMetadata('Doctrine\Tests\Models\CMS\CmsUser');
|
|
$cm->initializeReflection(new \Doctrine\Common\Persistence\Mapping\RuntimeReflectionService);
|
|
|
|
$cm->mapField(array('fieldName' => 'name', 'columnName' => 'name'));
|
|
|
|
$this->setExpectedException('Doctrine\ORM\Mapping\MappingException');
|
|
$cm->mapOneToOne(array('fieldName' => 'name', 'targetEntity' => 'CmsUser'));
|
|
}
|
|
|
|
public function testDuplicateFieldAndAssocationMapping2_ThrowsException()
|
|
{
|
|
$cm = new ClassMetadata('Doctrine\Tests\Models\CMS\CmsUser');
|
|
$cm->initializeReflection(new \Doctrine\Common\Persistence\Mapping\RuntimeReflectionService);
|
|
|
|
$cm->mapOneToOne(array('fieldName' => 'name', 'targetEntity' => 'CmsUser'));
|
|
|
|
$this->setExpectedException('Doctrine\ORM\Mapping\MappingException');
|
|
$cm->mapField(array('fieldName' => 'name', 'columnName' => 'name'));
|
|
}
|
|
|
|
/**
|
|
* @group DDC-1224
|
|
*/
|
|
public function testGetTemporaryTableNameSchema()
|
|
{
|
|
$cm = new ClassMetadata('Doctrine\Tests\Models\CMS\CmsUser');
|
|
$cm->initializeReflection(new \Doctrine\Common\Persistence\Mapping\RuntimeReflectionService);
|
|
|
|
$cm->setTableName('foo.bar');
|
|
|
|
$this->assertEquals('foo_bar_id_tmp', $cm->getTemporaryIdTableName());
|
|
}
|
|
|
|
public function testDefaultTableName()
|
|
{
|
|
$cm = new ClassMetadata('Doctrine\Tests\Models\CMS\CmsUser');
|
|
$cm->initializeReflection(new \Doctrine\Common\Persistence\Mapping\RuntimeReflectionService);
|
|
|
|
// When table's name is not given
|
|
$primaryTable = array();
|
|
$cm->setPrimaryTable($primaryTable);
|
|
|
|
$this->assertEquals('CmsUser', $cm->getTableName());
|
|
$this->assertEquals('CmsUser', $cm->table['name']);
|
|
|
|
$cm = new ClassMetadata('Doctrine\Tests\Models\CMS\CmsAddress');
|
|
$cm->initializeReflection(new \Doctrine\Common\Persistence\Mapping\RuntimeReflectionService);
|
|
// When joinTable's name is not given
|
|
$cm->mapManyToMany(array(
|
|
'fieldName' => 'user',
|
|
'targetEntity' => 'CmsUser',
|
|
'inversedBy' => 'users',
|
|
'joinTable' => array('joinColumns' => array(array('referencedColumnName' => 'id')),
|
|
'inverseJoinColumns' => array(array('referencedColumnName' => 'id')))));
|
|
$this->assertEquals('cmsaddress_cmsuser', $cm->associationMappings['user']['joinTable']['name']);
|
|
}
|
|
|
|
public function testDefaultJoinColumnName()
|
|
{
|
|
$cm = new ClassMetadata('Doctrine\Tests\Models\CMS\CmsAddress');
|
|
$cm->initializeReflection(new \Doctrine\Common\Persistence\Mapping\RuntimeReflectionService);
|
|
|
|
// this is really dirty, but it's the simpliest way to test whether
|
|
// joinColumn's name will be automatically set to user_id
|
|
$cm->mapOneToOne(array(
|
|
'fieldName' => 'user',
|
|
'targetEntity' => 'CmsUser',
|
|
'joinColumns' => array(array('referencedColumnName' => 'id'))));
|
|
$this->assertEquals('user_id', $cm->associationMappings['user']['joinColumns'][0]['name']);
|
|
|
|
$cm = new ClassMetadata('Doctrine\Tests\Models\CMS\CmsAddress');
|
|
$cm->initializeReflection(new \Doctrine\Common\Persistence\Mapping\RuntimeReflectionService);
|
|
$cm->mapManyToMany(array(
|
|
'fieldName' => 'user',
|
|
'targetEntity' => 'CmsUser',
|
|
'inversedBy' => 'users',
|
|
'joinTable' => array('name' => 'user_CmsUser',
|
|
'joinColumns' => array(array('referencedColumnName' => 'id')),
|
|
'inverseJoinColumns' => array(array('referencedColumnName' => 'id')))));
|
|
$this->assertEquals('cmsaddress_id', $cm->associationMappings['user']['joinTable']['joinColumns'][0]['name']);
|
|
$this->assertEquals('cmsuser_id', $cm->associationMappings['user']['joinTable']['inverseJoinColumns'][0]['name']);
|
|
}
|
|
|
|
/**
|
|
* @group DDC-559
|
|
*/
|
|
public function testUnderscoreNamingStrategyDefaults()
|
|
{
|
|
$namingStrategy = new \Doctrine\ORM\Mapping\UnderscoreNamingStrategy(CASE_UPPER);
|
|
$oneToOneMetadata = new ClassMetadata('Doctrine\Tests\Models\CMS\CmsAddress', $namingStrategy);
|
|
$manyToManyMetadata = new ClassMetadata('Doctrine\Tests\Models\CMS\CmsAddress', $namingStrategy);
|
|
|
|
$oneToOneMetadata->mapOneToOne(array(
|
|
'fieldName' => 'user',
|
|
'targetEntity' => 'CmsUser'
|
|
));
|
|
|
|
$manyToManyMetadata->mapManyToMany(array(
|
|
'fieldName' => 'user',
|
|
'targetEntity' => 'CmsUser'
|
|
));
|
|
|
|
$this->assertEquals(array('USER_ID'=>'ID'), $oneToOneMetadata->associationMappings['user']['sourceToTargetKeyColumns']);
|
|
$this->assertEquals(array('USER_ID'=>'USER_ID'), $oneToOneMetadata->associationMappings['user']['joinColumnFieldNames']);
|
|
$this->assertEquals(array('ID'=>'USER_ID'), $oneToOneMetadata->associationMappings['user']['targetToSourceKeyColumns']);
|
|
|
|
$this->assertEquals('USER_ID', $oneToOneMetadata->associationMappings['user']['joinColumns'][0]['name']);
|
|
$this->assertEquals('ID', $oneToOneMetadata->associationMappings['user']['joinColumns'][0]['referencedColumnName']);
|
|
|
|
|
|
$this->assertEquals('CMS_ADDRESS_CMS_USER', $manyToManyMetadata->associationMappings['user']['joinTable']['name']);
|
|
|
|
$this->assertEquals(array('CMS_ADDRESS_ID','CMS_USER_ID'), $manyToManyMetadata->associationMappings['user']['joinTableColumns']);
|
|
$this->assertEquals(array('CMS_ADDRESS_ID'=>'ID'), $manyToManyMetadata->associationMappings['user']['relationToSourceKeyColumns']);
|
|
$this->assertEquals(array('CMS_USER_ID'=>'ID'), $manyToManyMetadata->associationMappings['user']['relationToTargetKeyColumns']);
|
|
|
|
$this->assertEquals('CMS_ADDRESS_ID', $manyToManyMetadata->associationMappings['user']['joinTable']['joinColumns'][0]['name']);
|
|
$this->assertEquals('CMS_USER_ID', $manyToManyMetadata->associationMappings['user']['joinTable']['inverseJoinColumns'][0]['name']);
|
|
|
|
$this->assertEquals('ID', $manyToManyMetadata->associationMappings['user']['joinTable']['joinColumns'][0]['referencedColumnName']);
|
|
$this->assertEquals('ID', $manyToManyMetadata->associationMappings['user']['joinTable']['inverseJoinColumns'][0]['referencedColumnName']);
|
|
|
|
|
|
$cm = new ClassMetadata('DoctrineGlobal_Article', $namingStrategy);
|
|
$cm->mapManyToMany(array('fieldName' => 'author', 'targetEntity' => 'Doctrine\Tests\Models\CMS\CmsUser'));
|
|
$this->assertEquals('DOCTRINE_GLOBAL_ARTICLE_CMS_USER', $cm->associationMappings['author']['joinTable']['name']);
|
|
}
|
|
|
|
/**
|
|
* @group DDC-886
|
|
*/
|
|
public function testSetMultipleIdentifierSetsComposite()
|
|
{
|
|
$cm = new ClassMetadata('Doctrine\Tests\Models\CMS\CmsUser');
|
|
$cm->initializeReflection(new \Doctrine\Common\Persistence\Mapping\RuntimeReflectionService);
|
|
|
|
$cm->mapField(array('fieldName' => 'name'));
|
|
$cm->mapField(array('fieldName' => 'username'));
|
|
|
|
$cm->setIdentifier(array('name', 'username'));
|
|
$this->assertTrue($cm->isIdentifierComposite);
|
|
}
|
|
|
|
/**
|
|
* @group DDC-944
|
|
*/
|
|
public function testMappingNotFound()
|
|
{
|
|
$cm = new ClassMetadata('Doctrine\Tests\Models\CMS\CmsUser');
|
|
$cm->initializeReflection(new \Doctrine\Common\Persistence\Mapping\RuntimeReflectionService);
|
|
|
|
$this->setExpectedException('Doctrine\ORM\Mapping\MappingException', "No mapping found for field 'foo' on class 'Doctrine\Tests\Models\CMS\CmsUser'.");
|
|
$cm->getFieldMapping('foo');
|
|
}
|
|
|
|
/**
|
|
* @group DDC-961
|
|
*/
|
|
public function testJoinTableMappingDefaults()
|
|
{
|
|
$cm = new ClassMetadata('DoctrineGlobal_Article');
|
|
$cm->initializeReflection(new \Doctrine\Common\Persistence\Mapping\RuntimeReflectionService);
|
|
|
|
$cm->mapManyToMany(array('fieldName' => 'author', 'targetEntity' => 'Doctrine\Tests\Models\CMS\CmsUser'));
|
|
|
|
$this->assertEquals('doctrineglobal_article_cmsuser', $cm->associationMappings['author']['joinTable']['name']);
|
|
}
|
|
|
|
/**
|
|
* @group DDC-117
|
|
*/
|
|
public function testMapIdentifierAssociation()
|
|
{
|
|
$cm = new ClassMetadata('Doctrine\Tests\Models\DDC117\DDC117ArticleDetails');
|
|
$cm->initializeReflection(new \Doctrine\Common\Persistence\Mapping\RuntimeReflectionService);
|
|
|
|
$cm->mapOneToOne(array(
|
|
'fieldName' => 'article',
|
|
'id' => true,
|
|
'targetEntity' => 'Doctrine\Tests\Models\DDC117\DDC117Article',
|
|
'joinColumns' => array(),
|
|
));
|
|
|
|
$this->assertTrue($cm->containsForeignIdentifier, "Identifier Association should set 'containsForeignIdentifier' boolean flag.");
|
|
$this->assertEquals(array("article"), $cm->identifier);
|
|
}
|
|
|
|
/**
|
|
* @group DDC-117
|
|
*/
|
|
public function testOrphanRemovalIdentifierAssociation()
|
|
{
|
|
$cm = new ClassMetadata('Doctrine\Tests\Models\DDC117\DDC117ArticleDetails');
|
|
$cm->initializeReflection(new \Doctrine\Common\Persistence\Mapping\RuntimeReflectionService);
|
|
|
|
$this->setExpectedException('Doctrine\ORM\Mapping\MappingException', 'The orphan removal option is not allowed on an association that');
|
|
$cm->mapOneToOne(array(
|
|
'fieldName' => 'article',
|
|
'id' => true,
|
|
'targetEntity' => 'Doctrine\Tests\Models\DDC117\DDC117Article',
|
|
'orphanRemoval' => true,
|
|
'joinColumns' => array(),
|
|
));
|
|
}
|
|
|
|
/**
|
|
* @group DDC-117
|
|
*/
|
|
public function testInverseIdentifierAssocation()
|
|
{
|
|
$cm = new ClassMetadata('Doctrine\Tests\Models\DDC117\DDC117ArticleDetails');
|
|
$cm->initializeReflection(new \Doctrine\Common\Persistence\Mapping\RuntimeReflectionService);
|
|
|
|
|
|
$this->setExpectedException('Doctrine\ORM\Mapping\MappingException', 'An inverse association is not allowed to be identifier in');
|
|
$cm->mapOneToOne(array(
|
|
'fieldName' => 'article',
|
|
'id' => true,
|
|
'mappedBy' => 'details', // INVERSE!
|
|
'targetEntity' => 'Doctrine\Tests\Models\DDC117\DDC117Article',
|
|
'joinColumns' => array(),
|
|
));
|
|
}
|
|
|
|
/**
|
|
* @group DDC-117
|
|
*/
|
|
public function testIdentifierAssocationManyToMany()
|
|
{
|
|
$cm = new ClassMetadata('Doctrine\Tests\Models\DDC117\DDC117ArticleDetails');
|
|
$cm->initializeReflection(new \Doctrine\Common\Persistence\Mapping\RuntimeReflectionService);
|
|
|
|
|
|
$this->setExpectedException('Doctrine\ORM\Mapping\MappingException', 'Many-to-many or one-to-many associations are not allowed to be identifier in');
|
|
$cm->mapManyToMany(array(
|
|
'fieldName' => 'article',
|
|
'id' => true,
|
|
'targetEntity' => 'Doctrine\Tests\Models\DDC117\DDC117Article',
|
|
'joinColumns' => array(),
|
|
));
|
|
}
|
|
|
|
/**
|
|
* @group DDC-996
|
|
*/
|
|
public function testEmptyFieldNameThrowsException()
|
|
{
|
|
$this->setExpectedException('Doctrine\ORM\Mapping\MappingException',
|
|
"The field or association mapping misses the 'fieldName' attribute in entity 'Doctrine\Tests\Models\CMS\CmsUser'.");
|
|
$cm = new ClassMetadata('Doctrine\Tests\Models\CMS\CmsUser');
|
|
$cm->initializeReflection(new \Doctrine\Common\Persistence\Mapping\RuntimeReflectionService);
|
|
|
|
$cm->mapField(array('fieldName' => ''));
|
|
}
|
|
|
|
public function testRetrievalOfNamedQueries()
|
|
{
|
|
$cm = new ClassMetadata('Doctrine\Tests\Models\CMS\CmsUser');
|
|
$cm->initializeReflection(new \Doctrine\Common\Persistence\Mapping\RuntimeReflectionService);
|
|
|
|
|
|
$this->assertEquals(0, count($cm->getNamedQueries()));
|
|
|
|
$cm->addNamedQuery(array(
|
|
'name' => 'userById',
|
|
'query' => 'SELECT u FROM __CLASS__ u WHERE u.id = ?1'
|
|
));
|
|
|
|
$this->assertEquals(1, count($cm->getNamedQueries()));
|
|
}
|
|
|
|
/**
|
|
* @group DDC-1663
|
|
*/
|
|
public function testRetrievalOfResultSetMappings()
|
|
{
|
|
$cm = new ClassMetadata('Doctrine\Tests\Models\CMS\CmsUser');
|
|
$cm->initializeReflection(new \Doctrine\Common\Persistence\Mapping\RuntimeReflectionService);
|
|
|
|
|
|
$this->assertEquals(0, count($cm->getSqlResultSetMappings()));
|
|
|
|
$cm->addSqlResultSetMapping(array(
|
|
'name' => 'find-all',
|
|
'entities' => array(
|
|
array(
|
|
'entityClass' => 'Doctrine\Tests\Models\CMS\CmsUser',
|
|
),
|
|
),
|
|
));
|
|
|
|
$this->assertEquals(1, count($cm->getSqlResultSetMappings()));
|
|
}
|
|
|
|
public function testExistanceOfNamedQuery()
|
|
{
|
|
$cm = new ClassMetadata('Doctrine\Tests\Models\CMS\CmsUser');
|
|
$cm->initializeReflection(new \Doctrine\Common\Persistence\Mapping\RuntimeReflectionService);
|
|
|
|
|
|
$cm->addNamedQuery(array(
|
|
'name' => 'all',
|
|
'query' => 'SELECT u FROM __CLASS__ u'
|
|
));
|
|
|
|
$this->assertTrue($cm->hasNamedQuery('all'));
|
|
$this->assertFalse($cm->hasNamedQuery('userById'));
|
|
}
|
|
|
|
/**
|
|
* @group DDC-1663
|
|
*/
|
|
public function testRetrieveOfNamedNativeQuery()
|
|
{
|
|
$cm = new ClassMetadata('Doctrine\Tests\Models\CMS\CmsUser');
|
|
$cm->initializeReflection(new \Doctrine\Common\Persistence\Mapping\RuntimeReflectionService);
|
|
|
|
$cm->addNamedNativeQuery(array(
|
|
'name' => 'find-all',
|
|
'query' => 'SELECT * FROM cms_users',
|
|
'resultSetMapping' => 'result-mapping-name',
|
|
'resultClass' => 'Doctrine\Tests\Models\CMS\CmsUser',
|
|
));
|
|
|
|
$cm->addNamedNativeQuery(array(
|
|
'name' => 'find-by-id',
|
|
'query' => 'SELECT * FROM cms_users WHERE id = ?',
|
|
'resultClass' => '__CLASS__',
|
|
'resultSetMapping' => 'result-mapping-name',
|
|
));
|
|
|
|
$mapping = $cm->getNamedNativeQuery('find-all');
|
|
$this->assertEquals('SELECT * FROM cms_users', $mapping['query']);
|
|
$this->assertEquals('result-mapping-name', $mapping['resultSetMapping']);
|
|
$this->assertEquals('Doctrine\Tests\Models\CMS\CmsUser', $mapping['resultClass']);
|
|
|
|
$mapping = $cm->getNamedNativeQuery('find-by-id');
|
|
$this->assertEquals('SELECT * FROM cms_users WHERE id = ?', $mapping['query']);
|
|
$this->assertEquals('result-mapping-name', $mapping['resultSetMapping']);
|
|
$this->assertEquals('Doctrine\Tests\Models\CMS\CmsUser', $mapping['resultClass']);
|
|
}
|
|
|
|
/**
|
|
* @group DDC-1663
|
|
*/
|
|
public function testRetrieveOfSqlResultSetMapping()
|
|
{
|
|
$cm = new ClassMetadata('Doctrine\Tests\Models\CMS\CmsUser');
|
|
$cm->initializeReflection(new \Doctrine\Common\Persistence\Mapping\RuntimeReflectionService);
|
|
|
|
$cm->addSqlResultSetMapping(array(
|
|
'name' => 'find-all',
|
|
'entities' => array(
|
|
array(
|
|
'entityClass' => '__CLASS__',
|
|
'fields' => array(
|
|
array(
|
|
'name' => 'id',
|
|
'column'=> 'id'
|
|
),
|
|
array(
|
|
'name' => 'name',
|
|
'column'=> 'name'
|
|
)
|
|
)
|
|
),
|
|
array(
|
|
'entityClass' => 'Doctrine\Tests\Models\CMS\CmsEmail',
|
|
'fields' => array(
|
|
array(
|
|
'name' => 'id',
|
|
'column'=> 'id'
|
|
),
|
|
array(
|
|
'name' => 'email',
|
|
'column'=> 'email'
|
|
)
|
|
)
|
|
)
|
|
),
|
|
'columns' => array(
|
|
array(
|
|
'name' => 'scalarColumn'
|
|
)
|
|
)
|
|
));
|
|
|
|
$mapping = $cm->getSqlResultSetMapping('find-all');
|
|
|
|
$this->assertEquals('Doctrine\Tests\Models\CMS\CmsUser', $mapping['entities'][0]['entityClass']);
|
|
$this->assertEquals(array('name'=>'id','column'=>'id'), $mapping['entities'][0]['fields'][0]);
|
|
$this->assertEquals(array('name'=>'name','column'=>'name'), $mapping['entities'][0]['fields'][1]);
|
|
|
|
$this->assertEquals('Doctrine\Tests\Models\CMS\CmsEmail', $mapping['entities'][1]['entityClass']);
|
|
$this->assertEquals(array('name'=>'id','column'=>'id'), $mapping['entities'][1]['fields'][0]);
|
|
$this->assertEquals(array('name'=>'email','column'=>'email'), $mapping['entities'][1]['fields'][1]);
|
|
|
|
$this->assertEquals('scalarColumn', $mapping['columns'][0]['name']);
|
|
}
|
|
|
|
/**
|
|
* @group DDC-1663
|
|
*/
|
|
public function testExistanceOfSqlResultSetMapping()
|
|
{
|
|
$cm = new ClassMetadata('Doctrine\Tests\Models\CMS\CmsUser');
|
|
$cm->initializeReflection(new \Doctrine\Common\Persistence\Mapping\RuntimeReflectionService);
|
|
|
|
$cm->addSqlResultSetMapping(array(
|
|
'name' => 'find-all',
|
|
'entities' => array(
|
|
array(
|
|
'entityClass' => 'Doctrine\Tests\Models\CMS\CmsUser',
|
|
),
|
|
),
|
|
));
|
|
|
|
$this->assertTrue($cm->hasSqlResultSetMapping('find-all'));
|
|
$this->assertFalse($cm->hasSqlResultSetMapping('find-by-id'));
|
|
}
|
|
|
|
/**
|
|
* @group DDC-1663
|
|
*/
|
|
public function testExistanceOfNamedNativeQuery()
|
|
{
|
|
$cm = new ClassMetadata('Doctrine\Tests\Models\CMS\CmsUser');
|
|
$cm->initializeReflection(new \Doctrine\Common\Persistence\Mapping\RuntimeReflectionService);
|
|
|
|
|
|
$cm->addNamedNativeQuery(array(
|
|
'name' => 'find-all',
|
|
'query' => 'SELECT * FROM cms_users',
|
|
'resultClass' => 'Doctrine\Tests\Models\CMS\CmsUser',
|
|
'resultSetMapping' => 'result-mapping-name'
|
|
));
|
|
|
|
$this->assertTrue($cm->hasNamedNativeQuery('find-all'));
|
|
$this->assertFalse($cm->hasNamedNativeQuery('find-by-id'));
|
|
}
|
|
|
|
public function testRetrieveOfNamedQuery()
|
|
{
|
|
$cm = new ClassMetadata('Doctrine\Tests\Models\CMS\CmsUser');
|
|
$cm->initializeReflection(new \Doctrine\Common\Persistence\Mapping\RuntimeReflectionService);
|
|
|
|
|
|
$cm->addNamedQuery(array(
|
|
'name' => 'userById',
|
|
'query' => 'SELECT u FROM __CLASS__ u WHERE u.id = ?1'
|
|
));
|
|
|
|
$this->assertEquals('SELECT u FROM Doctrine\Tests\Models\CMS\CmsUser u WHERE u.id = ?1', $cm->getNamedQuery('userById'));
|
|
}
|
|
|
|
/**
|
|
* @group DDC-1663
|
|
*/
|
|
public function testRetrievalOfNamedNativeQueries()
|
|
{
|
|
$cm = new ClassMetadata('Doctrine\Tests\Models\CMS\CmsUser');
|
|
$cm->initializeReflection(new \Doctrine\Common\Persistence\Mapping\RuntimeReflectionService);
|
|
|
|
$this->assertEquals(0, count($cm->getNamedNativeQueries()));
|
|
|
|
$cm->addNamedNativeQuery(array(
|
|
'name' => 'find-all',
|
|
'query' => 'SELECT * FROM cms_users',
|
|
'resultClass' => 'Doctrine\Tests\Models\CMS\CmsUser',
|
|
'resultSetMapping' => 'result-mapping-name'
|
|
));
|
|
|
|
$this->assertEquals(1, count($cm->getNamedNativeQueries()));
|
|
}
|
|
|
|
/**
|
|
* @expectedException \Doctrine\ORM\Mapping\MappingException
|
|
* @expectedExceptionMessage Query named "userById" in "Doctrine\Tests\Models\CMS\CmsUser" was already declared, but it must be declared only once
|
|
*/
|
|
public function testNamingCollisionNamedQueryShouldThrowException()
|
|
{
|
|
$cm = new ClassMetadata('Doctrine\Tests\Models\CMS\CmsUser');
|
|
$cm->initializeReflection(new \Doctrine\Common\Persistence\Mapping\RuntimeReflectionService);
|
|
|
|
$cm->addNamedQuery(array(
|
|
'name' => 'userById',
|
|
'query' => 'SELECT u FROM __CLASS__ u WHERE u.id = ?1'
|
|
));
|
|
|
|
$cm->addNamedQuery(array(
|
|
'name' => 'userById',
|
|
'query' => 'SELECT u FROM __CLASS__ u WHERE u.id = ?1'
|
|
));
|
|
}
|
|
|
|
/**
|
|
* @group DDC-1663
|
|
*
|
|
* @expectedException \Doctrine\ORM\Mapping\MappingException
|
|
* @expectedExceptionMessage Query named "find-all" in "Doctrine\Tests\Models\CMS\CmsUser" was already declared, but it must be declared only once
|
|
*/
|
|
public function testNamingCollisionNamedNativeQueryShouldThrowException()
|
|
{
|
|
$cm = new ClassMetadata('Doctrine\Tests\Models\CMS\CmsUser');
|
|
$cm->initializeReflection(new \Doctrine\Common\Persistence\Mapping\RuntimeReflectionService);
|
|
|
|
$cm->addNamedNativeQuery(array(
|
|
'name' => 'find-all',
|
|
'query' => 'SELECT * FROM cms_users',
|
|
'resultClass' => 'Doctrine\Tests\Models\CMS\CmsUser',
|
|
'resultSetMapping' => 'result-mapping-name'
|
|
));
|
|
|
|
$cm->addNamedNativeQuery(array(
|
|
'name' => 'find-all',
|
|
'query' => 'SELECT * FROM cms_users',
|
|
'resultClass' => 'Doctrine\Tests\Models\CMS\CmsUser',
|
|
'resultSetMapping' => 'result-mapping-name'
|
|
));
|
|
}
|
|
|
|
/**
|
|
* @group DDC-1663
|
|
*
|
|
* @expectedException \Doctrine\ORM\Mapping\MappingException
|
|
* @expectedExceptionMessage Result set mapping named "find-all" in "Doctrine\Tests\Models\CMS\CmsUser" was already declared, but it must be declared only once
|
|
*/
|
|
public function testNamingCollisionSqlResultSetMappingShouldThrowException()
|
|
{
|
|
$cm = new ClassMetadata('Doctrine\Tests\Models\CMS\CmsUser');
|
|
$cm->initializeReflection(new \Doctrine\Common\Persistence\Mapping\RuntimeReflectionService);
|
|
|
|
$cm->addSqlResultSetMapping(array(
|
|
'name' => 'find-all',
|
|
'entities' => array(
|
|
array(
|
|
'entityClass' => 'Doctrine\Tests\Models\CMS\CmsUser',
|
|
),
|
|
),
|
|
));
|
|
|
|
$cm->addSqlResultSetMapping(array(
|
|
'name' => 'find-all',
|
|
'entities' => array(
|
|
array(
|
|
'entityClass' => 'Doctrine\Tests\Models\CMS\CmsUser',
|
|
),
|
|
),
|
|
));
|
|
}
|
|
|
|
/**
|
|
* @group DDC-1068
|
|
*/
|
|
public function testClassCaseSensitivity()
|
|
{
|
|
$user = new \Doctrine\Tests\Models\CMS\CmsUser();
|
|
$cm = new ClassMetadata('DOCTRINE\TESTS\MODELS\CMS\CMSUSER');
|
|
$cm->initializeReflection(new \Doctrine\Common\Persistence\Mapping\RuntimeReflectionService);
|
|
|
|
$this->assertEquals('Doctrine\Tests\Models\CMS\CmsUser', $cm->name);
|
|
}
|
|
|
|
/**
|
|
* @group DDC-659
|
|
*/
|
|
public function testLifecycleCallbackNotFound()
|
|
{
|
|
$cm = new ClassMetadata('Doctrine\Tests\Models\CMS\CmsUser');
|
|
$cm->initializeReflection(new \Doctrine\Common\Persistence\Mapping\RuntimeReflectionService);
|
|
$cm->addLifecycleCallback('notfound', 'postLoad');
|
|
|
|
$this->setExpectedException("Doctrine\ORM\Mapping\MappingException", "Entity 'Doctrine\Tests\Models\CMS\CmsUser' has no method 'notfound' to be registered as lifecycle callback.");
|
|
$cm->validateLifecycleCallbacks(new \Doctrine\Common\Persistence\Mapping\RuntimeReflectionService);
|
|
}
|
|
|
|
/**
|
|
* @group ImproveErrorMessages
|
|
*/
|
|
public function testTargetEntityNotFound()
|
|
{
|
|
$cm = new ClassMetadata('Doctrine\Tests\Models\CMS\CmsUser');
|
|
$cm->initializeReflection(new \Doctrine\Common\Persistence\Mapping\RuntimeReflectionService);
|
|
$cm->mapManyToOne(array('fieldName' => 'address', 'targetEntity' => 'UnknownClass'));
|
|
|
|
$this->setExpectedException("Doctrine\ORM\Mapping\MappingException", "The target-entity Doctrine\Tests\Models\CMS\UnknownClass cannot be found in 'Doctrine\Tests\Models\CMS\CmsUser#address'.");
|
|
$cm->validateAssocations();
|
|
}
|
|
|
|
/**
|
|
* @group DDC-1663
|
|
*
|
|
* @expectedException \Doctrine\ORM\Mapping\MappingException
|
|
* @expectedExceptionMessage Query name on entity class 'Doctrine\Tests\Models\CMS\CmsUser' is not defined.
|
|
*/
|
|
public function testNameIsMandatoryForNamedQueryMappingException()
|
|
{
|
|
$cm = new ClassMetadata('Doctrine\Tests\Models\CMS\CmsUser');
|
|
$cm->initializeReflection(new \Doctrine\Common\Persistence\Mapping\RuntimeReflectionService);
|
|
$cm->addNamedQuery(array(
|
|
'query' => 'SELECT u FROM Doctrine\Tests\Models\CMS\CmsUser u',
|
|
));
|
|
}
|
|
|
|
/**
|
|
* @group DDC-1663
|
|
*
|
|
* @expectedException \Doctrine\ORM\Mapping\MappingException
|
|
* @expectedExceptionMessage Query name on entity class 'Doctrine\Tests\Models\CMS\CmsUser' is not defined.
|
|
*/
|
|
public function testNameIsMandatoryForNameNativeQueryMappingException()
|
|
{
|
|
$cm = new ClassMetadata('Doctrine\Tests\Models\CMS\CmsUser');
|
|
$cm->initializeReflection(new \Doctrine\Common\Persistence\Mapping\RuntimeReflectionService);
|
|
$cm->addNamedQuery(array(
|
|
'query' => 'SELECT * FROM cms_users',
|
|
'resultClass' => 'Doctrine\Tests\Models\CMS\CmsUser',
|
|
'resultSetMapping' => 'result-mapping-name'
|
|
));
|
|
}
|
|
|
|
/**
|
|
* @group DDC-1663
|
|
*
|
|
* @expectedException \Doctrine\ORM\Mapping\MappingException
|
|
* @expectedExceptionMessage Result set mapping named "find-all" in "Doctrine\Tests\Models\CMS\CmsUser requires a entity class name.
|
|
*/
|
|
public function testNameIsMandatoryForEntityNameSqlResultSetMappingException()
|
|
{
|
|
$cm = new ClassMetadata('Doctrine\Tests\Models\CMS\CmsUser');
|
|
$cm->initializeReflection(new \Doctrine\Common\Persistence\Mapping\RuntimeReflectionService);
|
|
$cm->addSqlResultSetMapping(array(
|
|
'name' => 'find-all',
|
|
'entities' => array(
|
|
array(
|
|
'fields' => array()
|
|
)
|
|
),
|
|
));
|
|
}
|
|
|
|
/**
|
|
* @expectedException \Doctrine\ORM\Mapping\MappingException
|
|
* @expectedExceptionMessage Discriminator column name on entity class 'Doctrine\Tests\Models\CMS\CmsUser' is not defined.
|
|
*/
|
|
public function testNameIsMandatoryForDiscriminatorColumnsMappingException()
|
|
{
|
|
$cm = new ClassMetadata('Doctrine\Tests\Models\CMS\CmsUser');
|
|
$cm->initializeReflection(new \Doctrine\Common\Persistence\Mapping\RuntimeReflectionService);
|
|
$cm->setDiscriminatorColumn(array());
|
|
}
|
|
|
|
/**
|
|
* @group DDC-984
|
|
* @group DDC-559
|
|
* @group DDC-1575
|
|
*/
|
|
public function testFullyQualifiedClassNameShouldBeGivenToNamingStrategy()
|
|
{
|
|
$namingStrategy = new MyNamespacedNamingStrategy();
|
|
$addressMetadata = new ClassMetadata('Doctrine\Tests\Models\CMS\CmsAddress', $namingStrategy);
|
|
$articleMetadata = new ClassMetadata('DoctrineGlobal_Article', $namingStrategy);
|
|
$routingMetadata = new ClassMetadata('Doctrine\Tests\Models\Routing\RoutingLeg',$namingStrategy);
|
|
|
|
$addressMetadata->initializeReflection(new \Doctrine\Common\Persistence\Mapping\RuntimeReflectionService);
|
|
$articleMetadata->initializeReflection(new \Doctrine\Common\Persistence\Mapping\RuntimeReflectionService);
|
|
$routingMetadata->initializeReflection(new \Doctrine\Common\Persistence\Mapping\RuntimeReflectionService);
|
|
|
|
$addressMetadata->mapManyToMany(array(
|
|
'fieldName' => 'user',
|
|
'targetEntity' => 'CmsUser'
|
|
));
|
|
|
|
$articleMetadata->mapManyToMany(array(
|
|
'fieldName' => 'author',
|
|
'targetEntity' => 'Doctrine\Tests\Models\CMS\CmsUser'
|
|
));
|
|
|
|
$this->assertEquals('routing_routingleg', $routingMetadata->table['name']);
|
|
$this->assertEquals('cms_cmsaddress_cms_cmsuser', $addressMetadata->associationMappings['user']['joinTable']['name']);
|
|
$this->assertEquals('doctrineglobal_article_cms_cmsuser', $articleMetadata->associationMappings['author']['joinTable']['name']);
|
|
}
|
|
|
|
/**
|
|
* @group DDC-1746
|
|
*/
|
|
public function testInvalidCascade()
|
|
{
|
|
$cm = new ClassMetadata('Doctrine\Tests\Models\CMS\CmsUser');
|
|
$cm->initializeReflection(new \Doctrine\Common\Persistence\Mapping\RuntimeReflectionService);
|
|
|
|
$this->setExpectedException("Doctrine\ORM\Mapping\MappingException", "Invalid cascade option(s) specified: 'invalid'. Only 'remove', 'persist', 'refresh', 'merge' and 'detach' are allowed.");
|
|
$cm->mapManyToOne(array('fieldName' => 'address', 'targetEntity' => 'UnknownClass', 'cascade' => array('invalid')));
|
|
}
|
|
}
|
|
|
|
class MyNamespacedNamingStrategy extends \Doctrine\ORM\Mapping\DefaultNamingStrategy
|
|
{
|
|
/**
|
|
* {@inheritdoc}
|
|
*/
|
|
public function classToTableName($className)
|
|
{
|
|
if (strpos($className, '\\') !== false) {
|
|
$className = str_replace('\\', '_', str_replace('Doctrine\Tests\Models\\', '', $className));
|
|
}
|
|
|
|
return strtolower($className);
|
|
}
|
|
}
|