public function testResolve() { $route = new Route('/{activity}/route', [], [], ['group' => 'activity_association']); $this->routeCollection->add('first_route', new Route('/first_route')); $this->routeCollection->add('override1', new Route('/notes/route')); $this->routeCollection->add('some_route', new Route('/some_route')); $this->routeCollection->add('tested_route', $route); $this->routeCollection->add('override2', new Route('/emails/route')); $this->routeCollection->add('last_route', new Route('/last_route')); $config1 = new Config(new EntityConfigId('grouping', 'Test\\Email')); $config1->set('groups', ['activity']); $config2 = new Config(new EntityConfigId('grouping', 'Test\\Call')); $config2->set('groups', ['test', 'activity']); $config3 = new Config(new EntityConfigId('grouping', 'Test\\Message')); $config4 = new Config(new EntityConfigId('grouping', 'Test\\Note')); $config4->set('groups', ['activity']); $this->groupingConfigProvider->expects($this->once())->method('getConfigs')->with(null, false)->willReturn([$config1, $config2, $config3, $config4]); $this->entityAliasResolver->expects($this->exactly(3))->method('getPluralAlias')->willReturnMap([['Test\\Email', 'emails'], ['Test\\Call', 'calls'], ['Test\\Note', 'notes']]); $this->routeOptionsResolver->resolve($route, $this->routeCollectionAccessor); $this->assertEquals(['activity' => 'emails|calls|notes'], $route->getRequirements()); $this->routeCollection->sortByPriority(); $this->assertEquals(['first_route', 'some_route', 'override2', 'tested_route_auto_7', 'override1', 'tested_route', 'last_route'], array_keys($this->routeCollection->all())); $this->assertEquals('emails|calls|notes', $this->routeCollection->get('tested_route')->getRequirement('activity')); $this->assertEquals('calls', $this->routeCollection->get('tested_route_auto_7')->getDefault('activity')); }
public function testResolve() { $route = new Route('/{activity}/route', [], [], ['group' => ActivityAssociationRouteOptionsResolver::ROUTE_GROUP]); $this->routeCollection->add('first_route', new Route('/first_route')); $this->routeCollection->add('override_before', new Route('/events/route')); $this->routeCollection->add('some_route', new Route('/some_route')); $this->routeCollection->add('tested_route', $route); $this->routeCollection->add('override_after', new Route('/emails/route')); $this->routeCollection->add('last_route', new Route('/last_route')); $config1 = new Config(new EntityConfigId('grouping', 'Test\\Email')); $config1->set('groups', ['activity']); $config2 = new Config(new EntityConfigId('grouping', 'Test\\Call')); $config2->set('groups', ['test', 'activity']); $config3 = new Config(new EntityConfigId('grouping', 'Test\\Task')); $config3->set('groups', ['activity']); $config4 = new Config(new EntityConfigId('grouping', 'Test\\Message')); $config5 = new Config(new EntityConfigId('grouping', 'Test\\Event')); $config5->set('groups', ['activity']); $this->groupingConfigProvider->expects($this->once())->method('getConfigs')->with(null, false)->willReturn([$config1, $config2, $config3, $config4, $config5]); $this->entityAliasResolver->expects($this->exactly(4))->method('getPluralAlias')->willReturnMap([['Test\\Email', 'emails'], ['Test\\Call', 'calls'], ['Test\\Task', 'tasks'], ['Test\\Event', 'events']]); $this->routeOptionsResolver->resolve($route, $this->routeCollectionAccessor); $this->assertEquals(['activity' => '\\w+'], $route->getRequirements()); $this->routeCollection->sortByPriority(); $this->assertEquals(['first_route', 'some_route', 'override_after', 'tested_route_auto_7', 'tested_route_auto_8', 'override_before', 'tested_route', 'last_route'], array_keys($this->routeCollection->all())); $this->assertEquals('\\w+', $this->routeCollection->get('tested_route')->getRequirement('activity')); $this->assertEquals('calls', $this->routeCollection->get('tested_route_auto_7')->getDefault('activity')); $this->assertEquals('tasks', $this->routeCollection->get('tested_route_auto_8')->getDefault('activity')); }
public function testGetEntities() { $entityConfig = $this->getMockBuilder('Oro\\Bundle\\EntityConfigBundle\\Config\\ConfigInterface')->disableOriginalConstructor()->getMock(); $entityConfig->expects($this->at(0))->method('get')->with('label')->will($this->returnValue('SomeLabel')); $this->entityConfigProvider->expects($this->once())->method('hasConfig')->with('SomeClass')->will($this->returnValue(true)); $this->entityConfigProvider->expects($this->once())->method('getConfig')->with('SomeClass')->will($this->returnValue($entityConfig)); $securityConfigId = new EntityConfigId('security', 'SomeClass'); $securityConfig = new Config($securityConfigId); $securityConfig->set('type', Provider::ACL_SECURITY_TYPE); $securityConfig->set('permissions', 'All'); $securityConfig->set('group_name', 'SomeGroup'); $securityConfigs = array($securityConfig); $this->securityConfigProvider->expects($this->any())->method('getConfigs')->will($this->returnValue($securityConfigs)); $this->cache->expects($this->at(0))->method('fetch')->with(Provider::ACL_SECURITY_TYPE)->will($this->returnValue(false)); $this->cache->expects($this->at(2))->method('fetch')->with(Provider::ACL_SECURITY_TYPE)->will($this->returnValue(array('SomeClass' => $this->entity))); $this->cache->expects($this->once())->method('save')->with(Provider::ACL_SECURITY_TYPE, array('SomeClass' => $this->entity)); $provider = new Provider($this->securityConfigProvider, $this->entityConfigProvider, $this->extendConfigProvider, $this->cache); // call without cache $result = $provider->getEntities(); $this->assertCount(1, $result); $this->assertContainsOnlyInstancesOf('Oro\\Bundle\\SecurityBundle\\Metadata\\EntitySecurityMetadata', $result); $this->assertEquals(serialize($result), serialize(array($this->entity))); // call with local cache $result = $provider->getEntities(); $this->assertCount(1, $result); $this->assertContainsOnlyInstancesOf('Oro\\Bundle\\SecurityBundle\\Metadata\\EntitySecurityMetadata', $result); $this->assertEquals(serialize($result), serialize(array($this->entity))); // call with cache $provider = new Provider($this->securityConfigProvider, $this->entityConfigProvider, $this->extendConfigProvider, $this->cache); $result = $provider->getEntities(); $this->assertCount(1, $result); $this->assertContains($this->entity, $result); }
/** * @param string $className * @param mixed $values * * @return ConfigInterface */ protected function getEntityConfig($className, $values) { $configId = new EntityConfigId('extend', $className); $config = new Config($configId); $config->setValues($values); return $config; }
public function testFlush() { $container = $this->getMock('Symfony\\Component\\DependencyInjection\\ContainerInterface'); $model = new EntityConfigModel(self::ENTITY_CLASS); $entityConfigId = new EntityConfigId('entity', self::ENTITY_CLASS); $entityConfig = new Config($entityConfigId); $entityConfig->set('icon', 'test_icon'); $entityConfig->set('label', 'test_label'); $entityPropertyConfig = new PropertyConfigContainer(['entity' => ['items' => ['icon' => [], 'label' => ['options' => ['indexed' => true]]]]], $container); $this->entityConfigProvider->expects($this->once())->method('getPropertyConfig')->will($this->returnValue($entityPropertyConfig)); $testConfigId = new EntityConfigId('test', self::ENTITY_CLASS); $testConfig = new Config($testConfigId); $testConfig->set('attr1', 'test_attr1'); $testPropertyConfig = new PropertyConfigContainer(['entity' => ['items' => ['attr1' => []]]], $container); $this->testConfigProvider->expects($this->once())->method('getPropertyConfig')->will($this->returnValue($testPropertyConfig)); $this->modelManager->expects($this->once())->method('getEntityModel')->with($entityConfigId->getClassName())->will($this->returnValue($model)); $em = $this->getMockBuilder('Doctrine\\ORM\\EntityManager')->disableOriginalConstructor()->getMock(); $this->modelManager->expects($this->any())->method('getEntityManager')->will($this->returnValue($em)); $this->setFlushExpectations($em, [$model]); $this->eventDispatcher->expects($this->at(0))->method('dispatch')->with(Events::PRE_PERSIST_CONFIG, new PersistConfigEvent($entityConfig, $this->configManager)); $this->eventDispatcher->expects($this->at(1))->method('dispatch')->with(Events::PRE_PERSIST_CONFIG, new PersistConfigEvent($testConfig, $this->configManager)); $this->configManager->persist($entityConfig); $this->configManager->persist($testConfig); $this->configManager->flush(); $this->assertEquals(['icon' => 'test_icon', 'label' => 'test_label'], $model->toArray('entity')); $this->assertEquals(['attr1' => 'test_attr1'], $model->toArray('test')); $this->assertCount(3, $model->getIndexedValues()); $this->assertEquals('entity_config', $model->getIndexedValues()[0]->getScope()); $this->assertEquals('module_name', $model->getIndexedValues()[0]->getCode()); $this->assertEquals('entity_config', $model->getIndexedValues()[1]->getScope()); $this->assertEquals('entity_name', $model->getIndexedValues()[1]->getCode()); $this->assertEquals('entity', $model->getIndexedValues()[2]->getScope()); $this->assertEquals('label', $model->getIndexedValues()[2]->getCode()); }
public function testSupportsForNotActivityEntity() { $config = new Config(new EntityConfigId('grouping', 'Test\\Entity')); $config->set('groups', ['another_group']); $this->groupingConfigProvider->expects($this->once())->method('hasConfig')->with('Test\\Entity')->will($this->returnValue(true)); $this->groupingConfigProvider->expects($this->once())->method('getConfig')->with('Test\\Entity')->will($this->returnValue($config)); $this->assertFalse($this->extension->supports(['class' => 'Test\\Entity'])); }
public function testIsEntityAuditable() { $config = new Config(new EntityConfigId('dataaudit', self::TEST_ENTITY_REFERENCE)); $config->set('auditable', true); $this->configProvider->expects($this->once())->method('hasConfig')->with(self::TEST_ENTITY_REFERENCE)->will($this->returnValue(true)); $this->configProvider->expects($this->once())->method('getConfig')->with(self::TEST_ENTITY_REFERENCE)->will($this->returnValue($config)); $this->assertTrue($this->filter->isEntityAuditable(new LoggableClass(), false)); }
public function testIsNoteAssociationEnabled() { $config = new Config(new EntityConfigId('note', static::TEST_ENTITY_REFERENCE)); $config->set('enabled', true); $this->noteConfigProvider->expects($this->once())->method('hasConfig')->with(static::TEST_ENTITY_REFERENCE)->will($this->returnValue(true)); $this->noteConfigProvider->expects($this->once())->method('getConfig')->with(static::TEST_ENTITY_REFERENCE)->will($this->returnValue($config)); $this->entityConfigProvider->expects($this->once())->method('hasConfig')->with(Note::ENTITY_NAME, ExtendHelper::buildAssociationName(static::TEST_ENTITY_REFERENCE))->will($this->returnValue(true)); $this->assertTrue($this->filter->isNoteAssociationEnabled(new TestEntity(1))); }
public function testIsAttachmentAssociationEnabled() { $config = new Config(new EntityConfigId('attachment', 'stdClass')); $config->set('enabled', true); $this->attachmentConfigProvider->expects($this->once())->method('hasConfig')->with('stdClass')->will($this->returnValue(true)); $this->attachmentConfigProvider->expects($this->once())->method('getConfig')->with('stdClass')->will($this->returnValue($config)); $this->entityConfigProvider->expects($this->once())->method('hasConfig')->with(AttachmentScope::ATTACHMENT, ExtendHelper::buildAssociationName('stdClass'))->will($this->returnValue(true)); $this->assertTrue($this->filter->isAttachmentAssociationEnabled(new \stdClass())); }
public function testConfigHas() { $config = new Config(new EntityConfigId('test', 'Entity1'), ['attr' => 'val', 'null_attr' => null]); self::assertBenchmark(__METHOD__, 0.05, function () use($config) { $config->has('attr'); $config->has('null_attr'); $config->has('undefined_attr'); }); }
public function testGetMetadataWithoutCache() { $config = new Config(new EntityConfigId('ownership', 'SomeClass')); $config->set('frontend_owner_type', 'USER')->set('frontend_owner_field_name', 'test_field')->set('frontend_owner_column_name', 'test_column'); $this->configProvider->expects($this->once())->method('hasConfig')->with('SomeClass')->willReturn(true); $this->configProvider->expects($this->once())->method('getConfig')->with('SomeClass')->willReturn($config); $this->cache = null; $this->assertEquals(new FrontendOwnershipMetadata('USER', 'test_field', 'test_column'), $this->provider->getMetadata('SomeClass')); }
protected function prepareConfigProvider(array $configValues, $className) { /** @var \PHPUnit_Framework_MockObject_MockObject|ConfigIdInterface $configId */ $configId = $this->getMock('Oro\\Bundle\\EntityConfigBundle\\Config\\Id\\ConfigIdInterface'); $entityConfig = new Config($configId); $entityConfig->setValues($configValues); $this->configProvider->expects($this->once())->method('hasConfig')->with($this->equalTo($className))->will($this->returnValue(true)); $this->configProvider->expects($this->once())->method('getConfig')->with($this->equalTo($className))->will($this->returnValue($entityConfig)); }
public function testPrePersistEntityConfigWithNoneOwnership() { $config = new Config(new EntityConfigId('ownership', 'Test\\Entity1')); $config->set('owner_type', 'NONE'); $expectedConfig = new Config(new EntityConfigId('ownership', 'Test\\Entity1')); $this->configManager->expects($this->once())->method('persist')->with($expectedConfig); $this->configManager->expects($this->once())->method('calculateConfigChangeSet')->with($expectedConfig); $this->subscriber->prePersistEntityConfig(new PersistConfigEvent($config, $this->configManager)); }
/** * Test new index created and old deleted when field renamed */ public function testRenameField() { $entityConfig = new Config(new EntityConfigId('extend', self::ENTITY_CLASS_NAME)); $entityConfig->set('index', ['testField' => ['testField']]); $this->configProvider->expects($this->once())->method('getConfig')->with(self::ENTITY_CLASS_NAME)->will($this->returnValue($entityConfig)); $event = new RenameFieldEvent(self::ENTITY_CLASS_NAME, 'testField', 'newName', $this->configManager); $listener = new EntityConfigListener(); $listener->renameField($event); $this->assertEquals(['newName' => ['testField']], $entityConfig->get('index')); }
public function testIsApplicable() { $config = new Config(new EntityConfigId('comment', static::TEST_ENTITY_REFERENCE)); $config->set('enabled', true); $this->securityFacade->expects($this->once())->method('isGranted')->with('oro_comment_view')->willReturn(true); $this->commentConfigProvider->expects($this->once())->method('hasConfig')->with(static::TEST_ENTITY_REFERENCE)->will($this->returnValue(true)); $this->commentConfigProvider->expects($this->once())->method('getConfig')->with(static::TEST_ENTITY_REFERENCE)->will($this->returnValue($config)); $this->entityConfigProvider->expects($this->once())->method('hasConfig')->with(Comment::ENTITY_NAME, ExtendHelper::buildAssociationName(static::TEST_ENTITY_REFERENCE))->will($this->returnValue(true)); $this->assertTrue($this->filter->isApplicable(new TestEntity())); }
public function testIsNoteAssociationEnabledForEnabledButNotAccessibleAssociationButWithAccessibleFalse() { $entityClass = 'Test\\Entity'; $config = new Config(new EntityConfigId('note', $entityClass)); $config->set('enabled', true); $this->configManager->expects($this->once())->method('hasConfig')->with($entityClass)->willReturn(true); $this->configManager->expects($this->once())->method('getEntityConfig')->with('note', $entityClass)->willReturn($config); $this->configManager->expects($this->never())->method('getFieldConfig'); $this->assertTrue($this->noteAssociationHelper->isNoteAssociationEnabled($entityClass, false)); }
protected function initialize($className) { $metadata = $this->getClassMetadata(['enumField', 'multiEnumField', 'nonConfigurableField']); $enumFieldConfig = new Config(new FieldConfigId('extend', $className, 'enumField', 'enum')); $enumFieldConfig->set('target_field', 'targetField'); $multiEnumFieldConfig = new Config(new FieldConfigId('extend', $className, 'multiEnumField', 'multiEnum')); $this->em->expects($this->once())->method('getClassMetadata')->with($className)->will($this->returnValue($metadata)); $this->extendConfigProvider->expects($this->exactly(3))->method('hasConfig')->will($this->returnValueMap([[$className, 'enumField', true], [$className, 'multiEnumField', true], [$className, 'nonConfigurableField', false]])); $this->extendConfigProvider->expects($this->exactly(2))->method('getConfig')->will($this->returnValueMap([[$className, 'enumField', $enumFieldConfig], [$className, 'multiEnumField', $multiEnumFieldConfig]])); }
/** * Checks whether the name of a new field conflicts with the name of existing field. * * @param string $newFieldName * @param Config $existingFieldConfig * * @return bool */ public function hasFieldNameConflict($newFieldName, Config $existingFieldConfig) { $existingFieldName = $existingFieldConfig->getId()->getFieldName(); if (strtolower($newFieldName) === strtolower($existingFieldName)) { return true; } if ($this->normalizeFieldName($newFieldName) === $this->normalizeFieldName($existingFieldName) && !$existingFieldConfig->is('is_deleted') && !$existingFieldConfig->is('state', ExtendScope::STATE_DELETE)) { return true; } return false; }
protected function prepareReverseRelationsConfig() { $selfEntityConfig = new Config(new EntityConfigId('extend', 'Oro\\Bundle\\UserBundle\\Entity\\User')); $selfTargetFieldId = new FieldConfigId('extend', 'Extend\\Entity\\testEntity1', 'rel_m_t_o', 'manyToOne'); $selfEntityRelation = ['manyToOne|Extend\\Entity\\testEntity1|Oro\\Bundle\\UserBundle\\Entity\\User|rel_m_t_o' => ['assign' => false, 'field_id' => false, 'owner' => false, 'target_entity' => 'Extend\\Entity\\testEntity1', 'target_field_id' => $selfTargetFieldId], 'oneToMany|Extend\\Entity\\testEntity1|Oro\\Bundle\\UserBundle\\Entity\\User|rel_o_t_m' => ['assign' => true, 'field_id' => new FieldConfigId('extend', 'Extend\\Entity\\testEntity1', 'rel_o_t_m', 'oneToMany'), 'owner' => true, 'target_entity' => 'Extend\\Entity\\testEntity1', 'target_field_id' => false]]; $selfEntityConfig->set('relation', $selfEntityRelation); $targetEntityConfig = new Config(new EntityConfigId('extend', 'Extend\\Entity\\testEntity1')); $targetEntityRelation = ['manyToOne|Extend\\Entity\\testEntity1|Oro\\Bundle\\UserBundle\\Entity\\User|rel_m_t_o' => ['assign' => true, 'field_id' => new FieldConfigId('extend', 'Extend\\Entity\\testEntity1', 'rel_m_t_o', 'manyToOne'), 'owner' => true, 'target_entity' => 'Oro\\Bundle\\UserBundle\\Entity\\User', 'target_field_id' => false]]; $targetEntityConfig->set('relation', $targetEntityRelation); return ['selfEntityConfig' => $selfEntityConfig, 'targetFieldId' => $selfTargetFieldId, 'targetEntityConfig' => $targetEntityConfig]; }
public function testPreUpdate() { $configId = new EntityConfigId('extend', 'Acme\\TestBundle\\Entity\\TestEntity'); $config = new Config($configId); $config->set('upgradeable', true); $provider = $this->getMockBuilder('Oro\\Bundle\\EntityConfigBundle\\Provider\\ConfigProvider')->disableOriginalConstructor()->getMock(); $provider->expects($this->once())->method('getConfigs')->willReturn([$config]); $this->listProvider->expects($this->any())->method('getTargetEntityClasses')->willReturn(['Acme\\TestBundle\\Entity\\TestEntity']); $this->configManager->expects($this->any())->method('getProvider')->willReturn($provider); $this->associationBuilder->expects($this->once())->method('createManyToManyAssociation')->with('Oro\\Bundle\\ActivityListBundle\\Entity\\ActivityList', 'Acme\\TestBundle\\Entity\\TestEntity', 'activityList'); $this->extension->preUpdate(); }
public function testWithoutOwnerType() { $entity = new BusinessUnit(); $className = 'Oro\\Bundle\\OrganizationBundle\\Entity\\BusinessUnit'; /** @var \PHPUnit_Framework_MockObject_MockObject|ConfigIdInterface $configId */ $configId = $this->getMock('Oro\\Bundle\\EntityConfigBundle\\Config\\Id\\ConfigIdInterface'); $config = new Config($configId); $config->setValues(['another_owner_type' => 'test_type']); $this->configProvider->expects($this->once())->method('hasConfig')->with($this->equalTo($className))->will($this->returnValue(true)); $this->configProvider->expects($this->once())->method('getConfig')->with($this->equalTo($className))->will($this->returnValue($config)); $this->assertNull($this->extension->getOwnerType($entity)); }
public function testGetMetadataSetsOrganizationFieldName() { $configProvider = $this->getMockBuilder('Oro\\Bundle\\EntityConfigBundle\\Provider\\ConfigProvider')->disableOriginalConstructor()->getMock(); $provider = new OwnershipMetadataProvider(array('organization' => 'AcmeBundle\\Entity\\Organization', 'business_unit' => 'AcmeBundle\\Entity\\BusinessUnit', 'user' => 'AcmeBundle\\Entity\\User'), $configProvider, null); $config = new Config(new EntityConfigId('ownership', 'SomeClass')); $config->set('owner_type', 'ORGANIZATION'); $config->set('owner_field_name', 'test_field'); $config->set('owner_column_name', 'test_column'); $configProvider->expects($this->once())->method('hasConfig')->with($this->equalTo('SomeClass'))->will($this->returnValue(true)); $configProvider->expects($this->once())->method('getConfig')->with($this->equalTo('SomeClass'))->will($this->returnValue($config)); $this->assertEquals(new OwnershipMetadata('ORGANIZATION', 'test_field', 'test_column', 'test_field', 'test_column'), $provider->getMetadata('SomeClass')); }
public function testPreUpdateForManyToOne() { $extension = $this->getExtensionMock(['getAssociationScope', 'getAssociationAttributeName', 'getAssociationKind', 'getAssociationType']); $extension->expects($this->once())->method('getAssociationScope')->will($this->returnValue(self::ASSOCIATION_SCOPE)); $extension->expects($this->exactly(3))->method('getAssociationAttributeName')->will($this->returnValue(self::ATTR_NAME)); $extension->expects($this->once())->method('getAssociationKind')->will($this->returnValue('test')); $extension->expects($this->once())->method('getAssociationType')->will($this->returnValue('manyToOne')); $config1 = new Config(new EntityConfigId(self::ASSOCIATION_SCOPE, 'Test\\Entity1')); $config1->set(self::ATTR_NAME, ['Test\\SourceEntity']); $config2 = new Config(new EntityConfigId(self::ASSOCIATION_SCOPE, 'Test\\Entity2')); $this->setTargetEntityConfigsExpectations([$config1, $config2]); $this->associationBuilder->expects($this->once())->method('createManyToOneAssociation')->with('Test\\SourceEntity', 'Test\\Entity1', 'test'); $extension->preUpdate(); }
/** * @dataProvider dictionaryDataProvider */ public function testGetEntityAliasForDictionary($entityClass, $expectedAlias) { $enumConfigProvider = $this->getMockBuilder('Oro\\Bundle\\EntityConfigBundle\\Provider\\ConfigProvider')->disableOriginalConstructor()->getMock(); $enumConfig = new Config(new EntityConfigId('enum', $entityClass)); $groupingConfigProvider = $this->getMockBuilder('Oro\\Bundle\\EntityConfigBundle\\Provider\\ConfigProvider')->disableOriginalConstructor()->getMock(); $groupingConfig = new Config(new EntityConfigId('grouping', $entityClass)); $groupingConfig->set('groups', [GroupingScope::GROUP_DICTIONARY]); $this->configManager->expects($this->once())->method('hasConfig')->with($entityClass)->willReturn(true); $this->configManager->expects($this->exactly(2))->method('getProvider')->willReturnMap([['enum', $enumConfigProvider], ['grouping', $groupingConfigProvider]]); $enumConfigProvider->expects($this->once())->method('getConfig')->with($entityClass)->willReturn($enumConfig); $groupingConfigProvider->expects($this->once())->method('getConfig')->with($entityClass)->willReturn($groupingConfig); $result = $this->entityAliasProvider->getEntityAlias($entityClass); $this->assertEntityAlias($expectedAlias, $result); }
/** * Test new index created and old deleted when field renamed */ public function testRenameField() { $entityConfig = new Config(new EntityConfigId('extend', self::ENTITY_CLASS_NAME)); $entityConfig->set('index', ['testField' => ['testField']]); $configProvider = $this->getMockBuilder('Oro\\Bundle\\EntityConfigBundle\\Provider\\ConfigProvider')->disableOriginalConstructor()->getMock(); $configProvider->expects($this->once())->method('getConfig')->with(self::ENTITY_CLASS_NAME)->will($this->returnValue($entityConfig)); $configManager = $this->getMockBuilder('Oro\\Bundle\\EntityConfigBundle\\Config\\ConfigManager')->disableOriginalConstructor()->getMock(); $configManager->expects($this->once())->method('getProvider')->with('extend')->will($this->returnValue($configProvider)); $extendConfigProvider = $this->getMockBuilder('Oro\\Bundle\\EntityConfigBundle\\Provider\\ConfigProvider')->disableOriginalConstructor()->getMock(); $event = new RenameFieldEvent(self::ENTITY_CLASS_NAME, 'testField', 'newName', $configManager); $configSubscriber = new ConfigSubscriber($extendConfigProvider); $configSubscriber->renameField($event); $this->assertEquals(['newName' => ['testField']], $entityConfig->get('index')); }
/** * Test class is NOT extend and should NOT be persisted */ public function testNewNotExtendEntity() { $configModel = new EntityConfigModel('Oro\\Bundle\\EntityExtendBundle\\Tests\\Unit\\Fixtures\\TestClass2'); $entityConfig = new Config(new EntityConfigId('Oro\\Bundle\\EntityExtendBundle\\Tests\\Unit\\Fixtures\\TestClass2', 'extend')); /** * value of NEW Config should be empty */ $this->assertEquals([], $entityConfig->all()); $this->configProvider->expects($this->any())->method('getConfig')->will($this->returnValue($entityConfig)); $event = new EntityConfigEvent($configModel->getClassName(), $this->configManager); $listener = new EntityConfigListener(); $listener->updateEntity($event); $this->assertEquals([], $this->configManager->getUpdateConfig()); }
/** * @param string $className * @param null $configs */ protected function prepareMocks($className, $configs) { $this->identifyProvider->expects($this->once())->method('getEventTargetEntities')->will($this->returnValue([$className])); $extendConfig = new Config(new EntityConfigId('extend', $className)); if (!empty($configs)) { foreach ($configs as $name => $value) { $extendConfig->set($name, $value); } } $extendProvider = $this->getMockBuilder('Oro\\Bundle\\EntityConfigBundle\\Provider\\ConfigProvider')->disableOriginalConstructor()->getMock(); $extendProvider->expects($this->once())->method('getConfigs')->will($this->returnValue([$extendConfig])); $extendProvider->expects($this->any())->method('hasConfig')->with('Oro\\Bundle\\TrackingBundle\\Entity\\TrackingVisitEvent')->will($this->returnValue(true)); $this->configManager->expects($this->any())->method('getProvider')->with('extend')->will($this->returnValue($extendProvider)); }
public function testGetEmailFromRelatedObject() { $object = new TestCustomEntity(); $object->setUser(new TestUser('*****@*****.**')); $object->setEmailHolder(new TestEmailHolder('*****@*****.**')); $object->setOther(new SomeEntity()); $config = new Config(new EntityConfigId('extend', get_class($object))); $config->set('relation', [['owner' => true, 'field_id' => new FieldConfigId('extend', get_class($object), 'user', 'manyToOne'), 'target_entity' => 'Oro\\Bundle\\EmailBundle\\Tests\\Unit\\Fixtures\\Entity\\TestUser'], ['owner' => true, 'field_id' => new FieldConfigId('extend', get_class($object), 'emailHolder', 'manyToOne'), 'target_entity' => 'Oro\\Bundle\\EmailBundle\\Tests\\Unit\\Fixtures\\Entity\\TestEmailHolder'], ['owner' => true, 'field_id' => new FieldConfigId('extend', get_class($object), 'other', 'manyToOne'), 'target_entity' => 'Oro\\Bundle\\EmailBundle\\Tests\\Unit\\Fixtures\\Entity\\SomeEntity']]); $this->extendConfigProvider->expects($this->once())->method('hasConfig')->with(get_class($object))->will($this->returnValue(true)); $this->extendConfigProvider->expects($this->once())->method('getConfig')->with(get_class($object))->will($this->returnValue($config)); $this->helper->addTargetEntity('Oro\\Bundle\\EmailBundle\\Tests\\Unit\\Fixtures\\Entity\\TestUser'); $this->helper->addTargetEntity('Oro\\Bundle\\EmailBundle\\Tests\\Unit\\Fixtures\\Entity\\TestEmailHolder', -10); $this->assertEquals('*****@*****.**', $this->helper->getEmail($object)); }
public function preSetData() { $entityConfigId = $this->getMockBuilder('Oro\\Bundle\\EntityConfigBundle\\Config\\Id\\EntityConfigId')->disableOriginalConstructor()->getMock(); $user = new User(); $user->setId(1); $organization = new Organization(); $organization->setId(3); $userConfig = new Config($entityConfigId); $userConfig->setValues(["owner_type" => "USER", "owner_field_name" => "owner", "owner_column_name" => "owner_id", "organization_field_name" => "organization", "organization_column_name" => "organization_id"]); $buConfig = new Config($entityConfigId); $buConfig->setValues(["owner_type" => "BUSINESS_UNIT", "owner_field_name" => "owner", "owner_column_name" => "owner_id", "organization_field_name" => "organization", "organization_column_name" => "organization_id"]); $organizationConfig = new Config($entityConfigId); $organizationConfig->setValues(["owner_type" => "ORGANIZATION", "owner_field_name" => "owner", "owner_column_name" => "owner_id"]); return ['OwnershipType User with UsernamePasswordOrganizationToken' => [new UsernamePasswordOrganizationToken($user, 'admin', 'key', $organization), $userConfig, ['owner' => $user, 'organization' => $organization]], 'OwnershipType BusinessUnit with UsernamePasswordOrganizationToken' => [new UsernamePasswordOrganizationToken($user, 'admin', 'key', $organization), $buConfig, ['organization' => $organization]], 'OwnershipType Organization with UsernamePasswordOrganizationToken' => [new UsernamePasswordOrganizationToken($user, 'admin', 'key', $organization), $organizationConfig, ['owner' => $organization]], 'OwnershipType User with UsernamePasswordToken' => [new UsernamePasswordToken($user, 'admin', 'key'), $userConfig, ['owner' => $user]], 'OwnershipType BusinessUnit with UsernamePasswordToken' => [new UsernamePasswordToken($user, 'admin', 'key'), $buConfig, []], 'OwnershipType Organization with UsernamePasswordToken' => [new UsernamePasswordToken($user, 'admin', 'key'), $organizationConfig, []]]; }
/** * @return \PHPUnit_Framework_MockObject_MockObject */ protected function getExtendConfigMock() { $extendConfigProvider = $this->getMockBuilder('Oro\\Bundle\\EntityConfigBundle\\Provider\\ConfigProvider')->disableOriginalConstructor()->getMock(); $config1 = new Config(new EntityConfigId('extend', self::ENTITY_NAMESPACE . '\\TestEntity1')); $config2 = new Config(new EntityConfigId('extend', self::ENTITY_NAMESPACE . '\\TestEntity2')); $config3 = new Config(new EntityConfigId('extend', self::ENTITY_NAMESPACE . '\\TestEntity3')); $newCustomEntityConfig = new Config(new EntityConfigId('extend', ExtendHelper::ENTITY_NAMESPACE . '\\TestEntity4')); $newCustomEntityConfig->set('state', ExtendScope::STATE_NEW); $toBeDeletedCustomEntityConfig = new Config(new EntityConfigId('extend', ExtendHelper::ENTITY_NAMESPACE . '\\TestEntity5')); $toBeDeletedCustomEntityConfig->set('state', ExtendScope::STATE_DELETE); $deletedCustomEntityConfig = new Config(new EntityConfigId('extend', ExtendHelper::ENTITY_NAMESPACE . '\\TestEntity6')); $deletedCustomEntityConfig->set('state', ExtendScope::STATE_ACTIVE); $deletedCustomEntityConfig->set('is_deleted', true); $entityConfigs = [$config1, $config2, $config3, $newCustomEntityConfig, $toBeDeletedCustomEntityConfig, $deletedCustomEntityConfig]; $extendConfigProvider->expects($this->once())->method('getConfigs')->will($this->returnValue($entityConfigs)); return $extendConfigProvider; }