protected function setUp()
 {
     $this->entityManager = $this->getMockBuilder('Doctrine\\ORM\\EntityManager')->disableOriginalConstructor()->getMock();
     $this->doctrineHelper = $this->getMockBuilder('Oro\\Bundle\\EntityBundle\\ORM\\DoctrineHelper')->disableOriginalConstructor()->getMock();
     $this->doctrineHelper->expects($this->any())->method('getEntityManager')->will($this->returnValue($this->entityManager));
     $this->fieldHelper = $this->getMockBuilder('Oro\\Bundle\\ImportExportBundle\\Field\\FieldHelper')->disableOriginalConstructor()->getMock();
     $this->fixer = new EntityDetachFixer($this->doctrineHelper, $this->fieldHelper, PropertyAccess::createPropertyAccessor());
 }

 /**
  * {@inheritdoc}
  */
 protected function getChoices($entityName, $withRelations, $withVirtualFields)
 {
     $choiceFields = [];
     $choiceRelations = [];
     $idFieldNames = $this->doctrineHelper->getEntityIdentifierFieldNames($entityName);
     foreach ($this->getEntityFields($entityName, $withRelations, $withVirtualFields) as $fieldName => $field) {
         $formConfig = $this->formConfigProvider->getConfig($entityName, $fieldName);
         if ($formConfig->is('is_enabled', false) || in_array($fieldName, $idFieldNames)) {
             // field is not enabled for displaying in forms
             // or field is entity identifier
             continue;
         }
         if (!isset($field['relation_type'])) {
             $choiceFields[$fieldName] = $field['label'];
         } elseif (!in_array($field['relation_type'], RelationType::$toManyRelations)) {
             // enable only mass update for *-to-one relations
             $choiceRelations[$fieldName] = $field['label'];
         }
     }
     if (empty($choiceRelations)) {
         return $choiceFields;
     }
     $choices = [];
     if (!empty($choiceFields)) {
         $choices[$this->translator->trans('oro.entity.form.entity_fields')] = $choiceFields;
     }
     $choices[$this->translator->trans('oro.entity.form.entity_related')] = $choiceRelations;
     return $choices;
 }

 /**
  * {@inheritdoc}
  */
 public function getCalendarEvents($organizationId, $userId, $calendarId, $start, $end, $connections, $extraFields = [])
 {
     if (!$this->calendarConfig->isSystemCalendarEnabled() || !$this->securityFacade->isGranted('oro_system_calendar_view')) {
         return [];
     }
     //@TODO: temporary return all system calendars until BAP-6566 implemented
     ///** @var CalendarEventRepository $repo */
     //$repo = $this->doctrineHelper->getEntityRepository('OroCalendarBundle:CalendarEvent');
     //$qb = $repo->getSystemEventListByTimeIntervalQueryBuilder(
     //    $calendarId,
     //    $start,
     //    $end,
     //    []
     //);
     /** @var CalendarEventRepository $repo */
     $repo = $this->doctrineHelper->getEntityRepository('OroCalendarBundle:CalendarEvent');
     $qb = $repo->getSystemEventListByTimeIntervalQueryBuilder($start, $end, [], $extraFields)->andWhere('c.organization = :organizationId')->setParameter('organizationId', $organizationId);
     $invisibleIds = [];
     foreach ($connections as $id => $visible) {
         if (!$visible) {
             $invisibleIds[] = $id;
         }
     }
     if (!empty($invisibleIds)) {
         $qb->andWhere('c.id NOT IN (:invisibleIds)')->setParameter('invisibleIds', $invisibleIds);
     }
     return $this->calendarEventNormalizer->getCalendarEvents($calendarId, $qb->getQuery());
 }

 /**
  * @param BuildAfter $event
  */
 public function onBuildAfter(BuildAfter $event)
 {
     /** @var OrmDatasource $dataSource */
     $datagrid = $event->getDatagrid();
     $config = $datagrid->getConfig();
     $configParameters = $config->toArray();
     if (!array_key_exists('extended_entity_name', $configParameters) || !$configParameters['extended_entity_name']) {
         return;
     }
     $targetClass = $configParameters['extended_entity_name'];
     $parameters = $datagrid->getParameters();
     $dataSource = $datagrid->getDatasource();
     $queryBuilder = $dataSource->getQueryBuilder();
     $alias = current($queryBuilder->getDQLPart('from'))->getAlias();
     if ($dataSource instanceof OrmDatasource && $parameters->has('activityId') && $parameters->has('activityClass')) {
         $id = $parameters->get('activityId');
         $class = $parameters->get('activityClass');
         $entityClass = $this->entityClassNameHelper->resolveEntityClass($class, true);
         $entity = $this->doctrineHelper->getEntity($entityClass, $id);
         if ($entity && $entity instanceof ActivityInterface) {
             $targetsArray = $entity->getActivityTargets($targetClass);
             $targetIds = [];
             foreach ($targetsArray as $target) {
                 $targetIds[] = $target->getId();
             }
             if ($targetIds) {
                 $queryBuilder->andWhere($queryBuilder->expr()->notIn(sprintf('%s.id', $alias), $targetIds));
             }
         }
     }
 }

 /**
  * Collect activities changes
  *
  * @param OnFlushEventArgs $args
  */
 public function onFlush(OnFlushEventArgs $args)
 {
     $entitiesToDelete = $args->getEntityManager()->getUnitOfWork()->getScheduledEntityDeletions();
     $entitiesToUpdate = $args->getEntityManager()->getUnitOfWork()->getScheduledEntityUpdates();
     if (!empty($entitiesToDelete) || !empty($entitiesToUpdate)) {
         foreach ($entitiesToDelete as $entity) {
             $class = $this->doctrineHelper->getEntityClass($entity);
             $id = $this->doctrineHelper->getSingleEntityIdentifier($entity);
             $key = $class . '_' . $id;
             if ($this->activityContactProvider->isSupportedEntity($class) && !isset($this->deletedEntities[$key])) {
                 $targets = $entity->getActivityTargetEntities();
                 $targetsInfo = [];
                 foreach ($targets as $target) {
                     $targetsInfo[] = ['class' => $this->doctrineHelper->getEntityClass($target), 'id' => $this->doctrineHelper->getSingleEntityIdentifier($target), 'direction' => $this->activityContactProvider->getActivityDirection($entity, $target)];
                 }
                 $this->deletedEntities[$key] = ['class' => $class, 'id' => $id, 'contactDate' => $this->activityContactProvider->getActivityDate($entity), 'targets' => $targetsInfo];
             }
         }
         foreach ($entitiesToUpdate as $entity) {
             $class = $this->doctrineHelper->getEntityClass($entity);
             $id = $this->doctrineHelper->getSingleEntityIdentifier($entity);
             $key = $class . '_' . $id;
             if ($this->activityContactProvider->isSupportedEntity($class) && !isset($this->updatedEntities[$key])) {
                 $changes = $args->getEntityManager()->getUnitOfWork()->getEntityChangeSet($entity);
                 $isDirectionChanged = $this->activityContactProvider->getActivityDirectionProvider($entity)->isDirectionChanged($changes);
                 $targets = $entity->getActivityTargetEntities();
                 $targetsInfo = [];
                 foreach ($targets as $target) {
                     $targetsInfo[] = ['class' => $this->doctrineHelper->getEntityClass($target), 'id' => $this->doctrineHelper->getSingleEntityIdentifier($target), 'direction' => $this->activityContactProvider->getActivityDirection($entity, $target), 'is_direction_changed' => $isDirectionChanged];
                 }
                 $this->updatedEntities[$key] = ['class' => $class, 'id' => $id, 'contactDate' => $this->activityContactProvider->getActivityDate($entity), 'targets' => $targetsInfo];
             }
         }
     }
 }

 /**
  * Delegated method
  *
  * @param object $entity
  * @return bool
  */
 public function isAttachmentAssociationEnabled($entity)
 {
     if (!is_object($entity) || !$this->doctrineHelper->isManageableEntity($entity) || $this->doctrineHelper->isNewEntity($entity)) {
         return false;
     }
     return $this->config->isAttachmentAssociationEnabled($entity);
 }

 /**
  * @param StaticSegment $staticSegment
  *
  * {@inheritdoc}
  */
 protected function createSubordinateIterator($staticSegment)
 {
     $this->assertRequiredDependencies();
     if (!$staticSegment->getExtendedMergeVars()) {
         return new \EmptyIterator();
     }
     $qb = $this->getIteratorQueryBuilder($staticSegment);
     $marketingList = $staticSegment->getMarketingList();
     $memberIdentifier = MarketingListQueryBuilderAdapter::MEMBER_ALIAS . '.id';
     $fieldExpr = $this->fieldHelper->getFieldExpr($marketingList->getEntity(), $qb, $this->doctrineHelper->getSingleEntityIdentifierFieldName($marketingList->getEntity()));
     $qb->addSelect($fieldExpr . ' AS entity_id');
     $qb->addSelect($memberIdentifier . ' AS member_id');
     $qb->andWhere($qb->expr()->andX($qb->expr()->isNotNull($memberIdentifier)));
     $bufferedIterator = new BufferedQueryResultIterator($qb);
     $bufferedIterator->setHydrationMode(AbstractQuery::HYDRATE_ARRAY)->setReverse(true);
     $uniqueMembers =& $this->uniqueMembers;
     return new \CallbackFilterIterator($bufferedIterator, function (&$current) use($staticSegment, &$uniqueMembers) {
         if (is_array($current)) {
             if (!empty($current['member_id']) && in_array($current['member_id'], $uniqueMembers, true)) {
                 return false;
             }
             $current['subscribersList_id'] = $staticSegment->getSubscribersList()->getId();
             $current['static_segment_id'] = $staticSegment->getId();
             $uniqueMembers[] = $current['member_id'];
             unset($current['id']);
         }
         return true;
     });
 }

 /**
  * @param object $entity
  * @return object|null
  */
 public function discoverSimilar($entity)
 {
     if (!$this->configuration) {
         return null;
     }
     $idName = $this->doctrineHelper->getSingleEntityIdentifierFieldName($this->discoveryEntityClass);
     $idFieldName = self::ROOT_ALIAS . '.' . $idName;
     /** @var EntityRepository $repository */
     $repository = $this->doctrineHelper->getEntityRepository($this->discoveryEntityClass);
     $qb = $repository->createQueryBuilder(self::ROOT_ALIAS)->select(self::ROOT_ALIAS);
     // Apply search strategies
     $this->applyStrategies($qb, $entity);
     // Apply matcher strategy
     if ($this->configuration[Configuration::DISCOVERY_OPTIONS_KEY][Configuration::DISCOVERY_MATCH_KEY] === Configuration::DISCOVERY_MATCH_LATEST) {
         $qb->orderBy($idFieldName, Criteria::DESC);
     }
     // Skip current entity
     $id = $this->doctrineHelper->getSingleEntityIdentifier($entity);
     if (!empty($id)) {
         $idParameter = ':' . $idName;
         $qb->andWhere($qb->expr()->neq($idFieldName, $idParameter))->setParameter($idParameter, $id);
     }
     // Add organization limits
     $organizationField = $this->ownershipMetadata->getMetadata(ClassUtils::getClass($entity))->getOrganizationFieldName();
     if ($organizationField) {
         $propertyAccessor = PropertyAccess::createPropertyAccessor();
         $organization = $propertyAccessor->getValue($entity, $organizationField);
         $qb->andWhere(sprintf('%s.%s = :organization', self::ROOT_ALIAS, $organizationField))->setParameter('organization', $organization);
     }
     // Get only 1 match
     $qb->setMaxResults(1);
     return $qb->getQuery()->getOneOrNullResult();
 }

 public function testMerge()
 {
     $account1 = new User();
     $account2 = new User();
     $this->setId($account1, 1);
     $this->setId($account2, 2);
     $entityMetadata = new EntityMetadata(['type' => ClassUtils::getRealClass($account1)]);
     $entityData = new EntityData($entityMetadata, [$account1, $account2]);
     $entityData->setMasterEntity($account1);
     $fieldData = new FieldData($entityData, new FieldMetadata());
     $fieldData->setMode(MergeModes::NOTES_REPLACE);
     $fieldData->setSourceEntity($account2);
     $queryBuilder = $this->getMockBuilder('Doctrine\\ORM\\QueryBuilder')->disableOriginalConstructor()->setMethods(['getQuery', 'getResult'])->getMock();
     $queryBuilder->expects($this->any())->method('getQuery')->will($this->returnSelf());
     $queryBuilder->expects($this->any())->method('getResult')->will($this->returnValue([new ExtendNote()]));
     $repository = $this->getMockBuilder('Oro\\Bundle\\ActivityListBundle\\Entity\\Repository\\ActivityListRepository')->disableOriginalConstructor()->setMethods(['getBaseAssociatedNotesQB', 'getActivityListQueryBuilderByActivityClass'])->getMock();
     $repository->expects($this->any())->method('getBaseAssociatedNotesQB')->willReturn($queryBuilder);
     $activityQueryBuilder = $this->getMockBuilder('Doctrine\\ORM\\QueryBuilder')->disableOriginalConstructor()->setMethods(['getQuery', 'getResult'])->getMock();
     $activityQueryBuilder->expects($this->any())->method('getQuery')->will($this->returnSelf());
     $activityQueryBuilder->expects($this->any())->method('getResult')->will($this->returnValue([['id' => 1, 'relatedActivityId' => 11], ['id' => 3, 'relatedActivityId' => 2]]));
     $repository->expects($this->any())->method('getActivityListQueryBuilderByActivityClass')->willReturn($activityQueryBuilder);
     $entityManager = $this->getMockBuilder('Doctrine\\ORM\\EntityManager')->disableOriginalConstructor()->setMethods(['remove'])->getMock();
     $this->doctrineHelper->expects($this->any())->method('getEntityRepository')->willReturn($repository);
     $this->doctrineHelper->expects($this->any())->method('getEntityManager')->willReturn($entityManager);
     $this->activityListManager->expects($this->once())->method('replaceActivityTargetWithPlainQuery');
     $this->strategy->merge($fieldData);
 }

 /**
  * @param EmailCampaign $emailCampaign
  * @param object  $entity
  * @return EmailCampaignStatistics
  */
 public function getStatisticsRecord(EmailCampaign $emailCampaign, $entity)
 {
     $marketingList = $emailCampaign->getMarketingList();
     $entityId = $this->doctrineHelper->getSingleEntityIdentifier($entity);
     /**
      * Cache was added because there is a case:
      * - 2 email campaigns linked to one marketing list
      * - statistic can created using batches (marketing list item connector will be used)
      *  and flush will be run once per N records creation
      * in this case same Marketing list entity will be received twice for one marketing list
      * and new MarketingListItem for same $marketingList and $entityId will be persisted twice.
      *
      * Marketing list name used as key for cache because Id can be empty and name is unique
      *
      */
     if (empty($this->marketingListItemCache[$marketingList->getName()][$entityId])) {
         // Mark marketing list item as contacted
         $this->marketingListItemCache[$marketingList->getName()][$entityId] = $this->marketingListItemConnector->getMarketingListItem($marketingList, $entityId);
     }
     /** @var MarketingListItem $marketingListItem */
     $marketingListItem = $this->marketingListItemCache[$marketingList->getName()][$entityId];
     $manager = $this->doctrineHelper->getEntityManager($this->entityName);
     $statisticsRecord = null;
     if ($marketingListItem->getId() !== null) {
         $statisticsRecord = $manager->getRepository($this->entityName)->findOneBy(['emailCampaign' => $emailCampaign, 'marketingListItem' => $marketingListItem]);
     }
     if (!$statisticsRecord) {
         $statisticsRecord = new EmailCampaignStatistics();
         $statisticsRecord->setEmailCampaign($emailCampaign)->setMarketingListItem($marketingListItem)->setOwner($emailCampaign->getOwner())->setOrganization($emailCampaign->getOrganization());
         $manager->persist($statisticsRecord);
     }
     return $statisticsRecord;
 }

 /**
  * {@inheritdoc}
  */
 public function merge(FieldData $fieldData)
 {
     $entityData = $fieldData->getEntityData();
     $masterEntity = $entityData->getMasterEntity();
     $sourceEntity = $fieldData->getSourceEntity();
     if ($masterEntity->getId() !== $sourceEntity->getId()) {
         $queryBuilder = $this->doctrineHelper->getEntityRepository('OroNoteBundle:Note')->getBaseAssociatedNotesQB(ClassUtils::getRealClass($masterEntity), $masterEntity->getId());
         $notes = $queryBuilder->getQuery()->getResult();
         if (!empty($notes)) {
             $entityManager = $this->doctrineHelper->getEntityManager(current($notes));
             foreach ($notes as $note) {
                 $entityManager->remove($note);
             }
         }
         $queryBuilder = $this->doctrineHelper->getEntityRepository('OroNoteBundle:Note')->getBaseAssociatedNotesQB(ClassUtils::getRealClass($masterEntity), $sourceEntity->getId());
         $notes = $queryBuilder->getQuery()->getResult();
         if (!empty($notes)) {
             foreach ($notes as $note) {
                 $note->setTarget($masterEntity);
             }
         }
         $fieldMetadata = $fieldData->getMetadata();
         $activityClass = $fieldMetadata->get('type');
         $entityClass = ClassUtils::getRealClass($sourceEntity);
         $queryBuilder = $this->doctrineHelper->getEntityRepository(ActivityList::ENTITY_NAME)->getActivityListQueryBuilderByActivityClass($entityClass, $sourceEntity->getId(), $activityClass);
         $activityListItems = $queryBuilder->getQuery()->getResult();
         $activityIds = ArrayUtils::arrayColumn($activityListItems, 'id');
         $this->activityListManager->replaceActivityTargetWithPlainQuery($activityIds, $entityClass, $sourceEntity->getId(), $masterEntity->getId());
     }
 }

 /**
  * {@inheritdoc}
  */
 protected function applyAdditionalData(&$items, $calendarId)
 {
     $parentEventIds = $this->getParentEventIds($items);
     if (!empty($parentEventIds)) {
         /** @var CalendarEventRepository $repo */
         $repo = $this->doctrineHelper->getEntityRepository('OroCalendarBundle:CalendarEvent');
         $invitees = $repo->getInvitedUsersByParentsQueryBuilder($parentEventIds)->getQuery()->getArrayResult();
         $groupedInvitees = [];
         foreach ($invitees as $invitee) {
             $groupedInvitees[$invitee['parentEventId']][] = $invitee;
         }
         foreach ($items as &$item) {
             $item['invitedUsers'] = [];
             if (isset($groupedInvitees[$item['id']])) {
                 foreach ($groupedInvitees[$item['id']] as $invitee) {
                     $item['invitedUsers'][] = $invitee['userId'];
                 }
             }
         }
     } else {
         foreach ($items as &$item) {
             $item['invitedUsers'] = [];
         }
     }
 }

 /**
  * Checks if the entity can have comments
  *
  * @param object|null $entity
  *
  * @return bool
  */
 public function isApplicable($entity)
 {
     if (!is_object($entity) || !$this->doctrineHelper->isManageableEntity($entity) || !$this->securityFacade->isGranted('oro_comment_view')) {
         return false;
     }
     return $this->commentAssociationHelper->isCommentAssociationEnabled(ClassUtils::getClass($entity));
 }

 /**
  * {@inheritdoc}
  */
 public function getDirection($activity, $target)
 {
     //check if target is entity created from admin part
     if (!$target instanceof EmailHolderInterface) {
         $metadata = $this->doctrineHelper->getEntityMetadata($target);
         $columns = $metadata->getColumnNames();
         $className = get_class($target);
         foreach ($columns as $column) {
             //check only columns with 'contact_information'
             if ($this->isEmailType($className, $column)) {
                 $getMethodName = "get" . Inflector::classify($column);
                 /** @var $activity Email */
                 if ($activity->getFromEmailAddress()->getEmail() === $target->{$getMethodName}()) {
                     return DirectionProviderInterface::DIRECTION_OUTGOING;
                 } else {
                     foreach ($activity->getTo() as $recipient) {
                         if ($recipient->getEmailAddress()->getEmail() === $target->{$getMethodName}()) {
                             return DirectionProviderInterface::DIRECTION_INCOMING;
                         }
                     }
                 }
             }
         }
         return DirectionProviderInterface::DIRECTION_UNKNOWN;
     }
     /** @var $activity Email */
     /** @var $target EmailHolderInterface */
     if ($activity->getFromEmailAddress()->getEmail() === $target->getEmail()) {
         return DirectionProviderInterface::DIRECTION_OUTGOING;
     }
     return DirectionProviderInterface::DIRECTION_INCOMING;
 }

 /**
  * @dataProvider skuDataProvider
  * @param string[] $existingSku
  * @param array $testCases
  */
 public function testIncrementSku(array $existingSku, array $testCases)
 {
     $this->doctrineHelper->expects($this->any())->method('getEntityRepository')->with(self::PRODUCT_CLASS)->willReturn($this->getProductRepositoryMock($existingSku));
     foreach ($testCases as $expected => $sku) {
         $this->assertEquals($expected, $this->service->increment($sku));
     }
 }

 /**
  * Checks if the entity can has notes
  *
  * @param object $entity
  * @return bool
  */
 public function isNoteAssociationEnabled($entity)
 {
     if (!is_object($entity) || !$this->doctrineHelper->isManageableEntity($entity) || $this->doctrineHelper->isNewEntity($entity)) {
         return false;
     }
     return $this->noteAssociationHelper->isNoteAssociationEnabled(ClassUtils::getClass($entity));
 }

 /**
  * {@inheritdoc}
  */
 public function batchUpdate(MassActionInterface $massAction, IterableResultInterface $results, array $data)
 {
     $this->entityName = $massAction->getOptions()->offsetGet('entityName');
     $this->fieldName = empty($data['mass_edit_field']) ? null : $data['mass_edit_field'];
     if (empty($this->fieldName)) {
         throw new \RuntimeException("Field name was not specified with option 'mass_edit_field'");
     }
     $this->identifierName = $this->doctrineHelper->getSingleEntityIdentifierFieldName($this->entityName);
     $value = $data[$this->fieldName];
     $selectedIds = [];
     $entitiesCount = 0;
     $iteration = 0;
     $this->entityManager = $this->doctrineHelper->getEntityManager($this->entityName);
     $this->entityManager->beginTransaction();
     try {
         set_time_limit(0);
         foreach ($results as $result) {
             /** @var $result ResultRecordInterface */
             $selectedIds[] = $result->getValue($this->identifierName);
             $iteration++;
             if ($iteration % $this->batchSize == 0) {
                 $entitiesCount += $this->finishBatch($selectedIds, $value);
             }
         }
         if ($iteration % $this->batchSize > 0) {
             $entitiesCount += $this->finishBatch($selectedIds, $value);
         }
         $this->entityManager->commit();
     } catch (\Exception $e) {
         $this->entityManager->rollback();
         throw $e;
     }
     return $entitiesCount;
 }

 /**
  * @param bool $withRelations
  *
  * @dataProvider testDataProvider
  */
 public function testBuildFormRegularGuesser($withRelations)
 {
     $entityName = 'Test\\Entity';
     $this->doctrineHelperMock->expects($this->once())->method('getEntityIdentifierFieldNames')->with($entityName)->willReturn(['id']);
     $fields = [['name' => 'oneField', 'type' => 'string', 'label' => 'One field'], ['name' => 'anotherField', 'type' => 'string', 'label' => 'Another field']];
     if ($withRelations) {
         $fields[] = ['name' => 'relField', 'relation_type' => 'ref-one', 'label' => 'Many to One field'];
     }
     $this->entityFieldMock->expects($this->once())->method('getFields')->willReturn($fields);
     $this->formConfigMock->expects($this->at(0))->method('getConfig')->with($entityName, 'oneField')->willReturn(new Config(new FieldConfigId('form', $entityName, 'someField'), ['is_enabled' => false]));
     $this->formConfigMock->expects($this->at(1))->method('getConfig')->with($entityName, 'anotherField')->willReturn(new Config(new FieldConfigId('form', $entityName, 'anotherField'), ['is_enabled' => true]));
     if ($withRelations) {
         $this->formConfigMock->expects($this->at(2))->method('getConfig')->with($entityName, 'relField')->willReturn(new Config(new FieldConfigId('form', $entityName, 'relField'), ['is_enabled' => true]));
         $this->translatorMock->expects($this->at(0))->method('trans')->with('oro.entity.form.entity_fields')->willReturn('Fields');
         $this->translatorMock->expects($this->at(1))->method('trans')->with('oro.entity.form.entity_related')->willReturn('Relations');
     }
     $form = $this->factory->create($this->type, null, ['entity' => $entityName, 'with_relations' => $withRelations]);
     $view = $form->createView();
     $this->assertEquals('update_field_choice', $view->vars['full_name'], 'Failed asserting that field name is correct');
     $this->assertNotEmpty($view->vars['configs']['component']);
     $this->assertEquals('entity-field-choice', $view->vars['configs']['component']);
     $this->assertEquals('update_field_choice', $form->getConfig()->getType()->getName(), 'Failed asserting that correct underlying type was used');
     if ($withRelations) {
         $this->assertCount(2, $view->vars['choices'], 'Failed asserting that choices are grouped');
     } else {
         $this->assertCount(1, $view->vars['choices'], 'Failed asserting that choices exists');
         /** @var ChoiceView $choice */
         $choice = reset($view->vars['choices']);
         $this->assertEquals('Another field', $choice->label);
     }
 }

 /**
  * {@inheritdoc}
  */
 public function buildForm(FormBuilderInterface $builder, array $options)
 {
     if (empty($options['data_class'])) {
         return;
     }
     $className = $options['data_class'];
     if (!$this->doctrineHelper->isManageableEntity($className)) {
         return;
     }
     if (!$this->entityConfigProvider->hasConfig($className)) {
         return;
     }
     $uniqueKeys = $this->entityConfigProvider->getConfig($className)->get('unique_key');
     if (empty($uniqueKeys)) {
         return;
     }
     /* @var \Symfony\Component\Validator\Mapping\ClassMetadata $validatorMetadata */
     $validatorMetadata = $this->validator->getMetadataFor($className);
     foreach ($uniqueKeys['keys'] as $uniqueKey) {
         $fields = $uniqueKey['key'];
         $labels = array_map(function ($fieldName) use($className) {
             $label = $this->entityConfigProvider->getConfig($className, $fieldName)->get('label');
             return $this->translator->trans($label);
         }, $fields);
         $constraint = new UniqueEntity(['fields' => $fields, 'errorPath' => '', 'message' => $this->translator->transChoice('oro.entity.validation.unique_field', sizeof($fields), ['%field%' => implode(', ', $labels)])]);
         $validatorMetadata->addConstraint($constraint);
     }
 }

 /**
  * @param string $message
  * @param ProcessTrigger $trigger
  * @param ProcessData $data
  */
 public function debug($message, ProcessTrigger $trigger, ProcessData $data)
 {
     if ($this->logger) {
         $context = array('definition' => $trigger->getDefinition()->getName(), 'event' => $trigger->getEvent(), 'entityId' => $this->doctrineHelper->getSingleEntityIdentifier($data['data'], false));
         $this->logger->debug($message, $context);
     }
 }