/**
  * @param $parentsIds
  * @param $validationResult
  * @param $runValidateAmount
  * @param $result
  * @dataProvider dataProviderForValidateWithValidConfigurableProduct
  * @return void
  */
 public function testAroundValidateWithValidConfigurableProduct($parentsIds, $validationResult, $runValidateAmount, $result)
 {
     $closureMock = function () {
         return false;
     };
     $this->productMock->expects($this->once())->method('getId')->willReturn('product_id');
     $this->configurableMock->expects($this->once())->method('getParentIdsByChild')->with('product_id')->willReturn($parentsIds);
     $this->ruleMock->expects($this->exactly($runValidateAmount))->method('getConditions')->willReturn($this->ruleConditionsMock);
     $this->ruleConditionsMock->expects($this->exactly($runValidateAmount))->method('validateByEntityId')->willReturnMap($validationResult);
     $this->assertEquals($result, $this->validation->aroundValidate($this->ruleMock, $closureMock, $this->productMock));
 }
 /**
  * @param array $configurableIds
  * @param \Magento\CatalogRule\Model\Indexer\Product\ProductRuleIndexer $subject
  *
  * @return array
  */
 private function reindexSubProducts(array $configurableIds, \Magento\CatalogRule\Model\Indexer\Product\ProductRuleIndexer $subject)
 {
     $subProducts = [];
     if ($configurableIds) {
         $subProducts = array_values($this->configurable->getChildrenIds($configurableIds)[0]);
         if ($subProducts) {
             $subject->executeList($subProducts);
         }
     }
     return $subProducts;
 }
 /**
  * @param \Magento\Framework\Pricing\SaleableInterface|\Magento\Catalog\Model\Product $product
  * @return float
  * @throws \Magento\Framework\Exception\LocalizedException
  */
 public function resolvePrice(\Magento\Framework\Pricing\SaleableInterface $product)
 {
     $price = null;
     foreach ($this->configurable->getUsedProducts($product) as $subProduct) {
         $productPrice = $this->priceResolver->resolvePrice($subProduct);
         $price = $price ? min($price, $productPrice) : $productPrice;
     }
     if (!$price) {
         throw new \Magento\Framework\Exception\LocalizedException(__('Configurable product "%1" do not have sub-products', $product->getName()));
     }
     return (double) $price;
 }
 /**
  * {@inheritdoc}
  */
 public function getProducts(ProductInterface $product)
 {
     if (!isset($this->products[$product->getId()])) {
         if ($this->requestSafety->isSafeMethod()) {
             $productIds = $this->resource->getConnection()->fetchCol('(' . implode(') UNION (', $this->linkedProductSelectBuilder->build($product->getId())) . ')');
             $this->products[$product->getId()] = $this->collectionFactory->create()->addAttributeToSelect(['price', 'special_price'])->addIdFilter($productIds);
         } else {
             $this->products[$product->getId()] = $this->configurable->getUsedProducts($product);
         }
     }
     return $this->products[$product->getId()];
 }
Example #5
0
 /**
  * Preparing layout
  *
  * @return \Magento\ConfigurableProduct\Block\Product\Configurable\AssociatedSelector\Backend\Grid\ColumnSet
  */
 protected function _prepareLayout()
 {
     parent::_prepareLayout();
     $product = $this->getProduct();
     $attributes = $this->_productType->getUsedProductAttributes($product);
     foreach ($attributes as $attribute) {
         /** @var $attribute \Magento\Catalog\Model\Entity\Attribute */
         /** @var $block \Magento\Backend\Block\Widget\Grid\Column */
         $block = $this->addChild($attribute->getAttributeCode(), 'Magento\\Backend\\Block\\Widget\\Grid\\Column', array('header' => $attribute->getStoreLabel(), 'index' => $attribute->getAttributeCode(), 'type' => 'options', 'options' => $this->getOptions($attribute->getSource()), 'sortable' => false));
         $block->setId($attribute->getAttributeCode())->setGrid($this);
     }
     return $this;
 }
 /**
  * Prepare attribute set comprising all selected configurable attributes
  *
  * @param \Magento\Catalog\Model\Product $product
  *
  * @return void
  */
 protected function prepareAttributeSetToBeBaseForNewVariations(\Magento\Catalog\Model\Product $product)
 {
     $attributes = $this->configurableProduct->getUsedProductAttributes($product);
     $attributeSetId = $product->getNewVariationsAttributeSetId();
     /** @var $attributeSet \Magento\Eav\Model\Entity\Attribute\Set */
     $attributeSet = $this->attributeSetFactory->create()->load($attributeSetId);
     $attributeSet->addSetInfo($this->entityFactory->create()->setType(\Magento\Catalog\Model\Product::ENTITY)->getTypeId(), $attributes);
     foreach ($attributes as $attribute) {
         /* @var $attribute \Magento\Catalog\Model\Entity\Attribute */
         if (!$attribute->isInSet($attributeSetId)) {
             $attribute->setAttributeSetId($attributeSetId)->setAttributeGroupId($attributeSet->getDefaultGroupId($attributeSetId))->save();
         }
     }
 }
 /**
  * Create configurable product options
  *
  * @param array $attributesData
  * @return OptionInterface[]
  * @throws \InvalidArgumentException
  */
 public function create(array $attributesData)
 {
     $options = [];
     foreach ($attributesData as $item) {
         $attribute = $this->attributeFactory->create();
         $eavAttribute = $this->productAttributeRepository->get($item[Attribute::KEY_ATTRIBUTE_ID]);
         if (!$this->productType->canUseAttribute($eavAttribute)) {
             throw new \InvalidArgumentException('Provided attribute can not be used with configurable product.');
         }
         $this->updateAttributeData($attribute, $item);
         $options[] = $attribute;
     }
     return $options;
 }
 /**
  * @param \Magento\CatalogRule\Model\Rule $rule
  * @param \Closure $proceed
  * @param \Magento\Framework\DataObject|\Magento\Catalog\Model\Product $product
  * @return bool
  */
 public function aroundValidate(\Magento\CatalogRule\Model\Rule $rule, \Closure $proceed, \Magento\Framework\DataObject $product)
 {
     $validateResult = $proceed($product);
     if (!$validateResult && ($configurableProducts = $this->configurable->getParentIdsByChild($product->getId()))) {
         foreach ($configurableProducts as $configurableProductId) {
             $validateResult = $rule->getConditions()->validateByEntityId($configurableProductId);
             // If any of configurable product is valid for current rule, then their sub-product must be valid too
             if ($validateResult) {
                 break;
             }
         }
     }
     return $validateResult;
 }
Example #9
0
 /**
  * @inheritdoc
  */
 protected function prepareProduct($product, $data)
 {
     if ($this->attributeSet !== $data['attribute_set']) {
         $this->attributeSet = $data['attribute_set'];
         $this->eavConfig->clear();
     }
     if (empty($data['associated_product_ids'])) {
         $simpleIds = $this->configurableProductType->generateSimpleProducts($product, $data['variations_matrix']);
     } else {
         $simpleIds = $data['associated_product_ids'];
     }
     $product->setAssociatedProductIds($simpleIds);
     $product->setCanSaveConfigurableAttributes(true);
     return $this;
 }
 /**
  * @param \Magento\Framework\Pricing\SaleableInterface $product
  * @return float
  */
 public function resolvePrice(\Magento\Framework\Pricing\SaleableInterface $product)
 {
     $selectedConfigurableOption = $product->getSelectedConfigurableOption();
     if ($selectedConfigurableOption) {
         $price = $this->priceResolver->resolvePrice($selectedConfigurableOption);
     } else {
         $price = null;
         foreach ($this->configurable->getUsedProducts($product) as $subProduct) {
             $productPrice = $this->priceResolver->resolvePrice($subProduct);
             $price = $price ? min($price, $productPrice) : $productPrice;
         }
     }
     $priceInCurrentCurrency = $this->priceCurrency->convertAndRound($price);
     return $priceInCurrentCurrency ? (double) $priceInCurrentCurrency : false;
 }
 /**
  * @SuppressWarnings(PHPMD.ExcessiveMethodLength)
  */
 public function testGenerateSimpleProducts()
 {
     $productsData = [6 => ['image' => 'image.jpg', 'name' => 'config-red', 'configurable_attribute' => '{"new_attr":"6"}', 'sku' => 'config-red', 'quantity_and_stock_status' => ['qty' => ''], 'weight' => '333']];
     $stockData = ['manage_stock' => '0', 'use_config_enable_qty_increments' => '1', 'use_config_qty_increments' => '1', 'use_config_manage_stock' => 0, 'is_decimal_divided' => 0];
     $parentProductMock = $this->getMockBuilder('\\Magento\\Catalog\\Model\\Product')->setMethods(['__wakeup', 'getNewVariationsAttributeSetId', 'getStockData', 'getQuantityAndStockStatus', 'getWebsiteIds'])->disableOriginalConstructor()->getMock();
     $newSimpleProductMock = $this->getMockBuilder('\\Magento\\Catalog\\Model\\Product')->setMethods(['__wakeup', 'save', 'getId', 'setStoreId', 'setTypeId', 'setAttributeSetId', 'getTypeInstance', 'getStoreId', 'addData', 'setWebsiteIds', 'setStatus', 'setVisibility'])->disableOriginalConstructor()->getMock();
     $attributeMock = $this->getMockBuilder('\\Magento\\Eav\\Model\\Entity\\Attribute')->setMethods(['isInSet', 'setAttributeSetId', 'setAttributeGroupId', 'save'])->disableOriginalConstructor()->getMock();
     $attributeSetMock = $this->getMockBuilder('Magento\\Eav\\Model\\Entity\\Attribute\\Set')->setMethods(['load', 'addSetInfo', 'getDefaultGroupId'])->disableOriginalConstructor()->getMock();
     $eavEntityMock = $this->getMockBuilder('\\Magento\\Eav\\Model\\Entity')->setMethods(['setType', 'getTypeId'])->disableOriginalConstructor()->getMock();
     $productTypeMock = $this->getMockBuilder('Magento\\Catalog\\Model\\Product\\Type')->setMethods(['getSetAttributes'])->disableOriginalConstructor()->getMock();
     $editableAttributeMock = $this->getMockBuilder('Magento\\Eav\\Model\\Entity\\Attribute')->setMethods(['getIsUnique', 'getAttributeCode', 'getFrontend', 'getIsVisible'])->disableOriginalConstructor()->getMock();
     $frontendAttributeMock = $this->getMockBuilder('Magento\\Eav\\Model\\Entity\\Attribute\\Frontend')->setMethods(['getInputType'])->disableOriginalConstructor()->getMock();
     $this->configurableProduct->expects($this->once())->method('getUsedProductAttributes')->willReturn([$attributeMock]);
     $parentProductMock->expects($this->any())->method('getNewVariationsAttributeSetId')->willReturn('new_attr_set_id');
     $this->_attributeSetFactory->expects($this->once())->method('create')->willReturn($attributeSetMock);
     $attributeSetMock->expects($this->once())->method('load')->with('new_attr_set_id')->willReturnSelf();
     $this->_entityFactoryMock->expects($this->once())->method('create')->willReturn($eavEntityMock);
     $eavEntityMock->expects($this->once())->method('setType')->with('catalog_product')->willReturnSelf();
     $eavEntityMock->expects($this->once())->method('getTypeId')->willReturn('type_id');
     $attributeSetMock->expects($this->once())->method('addSetInfo')->with('type_id', [$attributeMock]);
     $attributeMock->expects($this->once())->method('isInSet')->with('new_attr_set_id')->willReturn(false);
     $attributeMock->expects($this->once())->method('setAttributeSetId')->with('new_attr_set_id')->willReturnSelf();
     $attributeSetMock->expects($this->once())->method('getDefaultGroupId')->with('new_attr_set_id')->willReturn('default_group_id');
     $attributeMock->expects($this->once())->method('setAttributeGroupId')->with('default_group_id')->willReturnSelf();
     $attributeMock->expects($this->once())->method('save')->willReturnSelf();
     $this->_productFactoryMock->expects($this->once())->method('create')->willReturn($newSimpleProductMock);
     $newSimpleProductMock->expects($this->once())->method('setStoreId')->with(0)->willReturnSelf();
     $newSimpleProductMock->expects($this->once())->method('setTypeId')->with('simple')->willReturnSelf();
     $newSimpleProductMock->expects($this->once())->method('setAttributeSetId')->with('new_attr_set_id')->willReturnSelf();
     $newSimpleProductMock->expects($this->once())->method('getTypeInstance')->willReturn($productTypeMock);
     $productTypeMock->expects($this->once())->method('getSetAttributes')->with($newSimpleProductMock)->willReturn([$editableAttributeMock]);
     $editableAttributeMock->expects($this->once())->method('getIsUnique')->willReturn(false);
     $editableAttributeMock->expects($this->once())->method('getAttributeCode')->willReturn('some_code');
     $editableAttributeMock->expects($this->any())->method('getFrontend')->willReturn($frontendAttributeMock);
     $frontendAttributeMock->expects($this->any())->method('getInputType')->willReturn('input_type');
     $editableAttributeMock->expects($this->any())->method('getIsVisible')->willReturn(false);
     $parentProductMock->expects($this->once())->method('getStockData')->willReturn($stockData);
     $parentProductMock->expects($this->once())->method('getQuantityAndStockStatus')->willReturn(['is_in_stock' => 1]);
     $newSimpleProductMock->expects($this->once())->method('getStoreId')->willReturn('store_id');
     $this->_stockConfiguration->expects($this->once())->method('getManageStock')->with('store_id')->willReturn(1);
     $newSimpleProductMock->expects($this->once())->method('addData')->willReturnSelf();
     $parentProductMock->expects($this->once())->method('getWebsiteIds')->willReturn('website_id');
     $newSimpleProductMock->expects($this->once())->method('setWebsiteIds')->with('website_id')->willReturnSelf();
     $newSimpleProductMock->expects($this->once())->method('setVisibility')->with(1)->willReturnSelf();
     $newSimpleProductMock->expects($this->once())->method('save')->willReturnSelf();
     $newSimpleProductMock->expects($this->once())->method('getId')->willReturn('product_id');
     $this->assertEquals(['product_id'], $this->_model->generateSimpleProducts($parentProductMock, $productsData));
 }
 private function validateConfigurable($product, $attributeSetId, $storeId)
 {
     $type = $product->getTypeInstance();
     //var_dump(\Magento\Store\Model\ScopeInterface::SCOPE_STORE);die();
     $auto = $this->scopeConfig->getValue('catalog/configurable_value/auto_create', \Magento\Store\Model\ScopeInterface::SCOPE_STORE);
     if (!$type instanceof Configurable) {
         return true;
     }
     $attributeSet = $this->attributeSetFactory->create()->load($attributeSetId);
     $attributes = $this->configurableProduct->getUsedProductAttributes($product);
     $attributeSet->addSetInfo($this->entityFactory->create()->setType(\Magento\Catalog\Model\Product::ENTITY)->getTypeId(), $attributes);
     foreach ($type->getConfigurableAttributes($product) as $configAattribute) {
         $attribute = $configAattribute->getProductAttribute();
         if (!is_null($attribute)) {
             //var_dump($attribute->isInSet($attributeSetId));die();
             if (!$attribute->isInSet($attributeSetId)) {
                 if ($auto) {
                     $attribute->setAttributeSetId($attributeSetId)->setAttributeGroupId($attributeSet->getDefaultGroupId($attributeSetId))->save();
                     return true;
                 } else {
                     $this->messageManager->addError(__('The configurable attribute ' . $attribute->getAttributeCode() . ' is not available in the targeted attribute set. Please create it first! Or allow create it from global config Catalog->Change Attribte Set'));
                     return false;
                 }
             } else {
                 return true;
             }
         }
     }
 }
Example #13
0
 protected function getAttributesFromConfigurable()
 {
     $this->productMock->expects($this->atLeastOnce())->method('getTypeInstance')->willReturn($this->configurableMock);
     $confAttribute = $this->getMock('\\Magento\\ConfigurableProduct\\Model\\Product\\Type\\Configurable\\Attribute', [], [], '', false);
     $this->configurableMock->expects($this->any())->method('getConfigurableAttributes')->with($this->productMock)->willReturn([$confAttribute, $confAttribute]);
     $confAttribute->expects($this->any())->method('__call')->with('getProductAttribute')->willReturn($this->attributeMock);
 }
Example #14
0
 /**
  * {@inheritdoc}
  */
 public function getUsedProductCollection($product = null)
 {
     $collection = parent::getUsedProductCollection($product);
     if (!is_null($this->getStoreFilter($product))) {
         $collection->setStoreId($this->getStoreFilter($product));
     }
     return $collection;
 }
Example #15
0
 /**
  * Select one of the options and "prepare for cart" with a proper buy request
  */
 protected function _prepareForCart()
 {
     $attributes = $this->_model->getConfigurableAttributesAsArray($this->_product);
     $attribute = reset($attributes);
     $optionValueId = $attribute['values'][0]['value_index'];
     $buyRequest = new \Magento\Framework\Object(['qty' => 5, 'super_attribute' => [$attribute['attribute_id'] => $optionValueId]]);
     $this->_model->prepareForCart($buyRequest, $this->_product);
 }
Example #16
0
 /**
  * @covers \Magento\ConfigurableProduct\Helper\Product\Options\Loader::load
  */
 public function testLoad()
 {
     $option = ['value_index' => 23];
     $this->product->expects(static::once())->method('getTypeInstance')->willReturn($this->configurable);
     $attribute = $this->getMockBuilder(Attribute::class)->disableOriginalConstructor()->setMethods(['getOptions', 'setValues'])->getMock();
     $attributes = [$attribute];
     $iterator = $this->getMockBuilder(Collection::class)->disableOriginalConstructor()->getMock();
     $iterator->expects($this->once())->method('getIterator')->willReturn(new \ArrayIterator($attributes));
     $this->configurable->expects(static::once())->method('getConfigurableAttributeCollection')->with($this->product)->willReturn($iterator);
     $attribute->expects(static::once())->method('getOptions')->willReturn([$option]);
     $optionValue = $this->getMockForAbstractClass(OptionValueInterface::class);
     $this->optionValueFactory->expects(static::once())->method('create')->willReturn($optionValue);
     $optionValue->expects(static::once())->method('setValueIndex')->with($option['value_index']);
     $attribute->expects(static::once())->method('setValues')->with([$optionValue]);
     $options = $this->loader->load($this->product);
     static::assertSame([$attribute], $options);
 }
Example #17
0
 /**
  * Prepare form before rendering HTML
  *
  * @return $this
  */
 protected function _prepareForm()
 {
     /** @var \Magento\Framework\Data\Form $form */
     $form = $this->_formFactory->create();
     $fieldset = $form->addFieldset('settings', ['legend' => __('Select Configurable Attributes')]);
     $fieldset->addField('configurable-attribute-selector', 'text', ['label' => 'Select Attribute', 'title' => 'Select Attribute']);
     $product = $this->getProduct();
     $usedAttributes = $product->getTypeId() == Configurable::TYPE_CODE ? $this->_configurableType->getUsedProductAttributes($product) : [];
     foreach ($usedAttributes as $attribute) {
         /** @var $attribute \Magento\Catalog\Model\Resource\Eav\Attribute */
         if ($this->_configurableType->canUseAttribute($attribute, $product)) {
             $fieldset->addField('attribute_' . $attribute->getAttributeId(), 'checkbox', ['label' => $attribute->getFrontendLabel(), 'title' => $attribute->getFrontendLabel(), 'name' => 'attributes[]', 'class' => 'configurable-attribute-checkbox', 'value' => $attribute->getAttributeId(), 'checked' => true]);
         }
     }
     $fieldset->addField('continue_button', 'note', ['text' => $this->getChildHtml('continue_button')]);
     $this->setForm($form);
     return parent::_prepareForm();
 }
Example #18
0
 /**
  * Initialize data for configurable product
  *
  * @param \Magento\Catalog\Controller\Adminhtml\Product\Initialization\Helper $subject
  * @param \Magento\Catalog\Model\Product $product
  *
  * @return \Magento\Catalog\Model\Product
  * @SuppressWarnings(PHPMD.UnusedFormalParameter)
  */
 public function afterInitialize(\Magento\Catalog\Controller\Adminhtml\Product\Initialization\Helper $subject, \Magento\Catalog\Model\Product $product)
 {
     $attributes = $this->request->getParam('attributes');
     if ($product->getTypeId() == ConfigurableProduct::TYPE_CODE && !empty($attributes)) {
         $setId = $this->request->getPost('new-variations-attribute-set-id');
         $product->setAttributeSetId($setId);
         $this->productType->setUsedProductAttributeIds($attributes, $product);
         $product->setNewVariationsAttributeSetId($setId);
         $associatedProductIds = $this->request->getPost('associated_product_ids', []);
         $variationsMatrix = $this->request->getParam('variations-matrix', []);
         if (!empty($variationsMatrix)) {
             $generatedProductIds = $this->variationHandler->generateSimpleProducts($product, $variationsMatrix);
             $associatedProductIds = array_merge($associatedProductIds, $generatedProductIds);
         }
         $product->setAssociatedProductIds(array_filter($associatedProductIds));
         $product->setCanSaveConfigurableAttributes((bool) $this->request->getPost('affect_configurable_product_attributes'));
     }
     return $product;
 }
 public function testCanUseAttribute()
 {
     $attribute = $this->getMock('Magento\\Catalog\\Model\\Resource\\Eav\\Attribute', array('getIsGlobal', 'getIsVisible', 'getIsConfigurable', 'usesSource', 'getIsUserDefined', '__wakeup', '__sleep'), array(), '', false);
     $attribute->expects($this->once())->method('getIsGlobal')->will($this->returnValue(1));
     $attribute->expects($this->once())->method('getIsVisible')->will($this->returnValue(1));
     $attribute->expects($this->once())->method('getIsConfigurable')->will($this->returnValue(1));
     $attribute->expects($this->once())->method('usesSource')->will($this->returnValue(1));
     $attribute->expects($this->once())->method('getIsUserDefined')->will($this->returnValue(1));
     $this->assertTrue($this->_model->canUseAttribute($attribute));
 }
 /**
  * @expectedException \Magento\Framework\Exception\NoSuchEntityException
  */
 public function testRemoveNoSuchEntityException()
 {
     $productSku = 'productSku';
     $optionId = 3;
     $this->productRepositoryMock->expects($this->once())->method('get')->with($this->equalTo($productSku))->will($this->returnValue($this->productMock));
     $this->productMock->expects($this->once())->method('getTypeId')->will($this->returnValue(ConfigurableType::TYPE_CODE));
     $this->productTypeMock->expects($this->once())->method('getConfigurableAttributeCollection')->with($this->equalTo($this->productMock))->will($this->returnValue($this->attributeCollectionMock));
     $this->attributeCollectionMock->expects($this->once())->method('getItemById')->with($this->equalTo($optionId))->will($this->returnValue(null));
     $this->writeService->remove($productSku, $optionId);
 }
 /**
  * Select one of the options and "prepare for cart" with a proper buy request
  *
  * @return ProductInterface
  */
 protected function _prepareForCart()
 {
     $product = $this->productRepository->getById(1, true);
     $attributes = $this->model->getConfigurableAttributesAsArray($product);
     $attribute = reset($attributes);
     $optionValueId = $attribute['values'][0]['value_index'];
     $buyRequest = new \Magento\Framework\DataObject(['qty' => 5, 'super_attribute' => [$attribute['attribute_id'] => $optionValueId]]);
     $this->model->prepareForCart($buyRequest, $product);
     return $product;
 }
Example #22
0
 /**
  * {@inheritdoc}
  */
 public function deleteById($sku, $id)
 {
     $product = $this->getProduct($sku);
     $attributeCollection = $this->configurableType->getConfigurableAttributeCollection($product);
     /** @var \Magento\ConfigurableProduct\Model\Product\Type\Configurable\Attribute $option */
     $option = $attributeCollection->getItemById($id);
     if ($option === null) {
         throw new NoSuchEntityException(__('Requested option doesn\'t exist'));
     }
     return $this->delete($option);
 }
Example #23
0
 /**
  * {@inheritdoc}
  */
 public function remove($productSku, $optionId)
 {
     $product = $this->getProduct($productSku);
     $attributeCollection = $this->productType->getConfigurableAttributeCollection($product);
     /** @var \Magento\ConfigurableProduct\Model\Product\Type\Configurable\Attribute $option */
     $option = $attributeCollection->getItemById($optionId);
     if ($option === null) {
         throw new NoSuchEntityException('Requested option doesn\'t exist');
     }
     $option->delete();
     return true;
 }
Example #24
0
 /**
  * @expectedException \Magento\Framework\Exception\NoSuchEntityException
  */
 public function testRemoveChildInvalidChildSku()
 {
     $productSku = 'configurable';
     $childSku = 'simple_10';
     $this->product->expects($this->any())->method('getTypeId')->will($this->returnValue(\Magento\ConfigurableProduct\Model\Product\Type\Configurable::TYPE_CODE));
     $this->productRepository->expects($this->any())->method('get')->will($this->returnValue($this->product));
     $option = $this->getMockBuilder('\\Magento\\Catalog\\Model\\Product')->setMethods(['getSku', 'getId', '__wakeup'])->disableOriginalConstructor()->getMock();
     $option->expects($this->any())->method('getSku')->will($this->returnValue($childSku . '_invalid'));
     $option->expects($this->any())->method('getId')->will($this->returnValue(10));
     $this->productType->expects($this->once())->method('getUsedProducts')->will($this->returnValue([$option]));
     $this->service->removeChild($productSku, $childSku);
 }
Example #25
0
 public function testSetImageFromChildProduct()
 {
     $productMock = $this->getMockBuilder('\\Magento\\Catalog\\Model\\Product')->setMethods(['__wakeup', 'hasData', 'getData', 'setImage'])->disableOriginalConstructor()->getMock();
     $childProductMock = $this->getMockBuilder('\\Magento\\Catalog\\Model\\Product')->setMethods(['__wakeup', 'getData'])->disableOriginalConstructor()->getMock();
     $productMock->expects($this->at(0))->method('getData')->with('image')->willReturn('no_selection');
     $productMock->expects($this->at(1))->method('getData')->with('image')->willReturn('no_selection');
     $productMock->expects($this->once())->method('hasData')->with('_cache_instance_products')->willReturn(true);
     $productMock->expects($this->at(3))->method('getData')->with('_cache_instance_products')->willReturn([$childProductMock]);
     $childProductMock->expects($this->any())->method('getData')->with('image')->willReturn('image_data');
     $productMock->expects($this->once())->method('setImage')->with('image_data')->willReturnSelf();
     $this->_model->setImageFromChildProduct($productMock);
 }
 public function testPrepareAttributeSet()
 {
     $productMock = $this->getMockBuilder('\\Magento\\Catalog\\Model\\Product')->setMethods(['getNewVariationsAttributeSetId'])->disableOriginalConstructor()->getMock();
     $attributeMock = $this->getMockBuilder('\\Magento\\Eav\\Model\\Entity\\Attribute')->setMethods(['isInSet', 'setAttributeSetId', 'setAttributeGroupId', 'save'])->disableOriginalConstructor()->getMock();
     $attributeSetMock = $this->getMockBuilder('Magento\\Eav\\Model\\Entity\\Attribute\\Set')->setMethods(['load', 'addSetInfo', 'getDefaultGroupId'])->disableOriginalConstructor()->getMock();
     $eavEntityMock = $this->getMockBuilder('\\Magento\\Eav\\Model\\Entity')->setMethods(['setType', 'getTypeId'])->disableOriginalConstructor()->getMock();
     $productMock->expects($this->once())->method('getNewVariationsAttributeSetId')->willReturn('new_attr_set_id');
     $this->configurableProduct->expects($this->once())->method('getUsedProductAttributes')->with($productMock)->willReturn([$attributeMock]);
     $this->attributeSetFactory->expects($this->once())->method('create')->willReturn($attributeSetMock);
     $attributeSetMock->expects($this->once())->method('load')->with('new_attr_set_id')->willReturnSelf();
     $this->entityFactoryMock->expects($this->once())->method('create')->willReturn($eavEntityMock);
     $eavEntityMock->expects($this->once())->method('setType')->with('catalog_product')->willReturnSelf();
     $eavEntityMock->expects($this->once())->method('getTypeId')->willReturn('type_id');
     $attributeSetMock->expects($this->once())->method('addSetInfo')->with('type_id', [$attributeMock]);
     $attributeMock->expects($this->once())->method('isInSet')->with('new_attr_set_id')->willReturn(false);
     $attributeMock->expects($this->once())->method('setAttributeSetId')->with('new_attr_set_id')->willReturnSelf();
     $attributeSetMock->expects($this->once())->method('getDefaultGroupId')->with('new_attr_set_id')->willReturn('default_group_id');
     $attributeMock->expects($this->once())->method('setAttributeGroupId')->with('default_group_id')->willReturnSelf();
     $attributeMock->expects($this->once())->method('save')->willReturnSelf();
     $this->model->prepareAttributeSet($productMock);
 }
Example #27
0
 /**
  * @expectedException \Magento\Framework\Exception\NoSuchEntityException
  * @expectedExceptionMessage Requested option doesn't exist: 3
  */
 public function testGetNoSuchEntityException()
 {
     $productSku = 'oneSku';
     $optionId = 3;
     $this->productRepository->expects($this->once())->method('get')->with($this->equalTo($productSku))->will($this->returnValue($this->product));
     $this->product->expects($this->once())->method('getTypeId')->will($this->returnValue(ConfigurableType::TYPE_CODE));
     $this->productType->expects($this->once())->method('getConfigurableAttributeCollection')->with($this->equalTo($this->product))->will($this->returnValue($this->configurableAttributeCollection));
     $this->configurableAttributeCollection->expects($this->once())->method('addFieldToFilter')->with(self::ATTRIBUTE_ID_FIELD_NAME, $optionId)->will($this->returnSelf());
     $this->configurableAttributeCollection->expects($this->once())->method('getFirstItem')->will($this->returnValue($this->option));
     $this->option->expects($this->once())->method('getId')->will($this->returnValue(null));
     $this->attributeResource->expects($this->once())->method('getIdFieldName')->will($this->returnValue(self::ATTRIBUTE_ID_FIELD_NAME));
     $this->configurableAttributeCollection->expects($this->once())->method('getResource')->will($this->returnValue($this->attributeResource));
     $this->model->get($productSku, $optionId);
 }
Example #28
0
 /**
  * @param \Magento\Catalog\Controller\Adminhtml\Product\Builder $subject
  * @param callable $proceed
  * @param \Magento\Framework\App\RequestInterface $request
  *
  * @return \Magento\Catalog\Model\Product
  * @SuppressWarnings(PHPMD.UnusedFormalParameter)
  * @SuppressWarnings(PHPMD.CyclomaticComplexity)
  */
 public function aroundBuild(\Magento\Catalog\Controller\Adminhtml\Product\Builder $subject, \Closure $proceed, \Magento\Framework\App\RequestInterface $request)
 {
     $product = $proceed($request);
     if ($request->has('attributes')) {
         $attributes = $request->getParam('attributes');
         if (!empty($attributes)) {
             $product->setTypeId(\Magento\ConfigurableProduct\Model\Product\Type\Configurable::TYPE_CODE);
             $this->configurableType->setUsedProductAttributeIds($attributes, $product);
         } else {
             $product->setTypeId(\Magento\Catalog\Model\Product\Type::TYPE_SIMPLE);
         }
     }
     // Required attributes of simple product for configurable creation
     if ($request->getParam('popup') && ($requiredAttributes = $request->getParam('required'))) {
         $requiredAttributes = explode(",", $requiredAttributes);
         foreach ($product->getAttributes() as $attribute) {
             if (in_array($attribute->getId(), $requiredAttributes)) {
                 $attribute->setIsRequired(1);
             }
         }
     }
     if ($request->getParam('popup') && $request->getParam('product') && !is_array($request->getParam('product')) && $request->getParam('id', false) === false) {
         $configProduct = $this->productFactory->create();
         $configProduct->setStoreId(0)->load($request->getParam('product'))->setTypeId($request->getParam('type'));
         $data = [];
         foreach ($configProduct->getTypeInstance()->getEditableAttributes($configProduct) as $attribute) {
             /* @var $attribute \Magento\Catalog\Model\ResourceModel\Eav\Attribute */
             if (!$attribute->getIsUnique() && $attribute->getFrontend()->getInputType() != 'gallery' && $attribute->getAttributeCode() != 'required_options' && $attribute->getAttributeCode() != 'has_options' && $attribute->getAttributeCode() != $configProduct->getIdFieldName()) {
                 $data[$attribute->getAttributeCode()] = $configProduct->getData($attribute->getAttributeCode());
             }
         }
         $product->addData($data);
         $product->setWebsiteIds($configProduct->getWebsiteIds());
     }
     return $product;
 }
Example #29
0
 /**
  * Retrieve actual list of associated products (i.e. if product contains variations matrix form data
  * - previously saved in database relations are not considered)
  *
  * @return Product[]
  */
 protected function _getAssociatedProducts()
 {
     $product = $this->getProduct();
     $ids = $this->getProduct()->getAssociatedProductIds();
     if ($ids === null) {
         // form data overrides any relations stored in database
         return $this->_configurableType->getUsedProducts($product);
     }
     $products = [];
     foreach ($ids as $productId) {
         try {
             $products[] = $this->productRepository->getById($productId);
         } catch (NoSuchEntityException $e) {
             continue;
         }
     }
     return $products;
 }
Example #30
0
 /**
  * Retrieve actual list of associated products (i.e. if product contains variations matrix form data
  * - previously saved in database relations are not considered)
  *
  * @return Product[]
  */
 protected function _getAssociatedProducts()
 {
     $product = $this->getProduct();
     $ids = $this->getProduct()->getAssociatedProductIds();
     if ($ids === null) {
         // form data overrides any relations stored in database
         return $this->_configurableType->getUsedProducts($product);
     }
     $products = array();
     foreach ($ids as $productId) {
         /** @var $product Product */
         $product = $this->_productFactory->create()->load($productId);
         if ($product->getId()) {
             $products[] = $product;
         }
     }
     return $products;
 }