PHP ExtendHelper::buildRelationKey方法代码示例

 /**
  * @param ConfigInterface $sourceEntityConfig The 'extend' config of the source entity
  * @param string          $targetEntityName
  * @param string          $relationName
  * @param string          $targetFieldName    A field name is used to show related entity
  * @param array           $options
  * @param string          $fieldType          The field type. By default the field type is manyToOne,
  *                                            but you can specify another type if it is based on manyToOne.
  *                                            In this case this type should be registered
  *                                            in entity_extend.yml under underlying_types section
  *
  * @return string The relation key
  */
 public function addManyToOneRelation(ConfigInterface $sourceEntityConfig, $targetEntityName, $relationName, $targetFieldName, $options = [], $fieldType = 'manyToOne')
 {
     $sourceEntityName = $sourceEntityConfig->getId()->getClassName();
     $relationKey = ExtendHelper::buildRelationKey($sourceEntityName, $relationName, 'manyToOne', $targetEntityName);
     // add a relation field config
     if (!$this->configManager->hasConfigFieldModel($sourceEntityName, $relationName)) {
         $this->configManager->createConfigFieldModel($sourceEntityName, $relationName, $fieldType);
         $options['extend']['state'] = ExtendScope::STATE_NEW;
     } else {
         $configFieldModel = $this->configManager->getConfigFieldModel($sourceEntityName, $relationName);
         if ($configFieldModel->getType() !== $fieldType) {
             $this->configManager->changeFieldType($sourceEntityName, $relationName, $fieldType);
         }
     }
     $options['extend']['is_extend'] = true;
     $options['extend']['relation_key'] = $relationKey;
     $options['extend']['target_entity'] = $targetEntityName;
     $options['extend']['target_field'] = $targetFieldName;
     $this->updateFieldConfigs($sourceEntityName, $relationName, $options);
     // add relation to config
     $relations = $sourceEntityConfig->get('relation', false, []);
     if (!isset($relations[$relationKey])) {
         $relations[$relationKey] = ['assign' => false, 'field_id' => new FieldConfigId('extend', $sourceEntityName, $relationName, 'manyToOne'), 'owner' => true, 'target_entity' => $targetEntityName, 'target_field_id' => false];
         $sourceEntityConfig->set('relation', $relations);
         $extendConfigProvider = $this->configManager->getProvider('extend');
         $extendConfigProvider->persist($sourceEntityConfig);
     }
     return $relationKey;
 }

 /**
  * @param ConfigInterface $entityConfig
  * @param string          $targetEntityClassName
  * @param string          $relationName
  */
 protected function createOwnerRelation(ConfigInterface $entityConfig, $targetEntityClassName, $relationName)
 {
     $relationKey = ExtendHelper::buildRelationKey($entityConfig->getId()->getClassName(), $relationName, 'manyToOne', $this->ownershipMetadataProvider->getOrganizationClass());
     if (!isset($entityConfig->get('relation')[$relationKey])) {
         $this->relationBuilder->addManyToOneRelation($entityConfig, $targetEntityClassName, $relationName, 'id', ['entity' => ['label' => 'oro.custom_entity.' . $relationName . '.label', 'description' => 'oro.custom_entity.' . $relationName . '.description'], 'view' => ['is_displayable' => false], 'form' => ['is_enabled' => false], 'dataaudit' => ['auditable' => true]]);
     }
 }

 /**
  * {@inheritdoc}
  */
 public function buildForm(FormBuilderInterface $builder, array $options)
 {
     $builder->addEventListener(FormEvents::POST_SUBMIT, function () use($options) {
         /** @var FieldConfigId $configId */
         $configId = $options['config_id'];
         $relationKey = ExtendHelper::buildRelationKey($configId->getClassName(), $configId->getFieldName(), 'manyToOne', 'Oro\\Bundle\\AttachmentBundle\\Entity\\File');
         /** @var Config $entityExtendConfig */
         $entityExtendConfig = $this->extendConfigProvider->getConfig($configId->getClassName());
         if ($this->isApplicable($entityExtendConfig, $relationKey)) {
             if ($entityExtendConfig->is('state', ExtendScope::STATE_ACTIVE)) {
                 $entityExtendConfig->set('state', ExtendScope::STATE_UPDATE);
                 $this->extendConfigProvider->persist($entityExtendConfig);
                 $this->extendConfigProvider->flush();
             }
         }
     });
 }

 /**
  * @param string $entityClass
  * @param string $activityClassName
  *
  * @return bool
  */
 protected function isActivityAssociationEnabled($entityClass, $activityClassName)
 {
     $extendConfig = $this->extendConfigProvider->getConfig($activityClassName);
     $relations = $extendConfig->get('relation', false, []);
     $relationKey = ExtendHelper::buildRelationKey($activityClassName, ExtendHelper::buildAssociationName($entityClass, ActivityScope::ASSOCIATION_KIND), RelationType::MANY_TO_MANY, $entityClass);
     return isset($relations[$relationKey]);
 }

 /**
  * @param ConfigInterface $fieldConfig
  */
 protected function createSelfRelation(ConfigInterface $fieldConfig)
 {
     /** @var FieldConfigId $fieldConfigId */
     $fieldConfigId = $fieldConfig->getId();
     $targetEntityClass = $fieldConfig->get('target_entity');
     $selfFieldId = new FieldConfigId('extend', $fieldConfigId->getClassName(), $fieldConfigId->getFieldName(), $this->fieldTypeHelper->getUnderlyingType($fieldConfigId->getFieldType()));
     $selfConfig = $this->extendConfigProvider->getConfig($selfFieldId->getClassName());
     $relationKey = ExtendHelper::buildRelationKey($selfFieldId->getClassName(), $selfFieldId->getFieldName(), $selfFieldId->getFieldType(), $targetEntityClass);
     /**
      * in case of oneToMany relation
      * automatically create target field (type: manyToOne)
      */
     $targetFieldId = false;
     $owner = true;
     $targetOwner = false;
     if (in_array($selfFieldId->getFieldType(), RelationType::$toManyRelations)) {
         $classNameArray = explode('\\', $selfFieldId->getClassName());
         $relationFieldName = strtolower(array_pop($classNameArray)) . '_' . $selfFieldId->getFieldName();
         if ($selfFieldId->getFieldType() === RelationType::ONE_TO_MANY) {
             $owner = false;
             $targetOwner = true;
         }
         $targetFieldId = new FieldConfigId('extend', $targetEntityClass, $relationFieldName, ExtendHelper::getReverseRelationType($selfFieldId->getFieldType()));
     }
     $selfRelationConfig = ['assign' => false, 'field_id' => $selfFieldId, 'owner' => $owner, 'target_entity' => $targetEntityClass, 'target_field_id' => $targetFieldId];
     if ($fieldConfig->has('cascade')) {
         $selfRelationConfig['cascade'] = $fieldConfig->get('cascade');
     }
     $selfRelations = $selfConfig->get('relation') ?: [];
     $selfRelations[$relationKey] = $selfRelationConfig;
     $selfConfig->set('relation', $selfRelations);
     $this->extendConfigProvider->persist($selfConfig);
     $targetConfig = $this->extendConfigProvider->getConfig($targetEntityClass);
     $targetRelationConfig = ['assign' => false, 'field_id' => $targetFieldId, 'owner' => $targetOwner, 'target_entity' => $selfFieldId->getClassName(), 'target_field_id' => $selfFieldId];
     $targetRelations = $targetConfig->get('relation') ?: [];
     $targetRelations[$relationKey] = $targetRelationConfig;
     $targetConfig->set('relation', $targetRelations);
     $fieldConfig->set('relation_key', $relationKey);
     $this->extendConfigProvider->persist($targetConfig);
 }

 /**
  * @param string $entityClass
  * @param string $fieldName
  * @param string $label
  * @param string $description
  * @param string $targetEntity
  * @param string $targetField
  */
 protected function addRelationField($entityClass, $fieldName, $label, $description, $targetEntity, $targetField)
 {
     $this->configManager->createConfigFieldModel($entityClass, $fieldName, 'manyToOne');
     $entityConfigProvider = $this->configManager->getProvider('entity');
     $entityFieldConfig = $entityConfigProvider->getConfig($entityClass, $fieldName);
     $entityFieldConfig->set('label', $label);
     $entityFieldConfig->set('description', $description);
     $extendConfigProvider = $this->configManager->getProvider('extend');
     $extendFieldConfig = $extendConfigProvider->getConfig($entityClass, $fieldName);
     $extendFieldConfig->set('owner', ExtendScope::OWNER_CUSTOM);
     $extendFieldConfig->set('state', ExtendScope::STATE_NEW);
     $extendFieldConfig->set('is_extend', true);
     $extendFieldConfig->set('target_entity', $targetEntity);
     $extendFieldConfig->set('target_field', $targetField);
     $extendFieldConfig->set('relation_key', ExtendHelper::buildRelationKey($entityClass, $targetField, 'manyToOne', $targetEntity));
     $formConfigProvider = $this->configManager->getProvider('form');
     $formFieldConfig = $formConfigProvider->getConfig($entityClass, $fieldName);
     $formFieldConfig->set('is_enabled', false);
     $viewConfigProvider = $this->configManager->getProvider('view');
     $viewFieldConfig = $viewConfigProvider->getConfig($entityClass, $fieldName);
     $viewFieldConfig->set('is_displayable', false);
     $importExportConfigProvider = $this->configManager->getProvider('importexport');
     $importExportFieldConfig = $importExportConfigProvider->getConfig($entityClass, $fieldName);
     $importExportFieldConfig->set('excluded', true);
 }

 public function testGetActivityActions()
 {
     $targetEntityClass = 'Test\\Entity';
     $activity1Class = 'Test\\Activity1';
     $activity2Class = 'Test\\Activity2';
     $activity1RelationKey = ExtendHelper::buildRelationKey($activity1Class, ExtendHelper::buildAssociationName($targetEntityClass, ActivityScope::ASSOCIATION_KIND), 'manyToMany', $targetEntityClass);
     $activity2RelationKey = ExtendHelper::buildRelationKey($activity2Class, ExtendHelper::buildAssociationName($targetEntityClass, ActivityScope::ASSOCIATION_KIND), 'manyToMany', $targetEntityClass);
     $targetEntityActivityConfig = new Config(new EntityConfigId('activity', $targetEntityClass));
     $targetEntityActivityConfig->set('activities', [$activity1Class, $activity2Class]);
     $activity1ExtendConfig = new Config(new EntityConfigId('extend', $activity1Class));
     $activity1ExtendConfig->set('relation', [$activity1RelationKey => []]);
     $activity1EntityConfig = new Config(new EntityConfigId('entity', $activity1Class));
     $activity1EntityConfig->set('plural_label', 'lbl.activity1');
     $activity1ActivityConfig = new Config(new EntityConfigId('activity', $activity1Class));
     $activity1ActivityConfig->set('action_button_widget', 'button_widget1');
     $activity1ActivityConfig->set('action_link_widget', 'link_widget1');
     $activity2ExtendConfig = new Config(new EntityConfigId('extend', $activity2Class));
     $activity2ExtendConfig->set('relation', [$activity2RelationKey => []]);
     $activity2EntityConfig = new Config(new EntityConfigId('entity', $activity2Class));
     $activity2EntityConfig->set('plural_label', 'lbl.activity2');
     $activity2ActivityConfig = new Config(new EntityConfigId('activity', $activity2Class));
     $activity2ActivityConfig->set('action_button_widget', 'button_widget2');
     $activity2ActivityConfig->set('action_link_widget', 'link_widget2');
     $activity2ActivityConfig->set('priority', 100);
     $this->extendConfigProvider->expects($this->any())->method('getConfig')->will($this->returnValueMap([[$activity1Class, null, $activity1ExtendConfig], [$activity2Class, null, $activity2ExtendConfig]]));
     $this->entityConfigProvider->expects($this->any())->method('getConfig')->will($this->returnValueMap([[$activity1Class, null, $activity1EntityConfig], [$activity2Class, null, $activity2EntityConfig]]));
     $this->activityConfigProvider->expects($this->any())->method('getConfig')->will($this->returnValueMap([[$targetEntityClass, null, $targetEntityActivityConfig], [$activity1Class, null, $activity1ActivityConfig], [$activity2Class, null, $activity2ActivityConfig]]));
     $this->assertEquals([['className' => 'Test\\Activity1', 'associationName' => 'entity_1f801d4a', 'button_widget' => 'button_widget1', 'link_widget' => 'link_widget1'], ['className' => 'Test\\Activity2', 'associationName' => 'entity_1f801d4a', 'button_widget' => 'button_widget2', 'link_widget' => 'link_widget2', 'priority' => 100]], $this->manager->getActivityActions($targetEntityClass));
 }

 /**
  * @param FieldConfigId $fieldConfigId
  *
  * @return string
  */
 protected function getRelationKey(FieldConfigId $fieldConfigId)
 {
     return ExtendHelper::buildRelationKey($fieldConfigId->getClassName(), $fieldConfigId->getFieldName(), 'manyToOne', 'Oro\\Bundle\\AttachmentBundle\\Entity\\File');
 }

 /**
  * @param \PHPUnit_Framework_MockObject_MockObject $entityConfigProvider
  * @param \PHPUnit_Framework_MockObject_MockObject $extendConfigProvider
  * @param \PHPUnit_Framework_MockObject_MockObject $formConfigProvider
  * @param \PHPUnit_Framework_MockObject_MockObject $viewConfigProvider
  * @param \PHPUnit_Framework_MockObject_MockObject $importExportConfigProvider
  * @param string $entityClass
  * @param string $fieldName
  * @param string $label
  * @param string $description
  * @param string $targetEntity
  * @param string $targetField
  * @param int $iteration
  *
  * @SuppressWarnings(PHPMD.ExcessiveParameterList)
  */
 protected function addFieldAssertions(\PHPUnit_Framework_MockObject_MockObject $entityConfigProvider, \PHPUnit_Framework_MockObject_MockObject $extendConfigProvider, \PHPUnit_Framework_MockObject_MockObject $formConfigProvider, \PHPUnit_Framework_MockObject_MockObject $viewConfigProvider, \PHPUnit_Framework_MockObject_MockObject $importExportConfigProvider, $entityClass, $fieldName, $label, $description, $targetEntity, $targetField, $iteration)
 {
     $this->configManager->expects($this->at($iteration * 7 + 1))->method('hasConfig')->with($entityClass, $fieldName)->will($this->returnValue(false));
     $this->configManager->expects($this->at($iteration * 7 + 2))->method('createConfigFieldModel')->with($entityClass, $fieldName, 'manyToOne');
     $entityFieldConfig = $this->getMock('Oro\\Bundle\\EntityConfigBundle\\Config\\ConfigInterface');
     $entityFieldConfig->expects($this->at(0))->method('set')->with('label', $label);
     $entityFieldConfig->expects($this->at(1))->method('set')->with('description', $description);
     $entityConfigProvider->expects($this->at($iteration))->method('getConfig')->with($entityClass, $fieldName)->will($this->returnValue($entityFieldConfig));
     $extendFieldConfig = $this->getMock('Oro\\Bundle\\EntityConfigBundle\\Config\\ConfigInterface');
     $extendFieldConfig->expects($this->at(0))->method('set')->with('owner', ExtendScope::OWNER_CUSTOM);
     $extendFieldConfig->expects($this->at(1))->method('set')->with('state', ExtendScope::STATE_NEW);
     $extendFieldConfig->expects($this->at(2))->method('set')->with('is_extend', true);
     $extendFieldConfig->expects($this->at(3))->method('set')->with('target_entity', $targetEntity);
     $extendFieldConfig->expects($this->at(4))->method('set')->with('target_field', $targetField);
     $extendFieldConfig->expects($this->at(5))->method('set')->with('relation_key', ExtendHelper::buildRelationKey($entityClass, $targetField, 'manyToOne', $targetEntity));
     $extendConfigProvider->expects($this->at($iteration + 1))->method('getConfig')->with($entityClass, $fieldName)->will($this->returnValue($extendFieldConfig));
     $formFieldConfig = $this->getMock('Oro\\Bundle\\EntityConfigBundle\\Config\\ConfigInterface');
     $formFieldConfig->expects($this->at(0))->method('set')->with('is_enabled', false);
     $formConfigProvider->expects($this->at($iteration))->method('getConfig')->with($entityClass, $fieldName)->will($this->returnValue($formFieldConfig));
     $viewFieldConfig = $this->getMock('Oro\\Bundle\\EntityConfigBundle\\Config\\ConfigInterface');
     $viewFieldConfig->expects($this->at(0))->method('set')->with('is_displayable', false);
     $viewConfigProvider->expects($this->at($iteration))->method('getConfig')->with($entityClass, $fieldName)->will($this->returnValue($viewFieldConfig));
     $importExportFieldConfig = $this->getMock('Oro\\Bundle\\EntityConfigBundle\\Config\\ConfigInterface');
     $importExportFieldConfig->expects($this->at(0))->method('set')->with('excluded', true);
     $importExportConfigProvider->expects($this->at($iteration))->method('getConfig')->with($entityClass, $fieldName)->will($this->returnValue($importExportFieldConfig));
 }

 /**
  * Adds the inverse side of a many-to-one relation
  *
  * @param Schema       $schema
  * @param Table|string $table                     A Table object or table name
  * @param string       $associationName           The name of a relation field
  * @param Table|string $targetTable               A Table object or table name
  * @param string       $targetAssociationName     The name of a relation field on the inverse side
  * @param string[]     $targetTitleColumnNames    Column names are used to show a title of related entity
  * @param string[]     $targetDetailedColumnNames Column names are used to show detailed info about related entity
  * @param string[]     $targetGridColumnNames     Column names are used to show related entity in a grid
  * @param array        $options                   Entity config values
  *                                                format is [CONFIG_SCOPE => [CONFIG_KEY => CONFIG_VALUE]]
  */
 public function addManyToOneInverseRelation(Schema $schema, $table, $associationName, $targetTable, $targetAssociationName, array $targetTitleColumnNames, array $targetDetailedColumnNames, array $targetGridColumnNames, array $options = [])
 {
     $this->ensureExtendFieldSet($options);
     $selfTableName = $this->getTableName($table);
     $selfClassName = $this->getEntityClassByTableName($selfTableName);
     $targetTableName = $this->getTableName($targetTable);
     $targetTable = $this->getTable($targetTable, $schema);
     $targetClassName = $this->getEntityClassByTableName($targetTableName);
     $this->checkColumnsExist($targetTable, $targetTitleColumnNames);
     $this->checkColumnsExist($targetTable, $targetDetailedColumnNames);
     $this->checkColumnsExist($targetTable, $targetGridColumnNames);
     $relationKey = ExtendHelper::buildRelationKey($selfClassName, $associationName, RelationType::MANY_TO_ONE, $targetClassName);
     $targetFieldId = new FieldConfigId('extend', $targetClassName, $targetAssociationName, RelationType::ONE_TO_MANY);
     $selfTableOptions['extend']['relation.' . $relationKey . '.target_field_id'] = $targetFieldId;
     $this->extendOptionsManager->setTableOptions($selfTableName, $selfTableOptions);
     $targetTableOptions['extend']['relation.' . $relationKey . '.field_id'] = $targetFieldId;
     $this->extendOptionsManager->setTableOptions($targetTableName, $targetTableOptions);
     $options[ExtendOptionsManager::TARGET_OPTION] = ['table_name' => $selfTableName, 'relation_key' => $relationKey, 'columns' => ['title' => $targetTitleColumnNames, 'detailed' => $targetDetailedColumnNames, 'grid' => $targetGridColumnNames]];
     $options[ExtendOptionsManager::TYPE_OPTION] = RelationType::ONE_TO_MANY;
     $this->extendOptionsManager->setColumnOptions($targetTableName, $targetAssociationName, $options);
 }

 /**
  * @param string $tableName
  * @param string $columnName
  * @param array  $options
  *
  * @SuppressWarnings(PHPMD.NPathComplexity)
  * @SuppressWarnings(PHPMD.CyclomaticComplexity)
  */
 public function addColumnOptions($tableName, $columnName, $options)
 {
     $entityClassName = $this->getEntityClassName($tableName, null, false);
     if (!$entityClassName) {
         return;
     }
     $newColumnName = $this->getAndRemoveOption($options, ExtendOptionsManager::NEW_NAME_OPTION);
     if ($newColumnName) {
         $this->result[ExtendConfigProcessor::RENAME_CONFIGS][$entityClassName][$columnName] = $newColumnName;
         if (empty($options)) {
             return;
         }
     }
     $fieldName = $this->getAndRemoveOption($options, ExtendOptionsManager::FIELD_NAME_OPTION);
     if (!$fieldName) {
         $fieldName = $this->getFieldName($tableName, $columnName);
     }
     $columnType = $this->getAndRemoveOption($options, ExtendOptionsManager::TYPE_OPTION);
     $columnMode = $this->getAndRemoveOption($options, ExtendOptionsManager::MODE_OPTION);
     $columnUnderlyingType = $this->fieldTypeHelper->getUnderlyingType($columnType);
     if (in_array($columnUnderlyingType, RelationType::$anyToAnyRelations, true)) {
         if (!isset($options['extend'])) {
             $options['extend'] = [];
         }
         $target = $this->getAndRemoveOption($options, ExtendOptionsManager::TARGET_OPTION);
         foreach ($target as $optionName => $optionValue) {
             switch ($optionName) {
                 case 'table_name':
                     $options['extend']['target_entity'] = $this->getEntityClassName($optionValue);
                     break;
                 case 'column':
                     $options['extend']['target_field'] = $this->getFieldName($target['table_name'], $optionValue);
                     break;
                 case 'columns':
                     foreach ($optionValue as $group => $columns) {
                         $values = [];
                         foreach ($columns as $column) {
                             $values[] = $this->getFieldName($target['table_name'], $column);
                         }
                         $options['extend']['target_' . $group] = $values;
                     }
                     break;
                 default:
                     $options['extend'][$optionName] = $optionValue;
                     break;
             }
         }
         if (!isset($options['extend']['relation_key'])) {
             $options['extend']['relation_key'] = ExtendHelper::buildRelationKey($entityClassName, $fieldName, $columnUnderlyingType, $options['extend']['target_entity']);
         }
     }
     $this->result[$entityClassName]['fields'][$fieldName] = [];
     if (!empty($options)) {
         $this->result[$entityClassName]['fields'][$fieldName]['configs'] = $options;
     }
     if ($columnType) {
         $this->result[$entityClassName]['fields'][$fieldName]['type'] = $columnType;
     }
     if ($columnMode) {
         $this->result[$entityClassName]['fields'][$fieldName]['mode'] = $columnMode;
     }
 }

 public function testBuildRelationKey()
 {
     $this->assertEquals('manyToOne|Test\\Entity|Test\\TargetEntity|testField', ExtendHelper::buildRelationKey('Test\\Entity', 'testField', 'manyToOne', 'Test\\TargetEntity'));
 }

 /**
  * @SuppressWarnings(PHPMD.ExcessiveMethodLength)
  */
 public function testBuildManyToManyTargetSide()
 {
     $entityClass = 'Oro\\Bundle\\EntityExtendBundle\\Tests\\Unit\\Fixtures\\TestClass';
     $fieldName = 'srcField';
     $fieldType = RelationType::MANY_TO_MANY;
     $fieldId = new FieldConfigId('extend', $entityClass, $fieldName, $fieldType);
     $targetEntityClass = 'Oro\\Bundle\\EntityExtendBundle\\Tests\\Unit\\Fixtures\\TestClass2';
     $targetFieldName = 'targetField';
     $targetFieldType = RelationType::MANY_TO_MANY;
     $targetFieldId = new FieldConfigId('extend', $targetEntityClass, $targetFieldName, $targetFieldType);
     $metadataBuilder = new ClassMetadataBuilder(new ClassMetadataInfo($entityClass));
     $relationKey = ExtendHelper::buildRelationKey($entityClass, $fieldName, RelationType::MANY_TO_ONE, $targetEntityClass);
     $extendConfig = $this->getEntityConfig($entityClass, ['relation' => [$relationKey => ['field_id' => $fieldId, 'owner' => false, 'target_entity' => $targetEntityClass, 'target_field_id' => $targetFieldId]], 'schema' => ['relation' => [$fieldName => []]]]);
     $this->builder->build($metadataBuilder, $extendConfig);
     $result = $metadataBuilder->getClassMetadata()->getAssociationMapping($fieldName);
     $this->assertEquals(['sourceEntity' => $entityClass, 'targetEntity' => $targetEntityClass, 'fieldName' => $fieldName, 'type' => ClassMetadataInfo::MANY_TO_MANY, 'isOwningSide' => false, 'mappedBy' => $targetFieldName, 'inversedBy' => null, 'cascade' => [], 'joinTable' => [], 'fetch' => ClassMetadataInfo::FETCH_LAZY, 'isCascadeRemove' => false, 'isCascadePersist' => false, 'isCascadeRefresh' => false, 'isCascadeMerge' => false, 'isCascadeDetach' => false, 'orphanRemoval' => false], $result);
     $defaultRelationFieldName = ExtendConfigDumper::DEFAULT_PREFIX . $fieldName;
     $this->assertFalse($metadataBuilder->getClassMetadata()->hasAssociation($defaultRelationFieldName));
 }

 /**
  * @param ConfigInterface $fieldConfig
  */
 protected function setRelationKeyToFieldConfig(ConfigInterface $fieldConfig)
 {
     /** @var FieldConfigId $fieldConfigId */
     $fieldConfigId = $fieldConfig->getId();
     $relationKey = ExtendHelper::buildRelationKey($fieldConfigId->getClassName(), $fieldConfigId->getFieldName(), $this->fieldTypeHelper->getUnderlyingType($fieldConfigId->getFieldType()), $fieldConfig->get('target_entity'));
     $fieldConfig->set('relation_key', $relationKey);
     $this->configManager->persist($fieldConfig);
 }