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();
 }