function it_builds_form(FormBuilderInterface $builder, IdentifiableObjectRepositoryInterface $repository, DataTransformerInterface $transformer, $transformerFactory)
 {
     $options = ['repository' => $repository->getWrappedObject(), 'multiple' => false];
     $transformerFactory->create($repository, ['multiple' => false])->willReturn($transformer);
     $builder->addViewTransformer($transformer, true)->shouldBeCalled();
     $this->buildForm($builder, $options);
 }

 function let(IdentifiableObjectRepositoryInterface $repository, \stdClass $entity)
 {
     $entity->code = 'foo';
     $repository->getIdentifierProperties()->willReturn(['code']);
     $repository->findOneByIdentifier('foo')->willReturn($entity);
     $this->beConstructedWith($repository, ['multiple' => false]);
 }

 /**
  * Find an object according to its identifiers from a repository.
  *
  * @param IdentifiableObjectRepositoryInterface $repository the repository to search inside
  * @param array                                 $data       the data that is currently processed
  *
  * @throws MissingIdentifierException in case the processed data do not allow to retrieve an object
  *                                    by its identifiers properly
  *
  * @return object|null
  */
 protected function findObject(IdentifiableObjectRepositoryInterface $repository, array $data)
 {
     $properties = $repository->getIdentifierProperties();
     $references = [];
     foreach ($properties as $property) {
         if (!isset($data[$property])) {
             throw new MissingIdentifierException(sprintf('Missing identifier column "%s". Columns found: %s.', $property, implode(', ', array_keys($data))));
         }
         $references[] = $data[$property];
     }
     return $repository->findOneByIdentifier(implode('.', $references));
 }

 /**
  * Find an object according to its identifiers from a repository.
  *
  * @param IdentifiableObjectRepositoryInterface $repository the repository to search inside
  * @param array                                 $data       the data that is currently processed
  *
  * @throws MissingIdentifierException in case the processed data do not allow to retrieve an object
  *                                    by its identifiers properly
  *
  * @return object|null
  */
 protected function findObject(IdentifiableObjectRepositoryInterface $repository, array $data)
 {
     $properties = $repository->getIdentifierProperties();
     $references = [];
     foreach ($properties as $property) {
         if (!isset($data[$property])) {
             throw new MissingIdentifierException();
         }
         $references[] = $data[$property];
     }
     return $repository->findOneByIdentifier(implode('.', $references));
 }

 function it_returns_no_products_when_they_all_are_duplicated($productRepository, $paginatorFactory, $stepExecution, ProductInterface $product, $pqbFactory, ProductQueryBuilder $pqb, ProductQueryBuilder $pqb2, Cursor $cursor, Cursor $cursor2, JobParameters $jobParameters, IdentifiableObjectRepositoryInterface $groupRepository, GroupInterface $variantGroup, AttributeInterface $axe, PaginatorInterface $paginator)
 {
     $configuration = ['filters' => [['field' => 'id', 'operator' => 'IN', 'value' => [12, 13]]], 'actions' => ['value' => 'variantGroupCode']];
     $stepExecution->getJobParameters()->willReturn($jobParameters);
     $jobParameters->get('filters')->willReturn($configuration['filters']);
     $jobParameters->get('actions')->willReturn($configuration['actions']);
     $groupRepository->findOneByIdentifier('variantGroupCode')->willReturn($variantGroup);
     $variantGroup->getAxisAttributes()->willReturn([$axe]);
     $variantGroup->getId()->willReturn(42);
     $axe->getCode()->willReturn('axe');
     $productRepository->getEligibleProductIdsForVariantGroup(42)->willReturn([]);
     $pqbFactory->create(['filters' => $configuration['filters']])->willReturn($pqb);
     $pqb->execute()->willReturn($cursor);
     $paginatorFactory->createPaginator($cursor)->willReturn($paginator);
     $pqbFactory->create(['filters' => [['field' => 'id', 'operator' => 'IN', 'value' => ['']]]])->willReturn($pqb2);
     $pqb2->execute()->willReturn($cursor2);
     $this->initialize();
     $this->read()->shouldReturn(null);
 }

 function it_transform_an_existing_product($guesser, $columnInfoTransformer, $attributeCache, $doctrine, $associationReader, $templateUpdater, $productRepository, AttributeInterface $attributeSku, AttributeInterface $attributeDesc, ColumnInfo $columnInfoSku, ColumnInfo $columnInfoFamily, ColumnInfo $columnInfoGroups, ColumnInfo $columnInfoCategories, ColumnInfo $columnInfoAssocGroups, ColumnInfo $columnInfoAssocProducts, ColumnInfo $columnInfoDesc, IdentifiableObjectRepositoryInterface $productRepository, ProductInterface $product, ObjectManager $objectManager, ClassMetadata $productMetadata, RelationTransformer $relationFamily, RelationTransformer $relationGroups, RelationTransformer $relationCategories, ClassMetadata $productValueMetadata, DefaultTransformer $defaultTransformer, ProductValueInterface $valueSku, ProductValueInterface $valueDesc, GroupInterface $variantGroup, ProductTemplateInterface $productTemplate)
 {
     // initialize attributes
     $columnInfoTransformer->transform('Pim\\Bundle\\CatalogBundle\\Model\\Product', ['sku', 'family', 'groups', 'categories', 'SUBSTITUTION-groups', 'SUBSTITUTION-products', 'description-en_US-mobile'])->shouldBeCalled()->willReturn([$columnInfoSku, $columnInfoFamily, $columnInfoGroups, $columnInfoCategories, $columnInfoAssocGroups, $columnInfoAssocProducts, $columnInfoDesc]);
     $columnInfoSku->getName()->willReturn('sku');
     $columnInfoSku->getPropertyPath()->willReturn('sku');
     $columnInfoSku->getLabel()->willReturn('sku');
     $columnInfoSku->getSuffixes()->willReturn([]);
     $columnInfoFamily->getName()->willReturn('family');
     $columnInfoFamily->getPropertyPath()->willReturn('family');
     $columnInfoFamily->getLabel()->willReturn('family');
     $columnInfoFamily->getSuffixes()->willReturn([]);
     // TODO : we should introduce a variant_group column after PIM-2458
     $columnInfoGroups->getName()->willReturn('groups');
     $columnInfoGroups->getPropertyPath()->willReturn('groups');
     $columnInfoGroups->getLabel()->willReturn('groups');
     $columnInfoGroups->getSuffixes()->willReturn([]);
     $columnInfoCategories->getName()->willReturn('categories');
     $columnInfoCategories->getPropertyPath()->willReturn('categories');
     $columnInfoCategories->getLabel()->willReturn('categories');
     $columnInfoCategories->getSuffixes()->willReturn([]);
     $columnInfoAssocGroups->getName()->willReturn('SUBSTITUTION');
     $columnInfoAssocGroups->getPropertyPath()->willReturn('sUBSTITUTION');
     $columnInfoAssocGroups->getLabel()->willReturn('SUBSTITUTION-groups');
     $columnInfoAssocGroups->getSuffixes()->willReturn(['groups']);
     $columnInfoAssocProducts->getName()->willReturn('SUBSTITUTION');
     $columnInfoAssocProducts->getPropertyPath()->willReturn('sUBSTITUTION');
     $columnInfoAssocProducts->getLabel()->willReturn('SUBSTITUTION-products');
     $columnInfoAssocProducts->getSuffixes()->willReturn(['products']);
     $columnInfoDesc->getName()->willReturn('description');
     $columnInfoDesc->getPropertyPath()->willReturn('description');
     $columnInfoDesc->getLabel()->willReturn('description');
     $columnInfoDesc->getSuffixes()->willReturn([]);
     $attributeCache->getAttributes([$columnInfoSku, $columnInfoFamily, $columnInfoGroups, $columnInfoCategories, $columnInfoAssocGroups, $columnInfoAssocProducts, $columnInfoDesc])->willReturn(['sku' => $attributeSku, 'description' => $attributeDesc]);
     $columnInfoSku->setAttribute($attributeSku)->shouldBeCalled();
     $attributeSku->getAttributeType()->willReturn('pim_catalog_identifier');
     $columnInfoFamily->setAttribute(null)->shouldBeCalled();
     $columnInfoGroups->setAttribute(null)->shouldBeCalled();
     $columnInfoCategories->setAttribute(null)->shouldBeCalled();
     $columnInfoDesc->setAttribute($attributeDesc)->shouldBeCalled();
     // find entity
     $attributeSku->getCode()->willReturn('sku');
     $productRepository->findOneByIdentifier('AKNTS')->willReturn($product);
     // set product properties
     $doctrine->getManagerForClass('Pim\\Bundle\\CatalogBundle\\Model\\Product')->willReturn($objectManager);
     $objectManager->getClassMetadata('Pim\\Bundle\\CatalogBundle\\Model\\Product')->willReturn($productMetadata);
     $guesser->getTransformerInfo($columnInfoFamily, $productMetadata)->willReturn([$relationFamily, ['class' => 'Pim\\Bundle\\CatalogBundle\\Entity\\Family', 'multiple' => false]]);
     $guesser->getTransformerInfo($columnInfoGroups, $productMetadata)->willReturn([$relationGroups, ['class' => 'Pim\\Bundle\\CatalogBundle\\Entity\\Group', 'multiple' => true]]);
     $guesser->getTransformerInfo($columnInfoCategories, $productMetadata)->willReturn([$relationCategories, ['class' => 'Pim\\Bundle\\CatalogBundle\\Entity\\Category', 'multiple' => true]]);
     // set product values
     $attributeCache->getRequiredAttributeCodes($product)->willReturn(['sku', 'description']);
     $doctrine->getManagerForClass('Pim\\Bundle\\CatalogBundle\\Model\\ProductValue')->willReturn($objectManager);
     $objectManager->getClassMetadata('Pim\\Bundle\\CatalogBundle\\Model\\ProductValue')->willReturn($productValueMetadata);
     $guesser->getTransformerInfo($columnInfoSku, $productValueMetadata)->willReturn([$defaultTransformer, []]);
     $guesser->getTransformerInfo($columnInfoDesc, $productValueMetadata)->willReturn([$defaultTransformer, []]);
     $columnInfoSku->getLocale()->willReturn(null);
     $columnInfoSku->getScope()->willReturn(null);
     $columnInfoDesc->getLocale()->willReturn('en_US');
     $columnInfoDesc->getScope()->willReturn('mobile');
     $product->getValue('sku', null, null)->willReturn($valueSku);
     $product->getValue('description', 'de_DE', 'mobile')->willReturn($valueDesc);
     // set variant group values
     $product->getVariantGroup()->willReturn($variantGroup);
     $variantGroup->getProductTemplate()->willReturn($productTemplate);
     $templateUpdater->update($productTemplate, [$product])->shouldBeCalled();
     // set associations
     $product->getReference()->willReturn('AKNTS');
     $associationReader->addItem(['association_type' => 'SUBSTITUTION', 'owner' => 'AKNTS', 'products' => 'AKNTS_WPS,AKNTS_PBS,AKNTS_PWS'])->shouldBeCalled();
     $this->transform('Pim\\Bundle\\CatalogBundle\\Model\\Product', ['sku' => 'AKNTS', 'family' => 'tshirts', 'groups' => 'akeneo_tshirt', 'categories' => 'tshirts,goodies', 'SUBSTITUTION-groups' => '', 'SUBSTITUTION-products' => 'AKNTS_WPS,AKNTS_PBS,AKNTS_PWS', 'description-en_US-mobile' => '<p>Akeneo T-Shirt</p>']);
 }

 /**
  * @param string $code
  *
  * @return string
  */
 public function getAttributeLabelFromCode($code)
 {
     if (null !== ($attribute = $this->attributeRepository->findOneByIdentifier($code))) {
         return (string) $attribute;
     }
     return $code;
 }

 /**
  * {@inheritdoc}
  */
 public function transform($model)
 {
     if (null === $model) {
         return null;
     }
     if (count($this->repository->getIdentifierProperties()) > 1) {
         throw new \InvalidArgumentException('Cannot transform object with multiple identifiers');
     }
     $identifierProperty = $this->repository->getIdentifierProperties()[0];
     $propertyAccessor = PropertyAccess::createPropertyAccessor();
     if ($this->multiple) {
         if (!is_array($model)) {
             throw new UnexpectedTypeException($model, 'array');
         }
         $identifiers = [];
         foreach ($model as $object) {
             $identifiers[] = $propertyAccessor->getValue($object, $identifierProperty);
         }
         return $identifiers;
     }
     if (!is_object($model)) {
         throw new UnexpectedTypeException($model, 'object');
     }
     return $propertyAccessor->getValue($model, $identifierProperty);
 }

 /**
  * Find a variant group by its id or return a 404 response
  *
  * @param string $code
  *
  * @throws NotFoundHttpException
  *
  * @return GroupInterface
  */
 protected function findVariantGroupOr404($code)
 {
     $group = $this->groupRepository->findOneByIdentifier($code);
     if (null === $group || false === $group->getType()->isVariant()) {
         throw new NotFoundHttpException(sprintf('Variant group with id %d could not be found.', $id));
     }
     return $group;
 }

 /**
  * {@inheritdoc}
  *
  * Expected data input format : "family_code"
  */
 public function setFieldData(ProductInterface $product, $field, $data, array $options = [])
 {
     $this->checkData($field, $data);
     if (null !== $data) {
         $family = $this->familyRepository->findOneByIdentifier($data);
         if (null === $family) {
             throw InvalidArgumentException::expected($field, 'existing family code', 'setter', 'family', $data);
         }
         $product->setFamily($family);
     } else {
         $product->setFamily(null);
     }
 }

 /**
  * {@inheritdoc}
  *
  * Expected data input format : ["category_code", "another_category_code"]
  */
 public function removeFieldData(ProductInterface $product, $field, $data, array $options = [])
 {
     $this->checkData($field, $data);
     $categories = [];
     foreach ($data as $categoryCode) {
         $category = $this->categoryRepository->findOneByIdentifier($categoryCode);
         if (null === $category) {
             throw InvalidArgumentException::expected($field, 'existing category code', 'remover', 'category', $categoryCode);
         }
         $categories[] = $category;
     }
     foreach ($categories as $categoryToRemove) {
         $product->removeCategory($categoryToRemove);
     }
 }

 /**
  * @param string $code
  *
  * @return Group|null
  */
 protected function findGroup($code)
 {
     $group = $this->groupRepository->findOneByIdentifier($code);
     if (null === $group) {
         throw new \InvalidArgumentException(sprintf('Group %s was not found', $code));
     }
     return $group;
 }

 /**
  * {@inheritdoc}
  */
 public function sort(array $columns, array $context = [])
 {
     $identifier = $this->productRepository->getIdentifierProperties()[0];
     if (isset($context['filters']['structure']['attributes']) && !empty($context['filters']['structure']['attributes'])) {
         $rawColumns = array_merge([$identifier], $this->firstDefaultColumns, array_map(function ($associationType) {
             return $associationType->getCode();
         }, $this->associationTypeRepository->findAll()), $context['filters']['structure']['attributes']);
         $sortedColumns = [];
         foreach ($rawColumns as $columnCode) {
             $sortedColumns = array_merge($sortedColumns, array_filter($columns, function ($columnCandidate) use($columnCode) {
                 return 0 !== preg_match(sprintf('/^%s(-.*)*/', $columnCode), $columnCandidate);
             }));
         }
         return $sortedColumns;
     }
     array_unshift($this->firstDefaultColumns, $identifier);
     return parent::sort($columns);
 }

 /**
  * {@inheritdoc}
  *
  * Expected data input format : ["group_code"]
  */
 public function addFieldData(ProductInterface $product, $field, $data, array $options = [])
 {
     $this->checkData($field, $data);
     $groups = [];
     foreach ($data as $groupCode) {
         $group = $this->groupRepository->findOneByIdentifier($groupCode);
         if (null === $group) {
             throw InvalidArgumentException::expected($field, 'existing group code', 'adder', 'groups', $groupCode);
         } elseif ($group->getType()->isVariant()) {
             throw InvalidArgumentException::expected($field, 'non variant group code', 'adder', 'groups', $groupCode);
         } else {
             $groups[] = $group;
         }
     }
     foreach ($groups as $group) {
         $product->addGroup($group);
     }
 }

 /**
  * @param array $configuration
  */
 public function execute(array $configuration)
 {
     $actions = $configuration['actions'];
     $variantGroupCode = $actions['value'];
     $variantGroup = $this->groupRepository->findOneByIdentifier($variantGroupCode);
     $axisAttributeCodes = $this->getAxisAttributeCodes($variantGroup);
     $eligibleProductIds = $this->productRepository->getEligibleProductIdsForVariantGroup($variantGroup->getId());
     $cursor = $this->getProductsCursor($configuration['filters']);
     $paginator = $this->paginatorFactory->createPaginator($cursor);
     list($productAttributeAxis, $acceptedIds) = $this->filterDuplicateAxisCombinations($paginator, $eligibleProductIds, $axisAttributeCodes);
     $excludedIds = $this->addSkippedMessageForDuplicatedProducts($productAttributeAxis);
     $acceptedIds = array_diff($acceptedIds, $excludedIds);
     $configuration['filters'] = [['field' => 'id', 'operator' => 'IN', 'value' => $acceptedIds]];
     if (0 === count($acceptedIds)) {
         $configuration = null;
     }
     $this->setJobConfiguration(json_encode($configuration));
 }

 /**
  * @param AssociationInterface $association
  * @param array                $groupsCodes
  */
 protected function setAssociatedGroups(AssociationInterface $association, $groupsCodes)
 {
     foreach ($groupsCodes as $groupCode) {
         $associatedGroup = $this->groupRepository->findOneByIdentifier($groupCode);
         if (!$associatedGroup) {
             throw InvalidArgumentException::expected('associations', 'existing group code', 'setter', 'association', $groupCode);
         }
         $association->addGroup($associatedGroup);
     }
 }

 /**
  * {@inheritdoc}
  *
  * Expected data input format : ["group_code"]
  */
 public function setFieldData(ProductInterface $product, $field, $data, array $options = [])
 {
     $this->checkData($field, $data);
     $groups = [];
     foreach ($data as $groupCode) {
         $group = $this->groupRepository->findOneByIdentifier($groupCode);
         if (null === $group) {
             throw InvalidArgumentException::expected($field, 'existing group code', 'setter', 'groups', $groupCode);
         } else {
             $groups[] = $group;
         }
     }
     $oldGroups = $product->getGroups();
     foreach ($oldGroups as $group) {
         $product->removeGroup($group);
     }
     foreach ($groups as $group) {
         $product->addGroup($group);
     }
 }

 /**
  * @param ChannelInterface $channel
  * @param array            $localeCodes
  */
 protected function setLocales(ChannelInterface $channel, array $localeCodes)
 {
     $locales = [];
     foreach ($localeCodes as $localeCode) {
         $locale = $this->localeRepository->findOneByIdentifier($localeCode);
         if (null === $locale) {
             throw new \InvalidArgumentException(sprintf('Locale with "%s" code does not exist', $localeCode));
         }
         $locales[] = $locale;
     }
     $channel->setLocales($locales);
 }

 /**
  * {@inheritdoc}
  *
  * Expected data input format : "variant_group_code"
  */
 public function setFieldData(ProductInterface $product, $field, $data, array $options = [])
 {
     $this->checkData($field, $data);
     if (null !== $data) {
         $variantGroup = $this->groupRepository->findOneByIdentifier($data);
         if (null === $variantGroup) {
             throw InvalidArgumentException::expected($field, 'existing variant group code', 'setter', 'variant_group', $data);
         }
         if (!$variantGroup->getType()->isVariant()) {
             throw InvalidArgumentException::expected($field, 'variant group code', 'setter', 'variant_group', $data);
         }
     }
     $existingGroups = $product->getGroups();
     foreach ($existingGroups as $group) {
         if ($group->getType()->isVariant()) {
             $product->removeGroup($group);
         }
     }
     if (null !== $data) {
         $product->addGroup($variantGroup);
     }
 }

 /**
  * Clean the filters to keep only non duplicated.
  * This method send "skipped" message for every duplicated product for a variant group.
  *
  * When all the selected products are skipped, there is no remaining products to mass-edit. The standard behaviour
  * should return a single filter like "id IN ()", which is equivalent to "nothing", and it's it is very poorly
  * managed by Doctrine.
  * Instead of returning this filter, we return a "is IS NULL" filter, which in this case is completely
  * equivalent to "nothing" (there can not be null ids).
  *
  * @param StepExecution $stepExecution
  * @param array         $filters
  * @param array         $actions
  *
  * @return array
  */
 public function clean(StepExecution $stepExecution, $filters, $actions)
 {
     $variantGroupCode = $actions['value'];
     $variantGroup = $this->groupRepository->findOneByIdentifier($variantGroupCode);
     $axisAttributeCodes = $this->getAxisAttributeCodes($variantGroup);
     $eligibleProductIds = $this->productRepository->getEligibleProductIdsForVariantGroup($variantGroup->getId());
     $cursor = $this->getProductsCursor($filters);
     $paginator = $this->paginatorFactory->createPaginator($cursor);
     list($productAttributeAxis, $acceptedIds) = $this->filterDuplicateAxisCombinations($stepExecution, $paginator, $eligibleProductIds, $axisAttributeCodes);
     $excludedIds = $this->addSkippedMessageForDuplicatedProducts($stepExecution, $productAttributeAxis);
     $acceptedIds = array_diff($acceptedIds, $excludedIds);
     if (0 === count($acceptedIds)) {
         return [['field' => 'id', 'operator' => Operators::IN_LIST, 'value' => ['']]];
     }
     return [['field' => 'id', 'operator' => Operators::IN_LIST, 'value' => $acceptedIds]];
 }