public function testGetMetadataForSingleClass() { $mockDriver = new MetadataDriverMock(); $entityManager = $this->_createEntityManager($mockDriver); $conn = $entityManager->getConnection(); $mockPlatform = $conn->getDatabasePlatform(); $mockPlatform->setPrefersSequences(true); $mockPlatform->setPrefersIdentityColumns(false); $cm1 = $this->_createValidClassMetadata(); // SUT $cmf = new \Doctrine\ORM\Mapping\ClassMetadataFactory(); $cmf->setEntityManager($entityManager); $cmf->setMetadataFor($cm1->name, $cm1); // Prechecks $this->assertEquals(array(), $cm1->parentClasses); $this->assertEquals(ClassMetadata::INHERITANCE_TYPE_NONE, $cm1->inheritanceType); $this->assertTrue($cm1->hasField('name')); $this->assertEquals(2, count($cm1->associationMappings)); $this->assertEquals(ClassMetadata::GENERATOR_TYPE_AUTO, $cm1->generatorType); $this->assertEquals('group', $cm1->table['name']); // Go $cmMap1 = $cmf->getMetadataFor($cm1->name); $this->assertSame($cm1, $cmMap1); $this->assertEquals('group', $cmMap1->table['name']); $this->assertTrue($cmMap1->table['quoted']); $this->assertEquals(array(), $cmMap1->parentClasses); $this->assertTrue($cmMap1->hasField('name')); }
/** * @group DDC-3293 * @group DDC-3477 * @group 1238 */ public function testEmbeddedMappingsWithFalseUseColumnPrefix() { $factory = new ClassMetadataFactory(); $em = $this->_getTestEntityManager(); $em->getConfiguration()->setMetadataDriverImpl($this->_loadDriver()); $factory->setEntityManager($em); $this->assertFalse($factory->getMetadataFor('Doctrine\\Tests\\Models\\DDC3293\\DDC3293User')->embeddedClasses['address']['columnPrefix']); }
public function setUp() { $this->metadataFactory = $this->getMock(ClassMetadataFactory::class); $this->metadataFactory->method('hasMetadataFor')->will($this->returnValueMap([[DummyEntity::class, true], [DummyEmbeddable::class, true]])); $this->metadataFactory->method('getMetadataFor')->will($this->returnValueMap([[DummyEntity::class, DummyEntity::getMetadata()], [DummyEmbeddable::class, DummyEmbeddable::getMetadata()]])); $em = $this->getMock(EntityManagerInterface::class); $em->method('getMetadataFactory')->willReturn($this->metadataFactory); $this->entity = new DummyEntity(); $this->entity->setId(1); $this->entity->setA('1a'); $this->entity->setB('1b'); $this->entity->setC('1c'); $d = new DummyEmbeddable(); $d->setX(1); $d->setY(2); $d->setZ(3); $this->entity->setD($d); $child = new DummyEntity(); $child->setId(2); $child->setA('2a'); $child->setB('2b'); $child->setC('2c'); $d = new DummyEmbeddable(); $d->setX(21); $d->setY(22); $d->setZ(23); $child->setD($d); $this->entity->addChild($child); $child = new DummyEntity(); $child->setId(3); $child->setA('3a'); $child->setB('3b'); $child->setC('3c'); $d = new DummyEmbeddable(); $d->setX(31); $d->setY(32); $d->setZ(33); $child->setD($d); $this->entity->addChild($child); $subchild = new DummyEntity(); $subchild->setId(4); $subchild->setA('4a'); $subchild->setB('4b'); $subchild->setC('4c'); $d = new DummyEmbeddable(); $d->setX(41); $d->setY(42); $d->setZ(43); $subchild->setD($d); $child->addChild($subchild); $this->normalizer = new DoctrineNormalizer(null, null, null, $em); $propertyNormalizer = new PropertyNormalizer(); $serializer = new Serializer([$this->normalizer, $propertyNormalizer]); $this->normalizer->setSerializer($serializer); }
/** * @group DDC-2109 */ public function testAssertTableColumnsAreNotAddedInManyToMany() { $evm = $this->em->getEventManager(); $this->listener->addResolveTargetEntity('Doctrine\\Tests\\ORM\\Tools\\ResolveTargetInterface', 'Doctrine\\Tests\\ORM\\Tools\\ResolveTargetEntity', array()); $this->listener->addResolveTargetEntity('Doctrine\\Tests\\ORM\\Tools\\TargetInterface', 'Doctrine\\Tests\\ORM\\Tools\\TargetEntity', array()); $evm->addEventListener(Events::loadClassMetadata, $this->listener); $cm = $this->factory->getMetadataFor('Doctrine\\Tests\\ORM\\Tools\\ResolveTargetEntity'); $meta = $cm->associationMappings['manyToMany']; $this->assertSame('Doctrine\\Tests\\ORM\\Tools\\TargetEntity', $meta['targetEntity']); $this->assertEquals(array('resolvetargetentity_id', 'targetinterface_id'), $meta['joinTableColumns']); }
/** * @group DDC-1544 */ public function testResolveTargetEntityListenerCanResolveTargetEntity() { $evm = $this->em->getEventManager(); $this->listener->addResolveTargetEntity('Doctrine\\Tests\\ORM\\Tools\\ResolveTargetInterface', 'Doctrine\\Tests\\ORM\\Tools\\ResolveTargetEntity', array()); $this->listener->addResolveTargetEntity('Doctrine\\Tests\\ORM\\Tools\\TargetInterface', 'Doctrine\\Tests\\ORM\\Tools\\TargetEntity', array()); $evm->addEventListener(Events::loadClassMetadata, $this->listener); $cm = $this->factory->getMetadataFor('Doctrine\\Tests\\ORM\\Tools\\ResolveTargetEntity'); $meta = $cm->associationMappings; $this->assertSame('Doctrine\\Tests\\ORM\\Tools\\TargetEntity', $meta['manyToMany']['targetEntity']); $this->assertSame('Doctrine\\Tests\\ORM\\Tools\\ResolveTargetEntity', $meta['manyToOne']['targetEntity']); $this->assertSame('Doctrine\\Tests\\ORM\\Tools\\ResolveTargetEntity', $meta['oneToMany']['targetEntity']); $this->assertSame('Doctrine\\Tests\\ORM\\Tools\\TargetEntity', $meta['oneToOne']['targetEntity']); }
/** * Clears the EntityManager. All entities that are currently managed * by this EntityManager become detached. * * @param string|null $entityName if given, only entities of this type will get detached * * @return void * * @throws ORMInvalidArgumentException if a non-null non-string value is given * @throws \Doctrine\Common\Persistence\Mapping\MappingException if a $entityName is given, but that entity is not * found in the mappings */ public function clear($entityName = null) { if (null !== $entityName && !is_string($entityName)) { throw ORMInvalidArgumentException::invalidEntityName($entityName); } $this->unitOfWork->clear(null === $entityName ? null : $this->metadataFactory->getMetadataFor($entityName)->getName()); }
/** * {@inheritdoc} */ public function storeCollectionCache(CollectionCacheKey $key, $elements) { /* @var $targetPersister CachedEntityPersister */ $associationMapping = $this->sourceEntity->associationMappings[$key->association]; $targetPersister = $this->uow->getEntityPersister($this->targetEntity->rootEntityName); $targetRegion = $targetPersister->getCacheRegion(); $targetHydrator = $targetPersister->getEntityHydrator(); // Only preserve ordering if association configured it if (!(isset($associationMapping['indexBy']) && $associationMapping['indexBy'])) { // Elements may be an array or a Collection $elements = array_values(is_array($elements) ? $elements : $elements->getValues()); } $entry = $this->hydrator->buildCacheEntry($this->targetEntity, $key, $elements); foreach ($entry->identifiers as $index => $entityKey) { if ($targetRegion->contains($entityKey)) { continue; } $class = $this->targetEntity; $className = ClassUtils::getClass($elements[$index]); if ($className !== $this->targetEntity->name) { $class = $this->metadataFactory->getMetadataFor($className); } $entity = $elements[$index]; $entityEntry = $targetHydrator->buildCacheEntry($class, $entityKey, $entity); $targetRegion->put($entityKey, $entityEntry); } $cached = $this->region->put($key, $entry); if ($this->cacheLogger && $cached) { $this->cacheLogger->collectionCachePut($this->regionName, $key); } }
/** * @param string $class * @param array $array * * @return array */ protected function getIdentifierFromArray($class, $array) { $meta = $this->entityMetadataFactory->getMetadataFor($class); $fields = $meta->getIdentifierFieldNames(); $ids = array(); foreach ($fields as $field) { if (isset($array[$field])) { $ids[$field] = $array[$field]; } else { $tmp = $array; $parts = explode('.', $field); foreach ($parts as $part) { if (isset($tmp[$part])) { if (is_array($tmp[$part])) { $tmp = $tmp[$part]; } else { $ids[$field] = $tmp[$part]; break; } } } } } return $ids; }
/** * {@inheritdoc} */ public function storeCollectionCache(CollectionCacheKey $key, $elements) { /* @var $targetPersister CachedEntityPersister */ $targetPersister = $this->uow->getEntityPersister($this->targetEntity->rootEntityName); $targetRegion = $targetPersister->getCacheRegion(); $targetHydrator = $targetPersister->getEntityHydrator(); $entry = $this->hydrator->buildCacheEntry($this->targetEntity, $key, $elements); foreach ($entry->identifiers as $index => $entityKey) { if ($targetRegion->contains($entityKey)) { continue; } $class = $this->targetEntity; $className = ClassUtils::getClass($elements[$index]); if ($className !== $this->targetEntity->name) { $class = $this->metadataFactory->getMetadataFor($className); } $entity = $elements[$index]; $entityEntry = $targetHydrator->buildCacheEntry($class, $entityKey, $entity); $targetRegion->put($entityKey, $entityEntry); } $cached = $this->region->put($key, $entry); if ($this->cacheLogger && $cached) { $this->cacheLogger->collectionCachePut($this->regionName, $key); } }
/** * {@inheritdoc} */ public function setMetadataFor($className, $class) { $cacheDriver = $this->getCacheDriver(); if (null !== $cacheDriver) { $cacheDriver->save($className . $this->cacheSalt, $class, null); } parent::setMetadataFor($className, $class); }
/** * Ensure indexes are inherited from the mapped superclass. * * @group DDC-3418 */ public function testMappedSuperclassIndex() { $class = $this->cmf->getMetadataFor(__NAMESPACE__ . '\\EntityIndexSubClass'); /* @var $class ClassMetadataInfo */ $this->assertArrayHasKey('mapped1', $class->fieldMappings); $this->assertArrayHasKey('IDX_NAME_INDEX', $class->table['uniqueConstraints']); $this->assertArrayHasKey('IDX_MAPPED1_INDEX', $class->table['uniqueConstraints']); $this->assertArrayHasKey('IDX_MAPPED2_INDEX', $class->table['indexes']); }
/** * @param mixed $classes * @return void */ public function setUp() { $this->doctrine = Zend_Registry::get('container')->getService('doctrine'); $this->em = $this->doctrine->getEntityManager(); $this->em->clear(); $tool = new SchemaTool($this->em); $tool->dropDatabase(); $classes = func_get_args(); if (!empty($classes)) { $metadataFactory = new ClassMetadataFactory(); $metadataFactory->setEntityManager($this->em); $metadataFactory->setCacheDriver(new ArrayCache()); $metadata = array(); foreach ((array) $classes as $class) { $metadata[] = $metadataFactory->getMetadataFor($class); } $tool->createSchema($metadata); } }
public function testGetMetadataForSingleClass() { $mockDriver = new MetadataDriverMock(); $entityManager = $this->_createEntityManager($mockDriver); $conn = $entityManager->getConnection(); $mockPlatform = $conn->getDatabasePlatform(); $mockPlatform->setPrefersSequences(true); $mockPlatform->setPrefersIdentityColumns(false); // Self-made metadata $cm1 = new ClassMetadata('Doctrine\\Tests\\ORM\\Mapping\\TestEntity1'); $cm1->initializeReflection(new \Doctrine\Common\Persistence\Mapping\RuntimeReflectionService()); $cm1->setPrimaryTable(array('name' => '`group`')); // Add a mapped field $cm1->mapField(array('fieldName' => 'name', 'type' => 'varchar')); // Add a mapped field $cm1->mapField(array('fieldName' => 'id', 'type' => 'integer', 'id' => true)); // and a mapped association $cm1->mapOneToOne(array('fieldName' => 'other', 'targetEntity' => 'TestEntity1', 'mappedBy' => 'this')); // and an association on the owning side $joinColumns = array(array('name' => 'other_id', 'referencedColumnName' => 'id')); $cm1->mapOneToOne(array('fieldName' => 'association', 'targetEntity' => 'TestEntity1', 'joinColumns' => $joinColumns)); // and an id generator type $cm1->setIdGeneratorType(ClassMetadata::GENERATOR_TYPE_AUTO); // SUT $cmf = new \Doctrine\ORM\Mapping\ClassMetadataFactory(); $cmf->setEntityManager($entityManager); $cmf->setMetadataFor('Doctrine\\Tests\\ORM\\Mapping\\TestEntity1', $cm1); // Prechecks $this->assertEquals(array(), $cm1->parentClasses); $this->assertEquals(ClassMetadata::INHERITANCE_TYPE_NONE, $cm1->inheritanceType); $this->assertTrue($cm1->hasField('name')); $this->assertEquals(2, count($cm1->associationMappings)); $this->assertEquals(ClassMetadata::GENERATOR_TYPE_AUTO, $cm1->generatorType); $this->assertEquals('group', $cm1->table['name']); // Go $cmMap1 = $cmf->getMetadataFor('Doctrine\\Tests\\ORM\\Mapping\\TestEntity1'); $this->assertSame($cm1, $cmMap1); $this->assertEquals('group', $cmMap1->table['name']); $this->assertTrue($cmMap1->table['quoted']); $this->assertEquals(array(), $cmMap1->parentClasses); $this->assertTrue($cmMap1->hasField('name')); }
/** * Prepare repository for specific entity * * @param string $entityName * @param array $entities * @param array $entityIds * @return EntityRepository */ protected function prepareEntityRepository($entityName, array $entities, array $entityIds) { $query = $this->getMockForAbstractClass('Doctrine\\ORM\\AbstractQuery', array($this->entityManager), '', true, true, true, array('getResult')); $query->expects($this->once())->method('getResult')->will($this->returnValue($entities)); $queryBuilder = $this->getMock('Doctrine\\ORM\\QueryBuilder', array('where', 'getQuery'), array($this->entityManager)); $queryBuilder->expects($this->once())->method('where')->with(new Func('e.id IN', $entityIds)); $queryBuilder->expects($this->once())->method('getQuery')->will($this->returnValue($query)); $repository = $this->getMock('Doctrine\\ORM\\EntityRepository', array('createQueryBuilder'), array($this->entityManager, $this->stubMetadata->getMetadataFor($entityName))); $repository->expects($this->any())->method('createQueryBuilder')->with('e')->will($this->returnValue($queryBuilder)); return $repository; }
/** * {@inheritDoc} */ public function isTransient($class) { if ($logger = $this->getProfilingLogger()) { $logger->startIsTransient(); $result = parent::isTransient($class); $logger->stopIsTransient(); return $result; } else { return parent::isTransient($class); } }
/** * Set up entity manager * * @return Doctrine\ORM\EntityManager */ protected function setUpOrm() { global $application; $doctrine = $application->getBootstrap()->getResource('container')->getService('doctrine'); $orm = $doctrine->getEntityManager(); $orm->clear(); $tool = new SchemaTool($orm); $tool->dropDatabase(); $classes = func_get_args(); if (!empty($classes)) { $metadataFactory = new ClassMetadataFactory(); $metadataFactory->setEntityManager($orm); $metadataFactory->setCacheDriver(new Cache()); $metadata = array(); foreach ((array) $classes as $class) { $metadata[] = $metadataFactory->getMetadataFor($class); } $tool->createSchema($metadata); } return $orm; }
/** * Gets a reference to the entity identified by the given type and identifier * without actually loading it. * * If partial objects are allowed, this method will return a partial object that only * has its identifier populated. Otherwise a proxy is returned that automatically * loads itself on first access. * * @return object The entity reference. */ public function getReference($entityName, $identifier) { $class = $this->_metadataFactory->getMetadataFor($entityName); // Check identity map first, if its already in there just return it. if ($entity = $this->_unitOfWork->tryGetById($identifier, $class->rootEntityName)) { return $entity; } if (!is_array($identifier)) { $identifier = array($class->identifier[0] => $identifier); } $entity = $this->_proxyFactory->getProxy($class->name, $identifier); $this->_unitOfWork->registerManaged($entity, $identifier, array()); return $entity; }
/** * Gets a partial reference to the entity identified by the given type and identifier * without actually loading it, if the entity is not yet loaded. * * The returned reference may be a partial object if the entity is not yet loaded/managed. * If it is a partial object it will not initialize the rest of the entity state on access. * Thus you can only ever safely access the identifier of an entity obtained through * this method. * * The use-cases for partial references involve maintaining bidirectional associations * without loading one side of the association or to update an entity without loading it. * Note, however, that in the latter case the original (persistent) entity data will * never be visible to the application (especially not event listeners) as it will * never be loaded in the first place. * * @param string $entityName The name of the entity type. * @param mixed $identifier The entity identifier. * @return object The (partial) entity reference. */ public function getPartialReference($entityName, $identifier) { $class = $this->metadataFactory->getMetadataFor(ltrim($entityName, '\\')); // Check identity map first, if its already in there just return it. if ($entity = $this->unitOfWork->tryGetById($identifier, $class->rootEntityName)) { return $entity instanceof $class->name ? $entity : null; } if (!is_array($identifier)) { $identifier = array($class->identifier[0] => $identifier); } $entity = $class->newInstance(); $class->setIdentifierValues($entity, $identifier); $this->unitOfWork->registerManaged($entity, $identifier, array()); return $entity; }
protected function loadMetadata($name) { $origName = $name; if ($this->config instanceof Kdyby\Doctrine\Configuration) { $name = $this->config->getTargetEntityClassName($name); } if (!class_exists($name)) { throw new Kdyby\Doctrine\MissingClassException("Metadata of class {$name} was not found, because the class is missing or cannot be autoloaded."); } $result = parent::loadMetadata($name); if ($name !== $origName) { $this->setMetadataFor($origName, $this->getMetadataFor($name)); } return $result; }
/** * {@inheritDoc} */ public function isTransient($class) { $logger = $this->getProfilingLogger(); if ($logger) { $logger->startIsTransient(); } if (array_key_exists($class, $this->isTransientCache)) { $result = $this->isTransientCache[$class]; } else { $result = parent::isTransient($class); $this->isTransientCache[$class] = $result; } if ($logger) { $logger->stopIsTransient(); } return $result; }
private function remapActions(ClassMetadata $metadata, ClassMetadataFactory $metadataFactory) { $fieldName = 'actions'; unset($metadata->fieldMappings[$fieldName]); unset($metadata->embeddedClasses[$fieldName]); // Re-map the embeddable $mapping = ['fieldName' => $fieldName, 'class' => $this->actionsClass, 'columnPrefix' => null]; $metadata->mapEmbedded($mapping); // Remove the existing inlined fields foreach ($metadata->fieldMappings as $name => $fieldMapping) { if (isset($fieldMapping['declaredField']) && $fieldMapping['declaredField'] === $fieldName) { unset($metadata->fieldMappings[$name]); unset($metadata->fieldNames[$fieldMapping['columnName']]); } } // Re-inline the embeddable $embeddableMetadata = $metadataFactory->getMetadataFor($this->actionsClass); $metadata->inlineEmbeddable($fieldName, $embeddableMetadata); }
/** * {@inheritdoc} */ public function loadById(array $identifier, $entity = null) { $cacheKey = new EntityCacheKey($this->class->rootEntityName, $identifier); $cacheEntry = $this->region->get($cacheKey); $class = $this->class; if ($cacheEntry !== null) { if ($cacheEntry->class !== $this->class->name) { $class = $this->metadataFactory->getMetadataFor($cacheEntry->class); } if (($entity = $this->hydrator->loadCacheEntry($class, $cacheKey, $cacheEntry, $entity)) !== null) { if ($this->cacheLogger) { $this->cacheLogger->entityCacheHit($this->regionName, $cacheKey); } return $entity; } } $entity = $this->persister->loadById($identifier, $entity); if ($entity === null) { return null; } $class = $this->class; $className = ClassUtils::getClass($entity); if ($className !== $this->class->name) { $class = $this->metadataFactory->getMetadataFor($className); } $cacheEntry = $this->hydrator->buildCacheEntry($class, $cacheKey, $entity); $cached = $this->region->put($cacheKey, $cacheEntry); if ($cached && ($this->joinedAssociations === null || count($this->joinedAssociations) > 0)) { $this->storeJoinedAssociations($entity); } if ($this->cacheLogger) { if ($cached) { $this->cacheLogger->entityCachePut($this->regionName, $cacheKey); } $this->cacheLogger->entityCacheMiss($this->regionName, $cacheKey); } return $entity; }
/** * @param string $attributeClass * @param ClassMetadataInfo $metadata * @param ClassMetadataFactory $metadataFactory */ private function mapAttributeOnAttributeValue($attributeClass, ClassMetadataInfo $metadata, ClassMetadataFactory $metadataFactory) { $attributeMetadata = $metadataFactory->getMetadataFor($attributeClass); $attributeMapping = ['fieldName' => 'attribute', 'targetEntity' => $attributeClass, 'inversedBy' => 'values', 'joinColumns' => [['name' => 'attribute_id', 'referencedColumnName' => $attributeMetadata->fieldMappings['id']['columnName'], 'nullable' => false, 'onDelete' => 'CASCADE']]]; $this->mapManyToOne($metadata, $attributeMapping); }
/** * Returns the metadata for a class. * * @return Doctrine\ORM\Mapping\ClassMetadata * @internal Performance-sensitive method. */ public function getClassMetadata($className) { return $this->_metadataFactory->getMetadataFor($className); }
public function setMetadataFor($className, $class) { $this->getCacheDriver()->save($className . $this->cacheSalt, $class, null); parent::setMetadataFor($className, $class); }
/** * Returns the metadata for each managed entity. * * @param ClassMetadataFactory $metadataFactory * @return \Doctrine\Common\Persistence\Mapping\ClassMetadata[] */ protected function getMetadataForSupportedEntities(ClassMetadataFactory $metadataFactory) { $metadata = array(); foreach ($this->entityClasses as $class) { $metadata[] = $metadataFactory->getMetadataFor($class); } return $metadata; }
/** * @group DDC-1845 */ public function testQuoteMetadata() { $cmf = new ClassMetadataFactory(); $driver = $this->createAnnotationDriver(array(__DIR__ . '/../../Models/Quote/')); $em = $this->_createEntityManager($driver); $cmf->setEntityManager($em); $userMetadata = $cmf->getMetadataFor('Doctrine\\Tests\\Models\\Quote\\User'); $phoneMetadata = $cmf->getMetadataFor('Doctrine\\Tests\\Models\\Quote\\Phone'); $groupMetadata = $cmf->getMetadataFor('Doctrine\\Tests\\Models\\Quote\\Group'); $addressMetadata = $cmf->getMetadataFor('Doctrine\\Tests\\Models\\Quote\\Address'); // Phone Class Metadata $this->assertTrue($phoneMetadata->fieldMappings['number']['quoted']); $this->assertEquals('phone-number', $phoneMetadata->fieldMappings['number']['columnName']); $user = $phoneMetadata->associationMappings['user']; $this->assertTrue($user['joinColumns'][0]['quoted']); $this->assertEquals('user-id', $user['joinColumns'][0]['name']); $this->assertEquals('user-id', $user['joinColumns'][0]['referencedColumnName']); // User Group Metadata $this->assertTrue($groupMetadata->fieldMappings['id']['quoted']); $this->assertTrue($groupMetadata->fieldMappings['name']['quoted']); $this->assertEquals('user-id', $userMetadata->fieldMappings['id']['columnName']); $this->assertEquals('user-name', $userMetadata->fieldMappings['name']['columnName']); $user = $groupMetadata->associationMappings['parent']; $this->assertTrue($user['joinColumns'][0]['quoted']); $this->assertEquals('parent-id', $user['joinColumns'][0]['name']); $this->assertEquals('group-id', $user['joinColumns'][0]['referencedColumnName']); // Address Class Metadata $this->assertTrue($addressMetadata->fieldMappings['id']['quoted']); $this->assertTrue($addressMetadata->fieldMappings['zip']['quoted']); $this->assertEquals('address-id', $addressMetadata->fieldMappings['id']['columnName']); $this->assertEquals('address-zip', $addressMetadata->fieldMappings['zip']['columnName']); $user = $addressMetadata->associationMappings['user']; $this->assertTrue($user['joinColumns'][0]['quoted']); $this->assertEquals('user-id', $user['joinColumns'][0]['name']); $this->assertEquals('user-id', $user['joinColumns'][0]['referencedColumnName']); // User Class Metadata $this->assertTrue($userMetadata->fieldMappings['id']['quoted']); $this->assertTrue($userMetadata->fieldMappings['name']['quoted']); $this->assertEquals('user-id', $userMetadata->fieldMappings['id']['columnName']); $this->assertEquals('user-name', $userMetadata->fieldMappings['name']['columnName']); $address = $userMetadata->associationMappings['address']; $this->assertTrue($address['joinColumns'][0]['quoted']); $this->assertEquals('address-id', $address['joinColumns'][0]['name']); $this->assertEquals('address-id', $address['joinColumns'][0]['referencedColumnName']); $groups = $userMetadata->associationMappings['groups']; $this->assertTrue($groups['joinTable']['quoted']); $this->assertTrue($groups['joinTable']['joinColumns'][0]['quoted']); $this->assertEquals('quote-users-groups', $groups['joinTable']['name']); $this->assertEquals('user-id', $groups['joinTable']['joinColumns'][0]['name']); $this->assertEquals('user-id', $groups['joinTable']['joinColumns'][0]['referencedColumnName']); $this->assertTrue($groups['joinTable']['inverseJoinColumns'][0]['quoted']); $this->assertEquals('group-id', $groups['joinTable']['inverseJoinColumns'][0]['name']); $this->assertEquals('group-id', $groups['joinTable']['inverseJoinColumns'][0]['referencedColumnName']); }
/** * @param array $association * @param array $ownerId * * @return CollectionCacheKey */ protected function buildCollectionCacheKey(array $association, $ownerId) { /** @var ClassMetadata $metadata */ $metadata = $this->metadataFactory->getMetadataFor($association['sourceEntity']); return new CollectionCacheKey($metadata->rootEntityName, $association['fieldName'], $ownerId); }
/** * @group DDC-1590 */ public function testMethodsAndPropertiesAreNotDuplicatedInChildClasses() { $cmf = new ClassMetadataFactory(); $em = $this->_getTestEntityManager(); $cmf->setEntityManager($em); $ns = $this->_namespace; $nsdir = $this->_tmpDir . '/' . $ns; $content = str_replace('namespace Doctrine\\Tests\\Models\\DDC1590', 'namespace ' . $ns, file_get_contents(__DIR__ . '/../../Models/DDC1590/DDC1590User.php')); $fname = $nsdir . "/DDC1590User.php"; file_put_contents($fname, $content); require $fname; $metadata = $cmf->getMetadataFor($ns . '\\DDC1590User'); $this->_generator->writeEntityClass($metadata, $this->_tmpDir); // class DDC1590User extends DDC1590Entity { ... } $source = file_get_contents($fname); // class _DDC1590User extends DDC1590Entity { ... } $source2 = str_replace('class DDC1590User', 'class _DDC1590User', $source); $fname2 = $nsdir . "/_DDC1590User.php"; file_put_contents($fname2, $source2); require $fname2; // class __DDC1590User { ... } $source3 = str_replace('class DDC1590User extends DDC1590Entity', 'class __DDC1590User', $source); $fname3 = $nsdir . "/__DDC1590User.php"; file_put_contents($fname3, $source3); require $fname3; // class _DDC1590User extends DDC1590Entity { ... } $rc2 = new \ReflectionClass($ns . '\\_DDC1590User'); $this->assertTrue($rc2->hasProperty('name')); $this->assertTrue($rc2->hasProperty('id')); $this->assertTrue($rc2->hasProperty('created_at')); $this->assertTrue($rc2->hasMethod('getName')); $this->assertTrue($rc2->hasMethod('setName')); $this->assertTrue($rc2->hasMethod('getId')); $this->assertFalse($rc2->hasMethod('setId')); $this->assertTrue($rc2->hasMethod('getCreatedAt')); $this->assertTrue($rc2->hasMethod('setCreatedAt')); // class __DDC1590User { ... } $rc3 = new \ReflectionClass($ns . '\\__DDC1590User'); $this->assertTrue($rc3->hasProperty('name')); $this->assertFalse($rc3->hasProperty('id')); $this->assertFalse($rc3->hasProperty('created_at')); $this->assertTrue($rc3->hasMethod('getName')); $this->assertTrue($rc3->hasMethod('setName')); $this->assertFalse($rc3->hasMethod('getId')); $this->assertFalse($rc3->hasMethod('setId')); $this->assertFalse($rc3->hasMethod('getCreatedAt')); $this->assertFalse($rc3->hasMethod('setCreatedAt')); }
public function testAddDefaultDiscriminatorMap() { $cmf = new ClassMetadataFactory(); $driver = $this->createAnnotationDriver(array(__DIR__ . '/../../Models/JoinedInheritanceType/')); $em = $this->_createEntityManager($driver); $cmf->setEntityManager($em); $rootMetadata = $cmf->getMetadataFor('Doctrine\\Tests\\Models\\JoinedInheritanceType\\RootClass'); $childMetadata = $cmf->getMetadataFor('Doctrine\\Tests\\Models\\JoinedInheritanceType\\ChildClass'); $anotherChildMetadata = $cmf->getMetadataFor('Doctrine\\Tests\\Models\\JoinedInheritanceType\\AnotherChildClass'); $rootDiscriminatorMap = $rootMetadata->discriminatorMap; $childDiscriminatorMap = $childMetadata->discriminatorMap; $anotherChildDiscriminatorMap = $anotherChildMetadata->discriminatorMap; $rootClass = 'Doctrine\\Tests\\Models\\JoinedInheritanceType\\RootClass'; $childClass = 'Doctrine\\Tests\\Models\\JoinedInheritanceType\\ChildClass'; $anotherChildClass = 'Doctrine\\Tests\\Models\\JoinedInheritanceType\\AnotherChildClass'; $rootClassKey = array_search($rootClass, $rootDiscriminatorMap); $childClassKey = array_search($childClass, $rootDiscriminatorMap); $anotherChildClassKey = array_search($anotherChildClass, $rootDiscriminatorMap); $this->assertEquals('rootclass', $rootClassKey); $this->assertEquals('childclass', $childClassKey); $this->assertEquals('anotherchildclass', $anotherChildClassKey); $this->assertEquals($childDiscriminatorMap, $rootDiscriminatorMap); $this->assertEquals($anotherChildDiscriminatorMap, $rootDiscriminatorMap); // ClassMetadataFactory::addDefaultDiscriminatorMap shouldn't be called again, because the // discriminator map is already cached $cmf = $this->getMock('Doctrine\\ORM\\Mapping\\ClassMetadataFactory', array('addDefaultDiscriminatorMap')); $cmf->setEntityManager($em); $cmf->expects($this->never())->method('addDefaultDiscriminatorMap'); $rootMetadata = $cmf->getMetadataFor('Doctrine\\Tests\\Models\\JoinedInheritanceType\\RootClass'); }