function it_adds_missing_product_values_from_family_on_new_product($valuesResolver, FamilyInterface $family, ProductInterface $product, AttributeInterface $sku, AttributeInterface $name, AttributeInterface $desc, ProductValueInterface $skuValue)
{
$sku->getCode()->willReturn('sku');
$sku->getAttributeType()->willReturn('pim_catalog_identifier');
$sku->isLocalizable()->willReturn(false);
$sku->isScopable()->willReturn(false);
$name->getCode()->willReturn('name');
$name->getAttributeType()->willReturn('pim_catalog_text');
$name->isLocalizable()->willReturn(true);
$name->isScopable()->willReturn(false);
$desc->getCode()->willReturn('description');
$desc->getAttributeType()->willReturn('pim_catalog_text');
$desc->isLocalizable()->willReturn(true);
$desc->isScopable()->willReturn(true);
// get expected attributes
$product->getAttributes()->willReturn([$sku]);
$family->getAttributes()->willReturn([$sku, $name, $desc]);
$product->getFamily()->willReturn($family);
// get eligible values
$valuesResolver->resolveEligibleValues(['sku' => $sku, 'name' => $name, 'description' => $desc], null, null)->willReturn([['attribute' => 'sku', 'type' => 'pim_catalog_identifier', 'locale' => null, 'scope' => null], ['attribute' => 'name', 'type' => 'pim_catalog_text', 'locale' => 'fr_FR', 'scope' => null], ['attribute' => 'name', 'type' => 'pim_catalog_text', 'locale' => 'en_US', 'scope' => null], ['attribute' => 'description', 'type' => 'pim_catalog_text', 'locale' => 'en_US', 'scope' => 'ecommerce'], ['attribute' => 'description', 'type' => 'pim_catalog_text', 'locale' => 'fr_FR', 'scope' => 'ecommerce'], ['attribute' => 'description', 'type' => 'pim_catalog_text', 'locale' => 'en_US', 'scope' => 'print'], ['attribute' => 'description', 'type' => 'pim_catalog_text', 'locale' => 'fr_FR', 'scope' => 'print']]);
// get existing values
$skuValue->getAttribute()->willReturn($sku);
$skuValue->getLocale()->willReturn(null);
$skuValue->getScope()->willReturn(null);
$product->getValues()->willReturn([$skuValue]);
// add 6 new values : 4 desc (locales x scopes) + 2 name (locales
$product->addValue(Argument::any())->shouldBeCalledTimes(6);
$this->addMissingProductValues($product);
}
function it_provide_product_completeness_if_a_family_is_defined($familyRepository, $productValueCompleteChecker, QueryBuilder $qb, AbstractQuery $query, AttributeRequirementInterface $requirement, ProductInterface $product, ChannelInterface $mobile, LocaleInterface $en, FamilyInterface $shirt, CompletenessInterface $completeness, ProductValueInterface $nameValue, AttributeInterface $name)
{
$product->getFamily()->willReturn($shirt);
$product->getCompletenesses()->willReturn([$completeness]);
$en->getCode()->willReturn('en_US');
$mobile->getCode()->willReturn('mobile');
$completeness->getLocale()->willReturn($en);
$completeness->getChannel()->willReturn($mobile);
$completeness->getMissingCount()->willReturn(1);
$familyRepository->getFullRequirementsQB($shirt, 'en_US')->willReturn($qb);
$qb->getQuery()->willReturn($query);
$query->getResult()->willReturn([$requirement]);
$requirement->getChannel()->willReturn($mobile);
$requirement->getAttribute()->willReturn($name);
$requirement->isRequired()->willReturn(true);
$name->getCode()->willReturn('name');
$name->isLocalizable()->willreturn(true);
$name->isScopable()->willReturn(false);
$name->isLocaleSpecific()->willReturn(true);
$name->hasLocaleSpecific($en)->willReturn(false);
$product->getValues()->willReturn(new ArrayCollection());
$productValueCompleteChecker->supportsValue($nameValue);
$productValueCompleteChecker->isComplete($nameValue, $mobile, $en);
$this->getProductCompleteness($product, [$mobile], [$en], 'en_US')->shouldReturn([['channels' => [['completeness' => $completeness, 'missing' => []]], 'stats' => ['total' => 1, 'complete' => 0], 'locale' => 'en_US']]);
}
function it_normalizes_the_properties_of_the_product($filter, $serializer, ProductInterface $product, AttributeInterface $attribute, ProductValueInterface $value, FamilyInterface $family, ArrayCollection $values, \ArrayIterator $iterator, ProductValueInterface $identifier)
{
$values->getIterator()->willReturn($iterator);
$family->getCode()->willReturn('my_family');
$product->getFamily()->willReturn($family);
$product->getGroupCodes()->willReturn([]);
$product->getVariantGroup()->willReturn(null);
$product->getCategoryCodes()->willReturn([]);
$product->isEnabled()->willReturn(true);
$value->getAttribute()->willReturn($attribute);
$attribute->getCode()->willReturn('name');
$product->getIdentifier()->willReturn($identifier);
$identifier->getData()->willReturn('my_code');
$product->getValues()->willReturn($values);
$filter->filterCollection($values, 'pim.transform.product_value.structured', Argument::type('array'))->shouldBeCalled()->willReturn($values);
$iterator->rewind()->willReturn(null);
$valueCount = 1;
$iterator->valid()->will(function () use(&$valueCount) {
return $valueCount-- > 0;
});
$iterator->current()->willReturn($value);
$iterator->next()->willReturn(null);
$context = ['filter_types' => ['pim.transform.product_value.structured']];
$serializer->normalize($value, 'standard', $context)->willReturn(['locale' => null, 'scope' => null, 'value' => 'foo']);
$created = new \DateTime('2010-06-23');
$product->getCreated()->willReturn($created);
$serializer->normalize($created, 'standard')->willReturn('2010-06-23T00:00:00+01:00');
$updated = new \DateTime('2010-06-23 23:00:00');
$product->getUpdated()->willReturn($updated);
$serializer->normalize($updated, 'standard')->willReturn('2010-06-23T23:00:00+01:00');
$this->normalize($product, 'standard', $context)->shouldReturn(['identifier' => 'my_code', 'family' => 'my_family', 'groups' => [], 'variant_group' => null, 'categories' => [], 'enabled' => true, 'values' => ['name' => [['locale' => null, 'scope' => null, 'value' => 'foo']]], 'created' => '2010-06-23T00:00:00+01:00', 'updated' => '2010-06-23T23:00:00+01:00']);
}
function it_returns_flat_data_without_media(ChannelInterface $channel, ChannelManager $channelManager, ProductInterface $product, Serializer $serializer)
{
$product->getValues()->willReturn([]);
$this->setDecimalSeparator(',');
$serializer->normalize($product, 'flat', ['scopeCode' => 'foobar', 'localeCodes' => '', 'decimal_separator' => ',', 'date_format' => 'yyyy-MM-dd'])->willReturn(['normalized_product']);
$channelManager->getChannelByCode('foobar')->willReturn($channel);
$this->setChannel('foobar');
$this->process($product)->shouldReturn(['media' => [], 'product' => ['normalized_product']]);
}
function it_normalizes_constraint_violation(ConstraintViolationInterface $violation, ProductInterface $product, ProductValueInterface $productValue, AttributeInterface $attribute)
{
$product->getValues()->willReturn(['price' => $productValue]);
$productValue->getLocale()->willReturn(null);
$productValue->getScope()->willReturn(null);
$productValue->getAttribute()->willReturn($attribute);
$attribute->getCode()->willReturn('price');
$violation->getPropertyPath()->willReturn('values[price].float');
$violation->getMessage()->willReturn('The price should be above 10.');
$this->normalize($violation, 'internal_api', ['product' => $product])->shouldReturn(['attribute' => 'price', 'locale' => null, 'scope' => null, 'message' => 'The price should be above 10.']);
}
/**
* Converts metric values
*
* @param DocumentManager $dm
* @param ProductInterface $product
*/
protected function convertMetricValues(DocumentManager $dm, ProductInterface $product)
{
foreach ($product->getValues() as $value) {
$metric = $value->getData();
if ($metric instanceof MetricInterface && $metric->getUnit()) {
$this->createMetricBaseValues($metric);
if (null !== $metric->getId()) {
$metadata = $dm->getClassMetadata(ClassUtils::getClass($metric));
$dm->getUnitOfWork()->recomputeSingleDocumentChangeSet($metadata, $metric);
}
}
}
}
function it_normalizes_product(SerializerInterface $serializer, ProductInterface $product, FamilyInterface $family, Completeness $completeness)
{
$serializer->implement('Symfony\\Component\\Serializer\\Normalizer\\NormalizerInterface');
$this->setSerializer($serializer);
$product->getFamily()->willReturn($family);
$product->getGroups()->willReturn([]);
$product->getValues()->willReturn([]);
$product->getCompletenesses()->willReturn([$completeness]);
$product->getCreated()->willReturn(null);
$product->getUpdated()->willReturn(null);
$product->isEnabled()->willReturn(true);
$serializer->normalize($family, 'mongodb_json', [])->willReturn('family normalization');
$serializer->normalize($completeness, 'mongodb_json', [])->willReturn(['completenessCode' => 'completeness normalization']);
$this->normalize($product, 'mongodb_json', [])->shouldReturn([ProductNormalizer::FAMILY_FIELD => 'family normalization', ProductNormalizer::COMPLETENESSES_FIELD => array('completenessCode' => 'completeness normalization'), ProductNormalizer::ENABLED_FIELD => true]);
}
function it_does_not_convert_null_metric_values_in_the_channel($converter, ProductValueInterface $weightValue, AttributeInterface $weight, MetricInterface $weightMetric, ProductInterface $product, ChannelInterface $channel)
{
$weightValue->getAttribute()->willReturn($weight);
$weightValue->getData()->willReturn($weightMetric);
$weight->getCode()->willReturn('weight');
$weightMetric->getFamily()->willReturn('Weight');
$weightMetric->getUnit()->willReturn(null);
$weightMetric->getData()->willReturn(null);
$product->getValues()->willReturn(array($weightValue));
$channel->getConversionUnits()->willReturn(array('weight' => 'GRAM'));
$converter->setFamily('Weight')->shouldNotBeCalled();
$converter->convert('KILOGRAM', 'GRAM', 1)->shouldNotBeCalled();
$weightMetric->setData(null)->shouldNotBeCalled();
$weightMetric->setUnit('GRAM')->shouldNotBeCalled();
$this->convert($product, $channel);
}
/**
* Returns the required attribute codes for a product
*
* @param ProductInterface $product
*
* @return array
*/
public function getRequiredAttributeCodes(ProductInterface $product)
{
$codes = [];
if ($product->getFamily()) {
$codes = $this->getFamilyAttributeCodes($product->getFamily());
}
foreach ($product->getGroups() as $group) {
$codes = array_merge($codes, $this->getGroupAttributeCodes($group));
}
if ($product->getId()) {
foreach ($product->getValues() as $value) {
$codes[] = $value->getAttribute()->getCode();
}
}
return array_unique($codes);
}
/**
* Convert all the products metric values into the channel configured conversion units
*
* @param ProductInterface $product
* @param ChannelInterface $channel
*/
public function convert(ProductInterface $product, ChannelInterface $channel)
{
$channelUnits = $channel->getConversionUnits();
foreach ($product->getValues() as $value) {
$data = $value->getData();
$attribute = $value->getAttribute();
if ($data instanceof MetricInterface && isset($channelUnits[$attribute->getCode()])) {
if (null === $data->getData()) {
return;
}
$channelUnit = $channelUnits[$attribute->getCode()];
$this->converter->setFamily($data->getFamily());
$data->setData($this->converter->convert($data->getUnit(), $channelUnit, $data->getData()));
$data->setUnit($channelUnit);
}
}
}
function it_normalizes_the_properties_of_the_product(ProductInterface $product, AttributeInterface $attribute, ProductValueInterface $value, ArrayCollection $values, \ArrayIterator $iterator, $filter, $normalizer)
{
$values->getIterator()->willReturn($iterator);
$product->getFamily()->willReturn(null);
$product->getGroupCodes()->willReturn([]);
$product->getVariantGroup()->willReturn(null);
$product->getCategoryCodes()->willReturn([]);
$product->isEnabled()->willReturn(true);
$value->getAttribute()->willReturn($attribute);
$attribute->getCode()->willReturn('name');
$product->getValues()->willReturn($values);
$filter->filterCollection($values, 'pim.transform.product_value.structured', Argument::type('array'))->shouldBeCalled()->willReturn($values);
$iterator->rewind()->willReturn(null);
$valueCount = 1;
$iterator->valid()->will(function () use(&$valueCount) {
return $valueCount-- > 0;
});
$iterator->current()->willReturn($value);
$iterator->next()->willReturn(null);
$normalizer->normalize($values, 'json', Argument::any())->willReturn(['name' => [['locale' => null, 'scope' => null, 'value' => 'foo']]]);
$this->normalize($product, 'json')->shouldReturn(['family' => null, 'groups' => [], 'variant_group' => null, 'categories' => [], 'enabled' => true, 'values' => ['name' => [['locale' => null, 'scope' => null, 'value' => 'foo']]]]);
}
/**
* Fetch product media
*
* @param ProductInterface $product
*
* @return ProductMediaInterface[]
*/
protected function getProductMedias(ProductInterface $product)
{
$media = [];
foreach ($product->getValues() as $value) {
if (in_array($value->getAttribute()->getAttributeType(), [AttributeTypes::IMAGE, AttributeTypes::FILE])) {
$media[] = $value->getData();
}
}
return $media;
}
function it_returns_flat_data_with_french_attribute($channelManager, $serializer, ChannelInterface $channel, ProductInterface $product, ProductValueInterface $number, AttributeInterface $attribute, MetricInterface $metric, ProductValueInterface $metricValue, ProductPriceInterface $price, ProductValueInterface $priceValue)
{
$this->setLocale('fr_FR');
$attribute->getAttributeType()->willReturn('pim_catalog_number');
$number->getDecimal('10.50');
$number->getAttribute()->willReturn($attribute);
$attribute->getAttributeType()->willReturn('pim_catalog_metric');
$metric->getData()->willReturn('10.00');
$metric->getUnit()->willReturn('GRAM');
$metricValue->getAttribute()->willReturn($attribute);
$metricValue->getData()->willReturn($metric);
$attribute->getAttributeType()->willReturn('pim_catalog_price_collection');
$price->getData()->willReturn('10');
$price->getCurrency()->willReturn('EUR');
$priceValue->getAttribute()->willReturn($attribute);
$priceValue->getData()->willReturn($price);
$product->getValues()->willReturn([$number, $metricValue, $priceValue]);
$serializer->normalize($product, 'flat', ['scopeCode' => 'mobile', 'localeCodes' => '', 'locale' => 'fr_FR'])->willReturn(['10,50', '10,00 GRAM', '10,00 EUR', '25/10/2015']);
$channelManager->getChannelByCode('mobile')->willReturn($channel);
$this->setChannelCode('mobile');
$this->process($product)->shouldReturn(['media' => [], 'product' => ['10,50', '10,00 GRAM', '10,00 EUR', '25/10/2015']]);
}
function it_normalizes_product_with_price($filter, ProductInterface $product, AttributeInterface $priceAttribute, ProductValueInterface $price, Collection $prices, Collection $values, ProductPriceInterface $productPrice, FamilyInterface $family, SerializerInterface $serializer)
{
$family->getCode()->willReturn('shoes');
$priceAttribute->getCode()->willReturn('price');
$priceAttribute->getAttributeType()->willReturn('pim_catalog_price_collection');
$priceAttribute->isLocalizable()->willReturn(false);
$priceAttribute->isScopable()->willReturn(false);
$price->getAttribute()->willReturn($priceAttribute);
$price->getData()->willReturn(null);
$productPrice->getData()->willReturn("356.00");
$productPrice->getCurrency()->willReturn("EUR");
$prices->add($productPrice);
$price->getPrices()->willReturn($prices);
$product->getIdentifier()->willReturn($price);
$product->getFamily()->willReturn($family);
$product->isEnabled()->willReturn(true);
$product->getGroupCodes()->willReturn(['group1', 'group2', 'variant_group_1']);
$product->getCategoryCodes()->willReturn(['nice shoes', 'converse']);
$product->getAssociations()->willReturn([]);
$values->add($price);
$product->getValues()->willReturn($values);
$filter->filterCollection($values, 'pim.transform.product_value.flat', Argument::cetera())->willReturn([$price]);
$serializer->normalize($price, 'flat', Argument::any())->willReturn(['price-EUR' => '356.00']);
$this->normalize($product, 'flat', ['price-EUR' => ''])->shouldReturn(['price-EUR' => '356.00', 'family' => 'shoes', 'groups' => 'group1,group2,variant_group_1', 'categories' => 'nice shoes,converse', 'enabled' => 1]);
}
/**
* Returns an array containing all completeness info and missing attributes for a product
*
* @param ProductInterface $product
* @param \Pim\Bundle\CatalogBundle\Entity\ChannelInterface[] $channels
* @param \Pim\Bundle\CatalogBundle\Entity\LocaleInterface[] $locales
* @param string $localeCode
*
* @return array
*/
public function getProductCompleteness(ProductInterface $product, array $channels, array $locales, $localeCode)
{
$family = $product->getFamily();
$getCodes = function ($entities) {
return array_map(function ($entity) {
return $entity->getCode();
}, $entities);
};
$channelCodes = $getCodes($channels);
$localeCodes = $getCodes($locales);
$channelTemplate = ['channels' => array_fill_keys($channelCodes, ['completeness' => null, 'missing' => []]), 'stats' => ['total' => 0, 'complete' => 0]];
$completenesses = array_fill_keys($localeCodes, $channelTemplate);
if (!$family) {
return $completenesses;
}
$allCompletenesses = $product->getCompletenesses();
foreach ($allCompletenesses as $completeness) {
$locale = $completeness->getLocale();
$channel = $completeness->getChannel();
$compLocaleCode = $locale->getCode();
if (isset($completenesses[$compLocaleCode])) {
$completenesses[$compLocaleCode]['channels'][$channel->getCode()]['completeness'] = $completeness;
$completenesses[$compLocaleCode]['stats']['total']++;
if (0 === $completeness->getMissingCount()) {
$completenesses[$compLocaleCode]['stats']['complete']++;
}
}
}
$requirements = $this->familyRepository->getFullRequirementsQB($family, $localeCode)->getQuery()->getResult();
$productValues = $product->getValues();
foreach ($requirements as $requirement) {
if ($requirement->isRequired()) {
$this->addRequirementToCompleteness($completenesses, $requirement, $productValues, $locales);
}
}
return $completenesses;
}
/**
* Get filtered values
*
* @param ProductInterface $product
* @param array $context
*
* @return ProductValueInterface[]
*/
protected function getFilteredValues(ProductInterface $product, array $context = [])
{
if (null === $this->filter) {
return $product->getValues();
}
$values = $product->getValues();
foreach ($context['filter_types'] as $filterType) {
$values = $this->filter->filterCollection($values, $filterType, ['channels' => [$context['scopeCode']], 'locales' => $context['localeCodes']]);
}
return $values;
}
/**
* Returns completenesses filled
*
* @param array $completenesses
* @param ProductInterface $product
* @param array $locales
* @param string $localeCode
*
* @return array
*/
protected function fillCompletenessesTemplate(array $completenesses, ProductInterface $product, array $locales, $localeCode)
{
$allCompletenesses = $product->getCompletenesses();
foreach ($allCompletenesses as $completeness) {
$locale = $completeness->getLocale();
$channel = $completeness->getChannel();
$compLocaleCode = $locale->getCode();
if (isset($completenesses[$compLocaleCode])) {
$completenesses[$compLocaleCode]['channels'][$channel->getCode()]['completeness'] = $completeness;
$completenesses[$compLocaleCode]['locale'] = $compLocaleCode;
$completenesses[$compLocaleCode]['stats']['total']++;
if (0 === $completeness->getMissingCount()) {
$completenesses[$compLocaleCode]['stats']['complete']++;
}
}
}
$requirements = $this->familyRepository->getFullRequirementsQB($product->getFamily(), $localeCode)->getQuery()->getResult();
$productValues = $product->getValues();
foreach ($requirements as $requirement) {
if ($requirement->isRequired()) {
$this->addRequirementToCompleteness($completenesses, $requirement, $productValues, $locales);
}
}
return $completenesses;
}
/**
* Denormalize product values
*
* @param string $data
* @param string $format
* @param array $context
* @param ProductInterface $product
*/
protected function denormalizeValues($data, $format, array $context, ProductInterface $product)
{
foreach ($product->getValues() as $value) {
$product->removeValue($value);
}
foreach ($data as $attFieldName => $dataValue) {
$attributeInfos = $this->attFieldExtractor->extractColumnInfo($attFieldName);
$attribute = $attributeInfos['attribute'];
unset($attributeInfos['attribute']);
if (!$product->hasAttribute($attribute)) {
$this->productBuilder->addAttributeToProduct($product, $attribute);
}
// Denormalize data value.
// The value is already added to the product so automatically updated
$productValue = $product->getValue($attribute->getCode(), $attributeInfos['locale_code'], $attributeInfos['scope_code']);
$this->serializer->denormalize($dataValue, $this->productValueClass, $format, ['product' => $product, 'entity' => $productValue] + $attributeInfos + $context);
}
}
/**
* Transforms product violations into an array
*
* @param ConstraintViolationListInterface $violations
* @param ProductInterface $product
*
* @return array
*/
protected function transformViolations(ConstraintViolationListInterface $violations, ProductInterface $product)
{
$errors = [];
foreach ($violations as $violation) {
$path = $violation->getPropertyPath();
if (0 === strpos($path, 'values')) {
$codeStart = strpos($path, '[') + 1;
$codeLength = strpos($path, ']') - $codeStart;
$valueIndex = substr($path, $codeStart, $codeLength);
$value = $product->getValues()[$valueIndex];
$attributeCode = $value->getAttribute()->getCode();
$currentError = ['attribute' => $attributeCode, 'locale' => $value->getLocale(), 'scope' => $value->getScope(), 'message' => $violation->getMessage(), 'invalid_value' => $violation->getInvalidValue()];
$errors['values'][$attributeCode] = isset($errors['values'][$attributeCode]) ? $errors['values'][$attributeCode] : [];
$identicalErrors = array_filter($errors['values'][$attributeCode], function ($error) use($currentError) {
return isset($error['message']) && $error['message'] === $currentError['message'];
});
if (empty($identicalErrors)) {
$errors['values'][$attributeCode][] = $currentError;
}
} else {
$errors[$path] = ['message' => $violation->getMessage(), 'invalid_value' => $violation->getInvalidValue()];
}
}
return $errors;
}
/**
* Fetch medias product values
*
* @param ProductInterface $product
*
* @return ProductValueInterface[]
*/
protected function getMediaProductValues(ProductInterface $product)
{
$values = [];
foreach ($product->getValues() as $value) {
if (in_array($value->getAttribute()->getAttributeType(), $this->mediaAttributeTypes)) {
$values[] = $value;
}
}
return $values;
}
/**
* Add missing prices (a price per currency)
*
* @param ProductInterface $product the product
*/
protected function addMissingPricesToProduct(ProductInterface $product)
{
foreach ($product->getValues() as $value) {
$this->addMissingPrices($value);
}
}
/**
* Get filtered values
*
* @param ProductInterface $product
* @param array $context
*
* @return ProductValueInterface[]
*/
protected function getFilteredValues(ProductInterface $product, array $context = [])
{
if (null === $this->filter) {
return $product->getValues();
}
$values = $this->filter->filterCollection($product->getValues(), isset($context['filter_type']) ? $context['filter_type'] : 'pim.transform.product_value.flat', ['channels' => [$context['scopeCode']], 'locales' => $context['localeCodes']]);
return $values;
}
function it_normalizes_an_existing_product_without_family_into_mongodb_document($mongoFactory, $serializer, ProductInterface $product, \MongoId $mongoId, \MongoDate $mongoDate, Association $assoc1, Association $assoc2, CategoryInterface $category1, CategoryInterface $category2, GroupInterface $group1, GroupInterface $group2, ProductValueInterface $value1, ProductValueInterface $value2)
{
$mongoFactory->createMongoId('product1')->willReturn($mongoId);
$mongoFactory->createMongoDate()->willReturn($mongoDate);
$category1->getId()->willReturn(12);
$category2->getId()->willReturn(34);
$group1->getId()->willReturn(56);
$group2->getId()->willReturn(78);
$product->getId()->willReturn('product1');
$product->getCreated()->willReturn(null);
$product->getFamily()->willReturn(null);
$product->isEnabled()->willReturn(true);
$product->getGroups()->willReturn([$group1, $group2]);
$product->getCategories()->willReturn([$category1, $category2]);
$product->getAssociations()->willReturn([$assoc1, $assoc2]);
$product->getValues()->willReturn([$value1, $value2]);
$context = ['_id' => $mongoId];
$serializer->normalize($product, 'mongodb_json')->willReturn(['data' => 'data', 'completenesses' => 'completenesses']);
$serializer->normalize($value1, 'mongodb_document', $context)->willReturn('my_value_1');
$serializer->normalize($value2, 'mongodb_document', $context)->willReturn('my_value_2');
$serializer->normalize($assoc1, 'mongodb_document', $context)->willReturn('my_assoc_1');
$serializer->normalize($assoc2, 'mongodb_document', $context)->willReturn('my_assoc_2');
$this->normalize($product, 'mongodb_document')->shouldReturn(['_id' => $mongoId, 'created' => $mongoDate, 'updated' => $mongoDate, 'enabled' => true, 'groupIds' => [56, 78], 'categoryIds' => [12, 34], 'associations' => ['my_assoc_1', 'my_assoc_2'], 'values' => ['my_value_1', 'my_value_2'], 'normalizedData' => ['data' => 'data'], 'completenesses' => []]);
}
/**
* Fetch medias on the local filesystem
*
* @param ProductInterface $product
* @param string $directory
*/
protected function fetchMedia(ProductInterface $product, $directory)
{
$identifier = $product->getIdentifier()->getData();
$this->mediaFetcher->fetchAll($product->getValues(), $directory, $identifier);
foreach ($this->mediaFetcher->getErrors() as $error) {
$this->stepExecution->addWarning($error['message'], [], new DataInvalidItem($error['media']));
}
}
