diff --git a/app/code/Magento/Catalog/Block/Product/ImageBuilder.php b/app/code/Magento/Catalog/Block/Product/ImageBuilder.php
index d47218db371420b420081d94596af421782a0991..04d30270cbb62b915b02f0a77102d8f7b87bdeb4 100644
--- a/app/code/Magento/Catalog/Block/Product/ImageBuilder.php
+++ b/app/code/Magento/Catalog/Block/Product/ImageBuilder.php
@@ -6,6 +6,7 @@
 namespace Magento\Catalog\Block\Product;
 
 use Magento\Catalog\Helper\ImageFactory as HelperFactory;
+use Magento\Catalog\Model\Product\Image\NotLoadInfoImageException;
 
 class ImageBuilder
 {
@@ -129,7 +130,11 @@ class ImageBuilder
             ? 'Magento_Catalog::product/image.phtml'
             : 'Magento_Catalog::product/image_with_borders.phtml';
 
-        $imagesize = $helper->getResizedImageInfo();
+        try {
+            $imagesize = $helper->getResizedImageInfo();
+        } catch (NotLoadInfoImageException $exception) {
+            $imagesize = [$helper->getWidth(), $helper->getHeight()];
+        }
 
         $data = [
             'data' => [
@@ -140,8 +145,8 @@ class ImageBuilder
                 'label' => $helper->getLabel(),
                 'ratio' =>  $this->getRatio($helper),
                 'custom_attributes' => $this->getCustomAttributes(),
-                'resized_image_width' => !empty($imagesize[0]) ? $imagesize[0] : $helper->getWidth(),
-                'resized_image_height' => !empty($imagesize[1]) ? $imagesize[1] : $helper->getHeight(),
+                'resized_image_width' => $imagesize[0],
+                'resized_image_height' => $imagesize[1],
             ],
         ];
 
diff --git a/app/code/Magento/Catalog/Model/Product/Image.php b/app/code/Magento/Catalog/Model/Product/Image.php
index abd28ed3bf1eced2b04fc0a7b4ade7875e73c5a1..91f589f9b5bd725b4a1042016497c8ea487f1f2f 100644
--- a/app/code/Magento/Catalog/Model/Product/Image.php
+++ b/app/code/Magento/Catalog/Model/Product/Image.php
@@ -5,6 +5,7 @@
  */
 namespace Magento\Catalog\Model\Product;
 
+use Magento\Catalog\Model\Product\Image\NotLoadInfoImageException;
 use Magento\Framework\App\Filesystem\DirectoryList;
 use Magento\Framework\App\ObjectManager;
 use Magento\Framework\Image as MagentoImage;
@@ -877,17 +878,26 @@ class Image extends \Magento\Framework\Model\AbstractModel
 
     /**
      * Return resized product image information
-     *
      * @return array
+     * @throws NotLoadInfoImageException
      */
     public function getResizedImageInfo()
     {
-        if ($this->isBaseFilePlaceholder() == true) {
-            $image = $this->imageAsset->getSourceFile();
-        } else {
-            $image = $this->imageAsset->getPath();
+        try {
+            if ($this->isBaseFilePlaceholder() == true) {
+                $image = $this->imageAsset->getSourceFile();
+            } else {
+                $image = $this->imageAsset->getPath();
+            }
+
+            $imageProperties = getimagesize($image);
+
+            return $imageProperties;
+        } finally {
+            if (empty($imageProperties)) {
+                throw new NotLoadInfoImageException(__('Can\'t get information about the picture: %1', $image));
+            }
         }
-        return getimagesize($image);
     }
 
     /**
diff --git a/app/code/Magento/Catalog/Model/Product/Image/NotLoadInfoImageException.php b/app/code/Magento/Catalog/Model/Product/Image/NotLoadInfoImageException.php
new file mode 100644
index 0000000000000000000000000000000000000000..0feec11c62a5931543c6f3f21cb2464add57527b
--- /dev/null
+++ b/app/code/Magento/Catalog/Model/Product/Image/NotLoadInfoImageException.php
@@ -0,0 +1,10 @@
+<?php
+/**
+ * Copyright © Magento, Inc. All rights reserved.
+ * See COPYING.txt for license details.
+ */
+namespace Magento\Catalog\Model\Product\Image;
+
+class NotLoadInfoImageException extends \Exception
+{
+}
diff --git a/app/code/Magento/Catalog/Ui/DataProvider/Product/Listing/Collector/Image.php b/app/code/Magento/Catalog/Ui/DataProvider/Product/Listing/Collector/Image.php
index 2fc9ef76aa00d30f416f786c9e45187c8e89774a..216bc16968fcbf05679a2bc777e825f2111cecd4 100644
--- a/app/code/Magento/Catalog/Ui/DataProvider/Product/Listing/Collector/Image.php
+++ b/app/code/Magento/Catalog/Ui/DataProvider/Product/Listing/Collector/Image.php
@@ -11,6 +11,7 @@ use Magento\Catalog\Api\Data\ProductRender\ImageInterface;
 use Magento\Catalog\Api\Data\ProductRender\ImageInterfaceFactory;
 use Magento\Catalog\Api\Data\ProductRenderInterface;
 use Magento\Catalog\Helper\ImageFactory;
+use Magento\Catalog\Model\Product\Image\NotLoadInfoImageException;
 use Magento\Catalog\Ui\DataProvider\Product\ProductRenderCollectorInterface;
 use Magento\Framework\App\State;
 use Magento\Framework\View\DesignInterface;
@@ -102,7 +103,12 @@ class Image implements ProductRenderCollectorInterface
                     [$this, "emulateImageCreating"],
                     [$product, $imageCode, (int) $productRender->getStoreId(), $image]
                 );
-            $resizedInfo = $helper->getResizedImageInfo();
+
+            try {
+                $resizedInfo = $helper->getResizedImageInfo();
+            } catch (NotLoadInfoImageException $exception) {
+                $resizedInfo = [$helper->getWidth(), $helper->getHeight()];
+            }
 
             $image->setCode($imageCode);
             $image->setHeight($helper->getHeight());
diff --git a/app/code/Magento/Checkout/Model/Cart.php b/app/code/Magento/Checkout/Model/Cart.php
index be5692a8948657b86c5ffdccc1781fb087238a74..c0ba9616754bbba4cfa2175d02ee32c96eeec0ca 100644
--- a/app/code/Magento/Checkout/Model/Cart.php
+++ b/app/code/Magento/Checkout/Model/Cart.php
@@ -13,9 +13,10 @@ use Magento\Framework\Exception\NoSuchEntityException;
 
 /**
  * Shopping cart model
+ *
  * @api
  * @SuppressWarnings(PHPMD.CouplingBetweenObjects)
- * @deprecated 100.1.0
+ * @deprecated 100.1.0 Use \Magento\Quote\Model\Quote instead
  */
 class Cart extends DataObject implements CartInterface
 {
diff --git a/app/code/Magento/Checkout/Model/Cart/CartInterface.php b/app/code/Magento/Checkout/Model/Cart/CartInterface.php
index 2f4b679381740ce06a188d0107aa8335fde92cbd..890e6a5012ea55dc24f7ba1d32180ad9e6e32100 100644
--- a/app/code/Magento/Checkout/Model/Cart/CartInterface.php
+++ b/app/code/Magento/Checkout/Model/Cart/CartInterface.php
@@ -12,7 +12,7 @@ use Magento\Quote\Model\Quote;
  *
  * @api
  * @author      Magento Core Team <core@magentocommerce.com>
- * @deprecated 100.1.0
+ * @deprecated 100.1.0 Use \Magento\Quote\Model\Quote instead
  */
 interface CartInterface
 {
diff --git a/app/code/Magento/Webapi/Controller/Rest/InputParamsResolver.php b/app/code/Magento/Webapi/Controller/Rest/InputParamsResolver.php
index 07d1b4e07fe9d702ce9b70262585a3eaa3200d28..fa89b7223a92e4c8883e95f6ccb91205c23d08f9 100644
--- a/app/code/Magento/Webapi/Controller/Rest/InputParamsResolver.php
+++ b/app/code/Magento/Webapi/Controller/Rest/InputParamsResolver.php
@@ -6,10 +6,10 @@
 
 namespace Magento\Webapi\Controller\Rest;
 
-use Magento\Framework\Webapi\ServiceInputProcessor;
 use Magento\Framework\Webapi\Rest\Request as RestRequest;
-use Magento\Webapi\Controller\Rest\Router;
+use Magento\Framework\Webapi\ServiceInputProcessor;
 use Magento\Webapi\Controller\Rest\Router\Route;
+use Magento\Webapi\Model\UrlDecoder;
 
 /**
  * This class is responsible for retrieving resolved input data
@@ -47,26 +47,32 @@ class InputParamsResolver
     private $requestValidator;
 
     /**
-     * Initialize dependencies
-     *
+     * @var UrlDecoder
+     */
+    private $urlDecoder;
+
+    /**
      * @param RestRequest $request
      * @param ParamsOverrider $paramsOverrider
      * @param ServiceInputProcessor $serviceInputProcessor
      * @param Router $router
      * @param RequestValidator $requestValidator
+     * @param UrlDecoder $urlDecoder
      */
     public function __construct(
         RestRequest $request,
         ParamsOverrider $paramsOverrider,
         ServiceInputProcessor $serviceInputProcessor,
         Router $router,
-        RequestValidator $requestValidator
+        RequestValidator $requestValidator,
+        UrlDecoder $urlDecoder = null
     ) {
         $this->request = $request;
         $this->paramsOverrider = $paramsOverrider;
         $this->serviceInputProcessor = $serviceInputProcessor;
         $this->router = $router;
         $this->requestValidator = $requestValidator;
+        $this->urlDecoder = $urlDecoder ?: \Magento\Framework\App\ObjectManager::getInstance()->get(UrlDecoder::class);
     }
 
     /**
@@ -97,6 +103,7 @@ class InputParamsResolver
             $inputData = $this->request->getRequestData();
         }
 
+        $inputData = $this->urlDecoder->decodeParams($inputData);
         $inputData = $this->paramsOverrider->override($inputData, $route->getParameters());
         $inputParams = $this->serviceInputProcessor->process($serviceClassName, $serviceMethodName, $inputData);
         return $inputParams;
diff --git a/app/code/Magento/Webapi/Controller/Soap/Request/Handler.php b/app/code/Magento/Webapi/Controller/Soap/Request/Handler.php
index 0e87805daf60ac96c1595967c1cd1fafa5347b5c..081b4c829475a19afbb31c05a9ebab9d7cd7bba8 100644
--- a/app/code/Magento/Webapi/Controller/Soap/Request/Handler.php
+++ b/app/code/Magento/Webapi/Controller/Soap/Request/Handler.php
@@ -17,6 +17,7 @@ use Magento\Framework\Webapi\Exception as WebapiException;
 use Magento\Webapi\Model\Soap\Config as SoapConfig;
 use Magento\Framework\Reflection\MethodsMap;
 use Magento\Webapi\Model\ServiceMetadata;
+use Magento\Webapi\Model\UrlDecoder;
 
 /**
  * Handler of requests to SOAP server.
@@ -70,8 +71,11 @@ class Handler
     protected $methodsMapProcessor;
 
     /**
-     * Initialize dependencies.
-     *
+     * @var UrlDecoder
+     */
+    private $urlDecoder;
+
+    /**
      * @param SoapRequest $request
      * @param \Magento\Framework\ObjectManagerInterface $objectManager
      * @param SoapConfig $apiConfig
@@ -80,6 +84,7 @@ class Handler
      * @param ServiceInputProcessor $serviceInputProcessor
      * @param DataObjectProcessor $dataObjectProcessor
      * @param MethodsMap $methodsMapProcessor
+     * @param UrlDecoder $urlDecoder
      */
     public function __construct(
         SoapRequest $request,
@@ -89,7 +94,8 @@ class Handler
         SimpleDataObjectConverter $dataObjectConverter,
         ServiceInputProcessor $serviceInputProcessor,
         DataObjectProcessor $dataObjectProcessor,
-        MethodsMap $methodsMapProcessor
+        MethodsMap $methodsMapProcessor,
+        UrlDecoder $urlDecoder = null
     ) {
         $this->_request = $request;
         $this->_objectManager = $objectManager;
@@ -99,6 +105,7 @@ class Handler
         $this->serviceInputProcessor = $serviceInputProcessor;
         $this->_dataObjectProcessor = $dataObjectProcessor;
         $this->methodsMapProcessor = $methodsMapProcessor;
+        $this->urlDecoder = $urlDecoder ?: \Magento\Framework\App\ObjectManager::getInstance()->get(UrlDecoder::class);
     }
 
     /**
@@ -150,6 +157,7 @@ class Handler
         /** SoapServer wraps parameters into array. Thus this wrapping should be removed to get access to parameters. */
         $arguments = reset($arguments);
         $arguments = $this->_dataObjectConverter->convertStdObjectToArray($arguments, true);
+        $arguments = $this->urlDecoder->decodeParams($arguments);
         return $this->serviceInputProcessor->process($serviceClass, $serviceMethod, $arguments);
     }
 
diff --git a/app/code/Magento/Webapi/Model/UrlDecoder.php b/app/code/Magento/Webapi/Model/UrlDecoder.php
new file mode 100644
index 0000000000000000000000000000000000000000..5a8ae37c607bfa169f1ce921dc12b05bdd488ece
--- /dev/null
+++ b/app/code/Magento/Webapi/Model/UrlDecoder.php
@@ -0,0 +1,35 @@
+<?php
+/**
+ * Copyright © Magento, Inc. All rights reserved.
+ * See COPYING.txt for license details.
+ */
+
+namespace Magento\Webapi\Model;
+
+/**
+ * Url decoder.
+ */
+class UrlDecoder
+{
+    /**
+     * Decode request params.
+     *
+     * @param array $params
+     *
+     * @return array
+     */
+    public function decodeParams(array $params)
+    {
+        foreach ($params as &$param) {
+            if (is_array($param)) {
+                $param = $this->decodeParams($param);
+            } else {
+                if ($param !== null && is_string($param)) {
+                    $param = rawurldecode($param);
+                }
+            }
+        }
+
+        return $params;
+    }
+}
diff --git a/app/code/Magento/Wishlist/CustomerData/Wishlist.php b/app/code/Magento/Wishlist/CustomerData/Wishlist.php
index a81b3d6537dfd204e8310470f9b8be077bac30c6..6933efc2aa5404127598aff85efdfddc44330112 100644
--- a/app/code/Magento/Wishlist/CustomerData/Wishlist.php
+++ b/app/code/Magento/Wishlist/CustomerData/Wishlist.php
@@ -5,6 +5,7 @@
  */
 namespace Magento\Wishlist\CustomerData;
 
+use Magento\Catalog\Model\Product\Image\NotLoadInfoImageException;
 use Magento\Customer\CustomerData\SectionSourceInterface;
 
 /**
@@ -154,15 +155,19 @@ class Wishlist implements SectionSourceInterface
             ? 'Magento_Catalog/product/image'
             : 'Magento_Catalog/product/image_with_borders';
 
-        $imagesize = $helper->getResizedImageInfo();
+        try {
+            $imagesize = $helper->getResizedImageInfo();
+        } catch (NotLoadInfoImageException $exception) {
+            $imagesize = [$helper->getWidth(), $helper->getHeight()];
+        }
 
         $width = $helper->getFrame()
             ? $helper->getWidth()
-            : (!empty($imagesize[0]) ? $imagesize[0] : $helper->getWidth());
+            : $imagesize[0];
 
         $height = $helper->getFrame()
             ? $helper->getHeight()
-            : (!empty($imagesize[1]) ? $imagesize[1] : $helper->getHeight());
+            : $imagesize[1];
 
         return [
             'template' => $template,
diff --git a/dev/tests/api-functional/testsuite/Magento/Catalog/Api/ProductRepositoryInterfaceTest.php b/dev/tests/api-functional/testsuite/Magento/Catalog/Api/ProductRepositoryInterfaceTest.php
index cb33edce3af39e6e4a11a9e55e56a1bd921e64ba..09f6362c833d4de773bc6702fc0f5a28c614b473 100644
--- a/dev/tests/api-functional/testsuite/Magento/Catalog/Api/ProductRepositoryInterfaceTest.php
+++ b/dev/tests/api-functional/testsuite/Magento/Catalog/Api/ProductRepositoryInterfaceTest.php
@@ -47,6 +47,15 @@ class ProductRepositoryInterfaceTest extends WebapiAbstract
             ProductInterface::TYPE_ID => 'simple',
             ProductInterface::PRICE => 10
         ],
+        [
+            ProductInterface::SKU => [
+                'rest' => 'sku%252fwith%252fslashes',
+                'soap' => 'sku%2fwith%2fslashes'
+            ],
+            ProductInterface::NAME => 'Simple Product with Sku with Slashes',
+            ProductInterface::TYPE_ID => 'simple',
+            ProductInterface::PRICE => 10
+        ],
     ];
 
     /**
@@ -135,6 +144,20 @@ class ProductRepositoryInterfaceTest extends WebapiAbstract
         ];
     }
 
+    /**
+     * @magentoApiDataFixture Magento/Catalog/_files/product_simple_sku_with_slash.php
+     */
+    public function testGetBySkuWithSlash()
+    {
+        $productData = $this->productData[2];
+        $response = $this->getProduct($productData[ProductInterface::SKU][TESTS_WEB_API_ADAPTER]);
+        $productData[ProductInterface::SKU] = rawurldecode($productData[ProductInterface::SKU]['soap']);
+        foreach ([ProductInterface::SKU, ProductInterface::NAME, ProductInterface::PRICE] as $key) {
+            $this->assertEquals($productData[$key], $response[$key]);
+        }
+        $this->assertEquals([1], $response[ProductInterface::EXTENSION_ATTRIBUTES_KEY]["website_ids"]);
+    }
+
     /**
      * Test removing association between product and website 1
      * @magentoApiDataFixture Magento/Catalog/_files/product_with_two_websites.php
diff --git a/dev/tests/api-functional/testsuite/Magento/CatalogInventory/Api/StockItemTest.php b/dev/tests/api-functional/testsuite/Magento/CatalogInventory/Api/StockItemTest.php
index 0d9f121ed77451aa62b3e63acf781eae29612cac..096baa269f3bdef5d85e26a17c193f15f86e5a9d 100644
--- a/dev/tests/api-functional/testsuite/Magento/CatalogInventory/Api/StockItemTest.php
+++ b/dev/tests/api-functional/testsuite/Magento/CatalogInventory/Api/StockItemTest.php
@@ -49,11 +49,12 @@ class StockItemTest extends WebapiAbstract
 
     /**
      * @param array $result
+     * @param string $productSku
+     *
      * @return array
      */
-    protected function getStockItemBySku($result)
+    protected function getStockItemBySku($result, $productSku)
     {
-        $productSku = 'simple1';
         $serviceInfo = [
             'rest' => [
                 'resourcePath' => self::RESOURCE_GET_PATH . "/$productSku",
@@ -69,6 +70,7 @@ class StockItemTest extends WebapiAbstract
         $apiResult = $this->_webApiCall($serviceInfo, $arguments);
         $result['item_id'] = $apiResult['item_id'];
         $this->assertEquals($result, array_intersect_key($apiResult, $result), 'The stock data does not match.');
+
         return $apiResult;
     }
 
@@ -76,15 +78,33 @@ class StockItemTest extends WebapiAbstract
      * @param array $newData
      * @param array $expectedResult
      * @param array $fixtureData
+     *
      * @magentoApiDataFixture Magento/Catalog/_files/multiple_products.php
      * @dataProvider saveStockItemBySkuWithWrongInputDataProvider
      */
     public function testStockItemPUTWithWrongInput($newData, $expectedResult, $fixtureData)
     {
-        $stockItemOld = $this->getStockItemBySku($fixtureData);
         $productSku = 'simple1';
+        $stockItemOld = $this->getStockItemBySku($fixtureData, $productSku);
         $itemId = $stockItemOld['item_id'];
 
+        $actualData = $this->updateStockItemBySku($productSku, $itemId, $newData);
+
+        $this->assertEquals($stockItemOld['item_id'], $actualData);
+
+        /** @var \Magento\CatalogInventory\Api\Data\StockItemInterfaceFactory $stockItemFactory */
+        $stockItemFactory = $this->objectManager
+            ->get(\Magento\CatalogInventory\Api\Data\StockItemInterfaceFactory::class);
+        $stockItem = $stockItemFactory->create();
+        /** @var \Magento\CatalogInventory\Model\ResourceModel\Stock\Item $stockItemResource */
+        $stockItemResource = $this->objectManager->get(\Magento\CatalogInventory\Model\ResourceModel\Stock\Item::class);
+        $stockItemResource->loadByProductId($stockItem, $stockItemOld['product_id'], $stockItemOld['stock_id']);
+        $expectedResult['item_id'] = $stockItem->getItemId();
+        $this->assertEquals($expectedResult, array_intersect_key($stockItem->getData(), $expectedResult));
+    }
+
+    private function updateStockItemBySku($productSku, $itemId, $newData)
+    {
         $resourcePath = str_replace([':productSku', ':itemId'], [$productSku, $itemId], self::RESOURCE_PUT_PATH);
 
         $serviceInfo = [
@@ -113,7 +133,124 @@ class StockItemTest extends WebapiAbstract
         $data = $stockItemDetailsDo->getData();
         $data['show_default_notification_message'] = false;
         $arguments = ['productSku' => $productSku, 'stockItem' => $data];
-        $this->assertEquals($stockItemOld['item_id'], $this->_webApiCall($serviceInfo, $arguments));
+
+        return $this->_webApiCall($serviceInfo, $arguments);
+    }
+
+    /**
+     * @return array
+     */
+    public function saveStockItemBySkuWithWrongInputDataProvider()
+    {
+        return [
+            [
+                [
+                    'item_id' => 222,
+                    'product_id' => 222,
+                    'stock_id' => 1,
+                    'qty' => '111.0000',
+                    'min_qty' => '0.0000',
+                    'use_config_min_qty' => 1,
+                    'is_qty_decimal' => 0,
+                    'backorders' => 0,
+                    'use_config_backorders' => 1,
+                    'min_sale_qty' => '1.0000',
+                    'use_config_min_sale_qty' => 1,
+                    'max_sale_qty' => '0.0000',
+                    'use_config_max_sale_qty' => 1,
+                    'is_in_stock' => 1,
+                    'low_stock_date' => '',
+                    'notify_stock_qty' => null,
+                    'use_config_notify_stock_qty' => 1,
+                    'manage_stock' => 0,
+                    'use_config_manage_stock' => 1,
+                    'stock_status_changed_auto' => 0,
+                    'use_config_qty_increments' => 1,
+                    'qty_increments' => '0.0000',
+                    'use_config_enable_qty_inc' => 1,
+                    'enable_qty_increments' => 0,
+                    'is_decimal_divided' => 0,
+                ],
+                [
+                    'item_id' => '1',
+                    'product_id' => '10',
+                    'stock_id' => '1',
+                    'qty' => '111.0000',
+                    'min_qty' => '0.0000',
+                    'use_config_min_qty' => '1',
+                    'is_qty_decimal' => '0',
+                    'backorders' => '0',
+                    'use_config_backorders' => '1',
+                    'min_sale_qty' => '1.0000',
+                    'use_config_min_sale_qty' => '1',
+                    'max_sale_qty' => '0.0000',
+                    'use_config_max_sale_qty' => '1',
+                    'is_in_stock' => '1',
+                    'low_stock_date' => null,
+                    'notify_stock_qty' => null,
+                    'use_config_notify_stock_qty' => '1',
+                    'manage_stock' => '0',
+                    'use_config_manage_stock' => '1',
+                    'stock_status_changed_auto' => '0',
+                    'use_config_qty_increments' => '1',
+                    'qty_increments' => '0.0000',
+                    'use_config_enable_qty_inc' => '1',
+                    'enable_qty_increments' => '0',
+                    'is_decimal_divided' => '0',
+                    'type_id' => 'simple',
+                ],
+                [
+                    'item_id' => 1,
+                    'product_id' => 10,
+                    'stock_id' => 1,
+                    'qty' => 100,
+                    'is_in_stock' => 1,
+                    'is_qty_decimal' => '',
+                    'show_default_notification_message' => '',
+                    'use_config_min_qty' => 1,
+                    'min_qty' => 0,
+                    'use_config_min_sale_qty' => 1,
+                    'min_sale_qty' => 1,
+                    'use_config_max_sale_qty' => 1,
+                    'max_sale_qty' => 10000,
+                    'use_config_backorders' => 1,
+                    'backorders' => 0,
+                    'use_config_notify_stock_qty' => 1,
+                    'notify_stock_qty' => 1,
+                    'use_config_qty_increments' => 1,
+                    'qty_increments' => 0,
+                    'use_config_enable_qty_inc' => 1,
+                    'enable_qty_increments' => '',
+                    'use_config_manage_stock' => 1,
+                    'manage_stock' => 1,
+                    'low_stock_date' => '',
+                    'is_decimal_divided' => '',
+                    'stock_status_changed_auto' => 0,
+                ],
+            ],
+        ];
+    }
+
+    /**
+     * @param array $newData
+     * @param array $expectedResult
+     * @param array $fixtureData
+     *
+     * @magentoApiDataFixture Magento/Catalog/_files/product_simple_sku_with_slash.php
+     * @dataProvider testUpdateStockItemBySkuDataProvider
+     */
+    public function testUpdateStockItemBySku($newData, $expectedResult, $fixtureData)
+    {
+        $productSku = [
+            'rest' => 'sku%252fwith%252fslashes',
+            'soap' => 'sku%2fwith%2fslashes'
+        ];
+        $stockItemOld = $this->getStockItemBySku($fixtureData, $productSku[TESTS_WEB_API_ADAPTER]);
+        $itemId = $stockItemOld['item_id'];
+
+        $actualData = $this->updateStockItemBySku($productSku[TESTS_WEB_API_ADAPTER], $itemId, $newData);
+
+        $this->assertEquals($stockItemOld['item_id'], $actualData);
 
         /** @var \Magento\CatalogInventory\Api\Data\StockItemInterfaceFactory $stockItemFactory */
         $stockItemFactory = $this->objectManager
@@ -126,10 +263,7 @@ class StockItemTest extends WebapiAbstract
         $this->assertEquals($expectedResult, array_intersect_key($stockItem->getData(), $expectedResult));
     }
 
-    /**
-     * @return array
-     */
-    public function saveStockItemBySkuWithWrongInputDataProvider()
+    public function testUpdateStockItemBySkuDataProvider()
     {
         return [
             [
@@ -162,7 +296,7 @@ class StockItemTest extends WebapiAbstract
                 ],
                 [
                     'item_id' => '1',
-                    'product_id' => '10',
+                    'product_id' => '1',
                     'stock_id' => '1',
                     'qty' => '111.0000',
                     'min_qty' => '0.0000',
@@ -190,7 +324,7 @@ class StockItemTest extends WebapiAbstract
                 ],
                 [
                     'item_id' => 1,
-                    'product_id' => 10,
+                    'product_id' => 1,
                     'stock_id' => 1,
                     'qty' => 100,
                     'is_in_stock' => 1,
diff --git a/dev/tests/api-functional/testsuite/Magento/CatalogInventory/Api/StockStatusTest.php b/dev/tests/api-functional/testsuite/Magento/CatalogInventory/Api/StockStatusTest.php
index c7e5736b3324cfbeeed461b12e038f06fadc1fc9..c3c80621f23489eda940408a9e97918a1e3945a0 100644
--- a/dev/tests/api-functional/testsuite/Magento/CatalogInventory/Api/StockStatusTest.php
+++ b/dev/tests/api-functional/testsuite/Magento/CatalogInventory/Api/StockStatusTest.php
@@ -3,6 +3,7 @@
  * Copyright © Magento, Inc. All rights reserved.
  * See COPYING.txt for license details.
  */
+
 namespace Magento\CatalogInventory\Api;
 
 use Magento\TestFramework\Helper\Bootstrap;
@@ -27,6 +28,14 @@ class StockStatusTest extends WebapiAbstract
         /** @var \Magento\Catalog\Model\Product $product */
         $product = $objectManager->get(\Magento\Catalog\Model\Product::class)->load(1);
         $expectedData = $product->getQuantityAndStockStatus();
+        $actualData = $this->getProductStockStatus($productSku);
+        $this->assertArrayHasKey('stock_item', $actualData);
+        $this->assertEquals($expectedData['is_in_stock'], $actualData['stock_item']['is_in_stock']);
+        $this->assertEquals($expectedData['qty'], $actualData['stock_item']['qty']);
+    }
+
+    private function getProductStockStatus($productSku)
+    {
         $serviceInfo = [
             'rest' => [
                 'resourcePath' => self::RESOURCE_PATH . "/$productSku",
@@ -41,6 +50,25 @@ class StockStatusTest extends WebapiAbstract
 
         $requestData = ['productSku' => $productSku];
         $actualData = $this->_webApiCall($serviceInfo, $requestData);
+
+        return $actualData;
+    }
+
+    /**
+     * @magentoApiDataFixture Magento/Catalog/_files/product_simple_sku_with_slash.php
+     */
+    public function testGetProductStockStatusBySkuWithSlashes()
+    {
+        $productSku = [
+            'rest' => 'sku%252fwith%252fslashes',
+            'soap' => 'sku%2fwith%2fslashes'
+        ];
+        $objectManager = Bootstrap::getObjectManager();
+
+        /** @var \Magento\Catalog\Model\Product $product */
+        $product = $objectManager->get(\Magento\Catalog\Model\Product::class)->load(1);
+        $expectedData = $product->getQuantityAndStockStatus();
+        $actualData = $this->getProductStockStatus($productSku[TESTS_WEB_API_ADAPTER]);
         $this->assertArrayHasKey('stock_item', $actualData);
         $this->assertEquals($expectedData['is_in_stock'], $actualData['stock_item']['is_in_stock']);
         $this->assertEquals($expectedData['qty'], $actualData['stock_item']['qty']);
diff --git a/dev/tests/integration/testsuite/Magento/Catalog/_files/product_simple_sku_with_slash.php b/dev/tests/integration/testsuite/Magento/Catalog/_files/product_simple_sku_with_slash.php
new file mode 100644
index 0000000000000000000000000000000000000000..271eda8a0ffce59e442398e4fd923261d28b5f9a
--- /dev/null
+++ b/dev/tests/integration/testsuite/Magento/Catalog/_files/product_simple_sku_with_slash.php
@@ -0,0 +1,41 @@
+<?php
+/**
+ * Copyright © Magento, Inc. All rights reserved.
+ * See COPYING.txt for license details.
+ */
+
+/** @var \Magento\TestFramework\ObjectManager $objectManager */
+$objectManager = \Magento\TestFramework\Helper\Bootstrap::getObjectManager();
+
+/** @var $product \Magento\Catalog\Model\Product */
+$product = $objectManager->create(\Magento\Catalog\Model\Product::class);
+$product->isObjectNew(true);
+$product->setTypeId(\Magento\Catalog\Model\Product\Type::TYPE_SIMPLE)
+    ->setId(1)
+    ->setAttributeSetId(4)
+    ->setWebsiteIds([1])
+    ->setName('Simple Product with Sku with Slashes')
+    ->setSku('sku/with/slashes')
+    ->setPrice(10)
+    ->setWeight(1)
+    ->setShortDescription("Short description")
+    ->setTaxClassId(0)
+    ->setDescription('Description with <b>html tag</b>')
+    ->setMetaTitle('meta title')
+    ->setMetaKeyword('meta keyword')
+    ->setMetaDescription('meta description')
+    ->setVisibility(\Magento\Catalog\Model\Product\Visibility::VISIBILITY_BOTH)
+    ->setStatus(\Magento\Catalog\Model\Product\Attribute\Source\Status::STATUS_ENABLED)
+    ->setStockData(
+        [
+            'use_config_manage_stock'   => 1,
+            'qty'                       => 100,
+            'is_qty_decimal'            => 0,
+            'is_in_stock'               => 1,
+        ]
+    )->setCanSaveCustomOptions(true)
+    ->setHasOptions(true);
+
+/** @var \Magento\Catalog\Api\ProductRepositoryInterface $productRepositoryFactory */
+$productRepository = $objectManager->create(\Magento\Catalog\Api\ProductRepositoryInterface::class);
+$productRepository->save($product);
diff --git a/dev/tests/integration/testsuite/Magento/Catalog/_files/product_simple_sku_with_slash_rollback.php b/dev/tests/integration/testsuite/Magento/Catalog/_files/product_simple_sku_with_slash_rollback.php
new file mode 100644
index 0000000000000000000000000000000000000000..9cd5adae1591535bf82cf853cfbfac0f5ae0f094
--- /dev/null
+++ b/dev/tests/integration/testsuite/Magento/Catalog/_files/product_simple_sku_with_slash_rollback.php
@@ -0,0 +1,24 @@
+<?php
+/**
+ * Copyright © Magento, Inc. All rights reserved.
+ * See COPYING.txt for license details.
+ */
+
+use Magento\Framework\Exception\NoSuchEntityException;
+
+/** @var \Magento\Framework\Registry $registry */
+$registry = \Magento\TestFramework\Helper\Bootstrap::getObjectManager()->get(\Magento\Framework\Registry::class);
+
+$registry->unregister('isSecureArea');
+$registry->register('isSecureArea', true);
+
+/** @var \Magento\Catalog\Api\ProductRepositoryInterface $productRepository */
+$productRepository = \Magento\TestFramework\Helper\Bootstrap::getObjectManager()
+    ->get(\Magento\Catalog\Api\ProductRepositoryInterface::class);
+try {
+    $product = $productRepository->get('sku/with/slashes', false, null, true);
+    $productRepository->delete($product);
+} catch (NoSuchEntityException $e) {
+}
+$registry->unregister('isSecureArea');
+$registry->register('isSecureArea', false);
diff --git a/dev/tests/integration/testsuite/Magento/Setup/Fixtures/FixtureModelTest.php b/dev/tests/integration/testsuite/Magento/Setup/Fixtures/FixtureModelTest.php
index 1320c5aa5844dba9ada101378b19b714bfeefd36..312f29898d709128b9e4b5fb15bd5169b1b75f32 100644
--- a/dev/tests/integration/testsuite/Magento/Setup/Fixtures/FixtureModelTest.php
+++ b/dev/tests/integration/testsuite/Magento/Setup/Fixtures/FixtureModelTest.php
@@ -118,7 +118,7 @@ class FixtureModelTest extends \Magento\TestFramework\Indexer\TestCase
 
         foreach ($this->entityAsserts as $entityAssert) {
             try {
-                $entityAssert->assert();
+                $this->assertTrue($entityAssert->assert());
             } catch (\AssertionError $assertionError) {
                 $this->assertTrue(false, $assertionError->getMessage());
             }
diff --git a/dev/tests/integration/testsuite/Magento/Setup/Fixtures/FixturesAsserts/BundleProductsAssert.php b/dev/tests/integration/testsuite/Magento/Setup/Fixtures/FixturesAsserts/BundleProductsAssert.php
index 496dc1b5c8e43b4960e633ab98a26c6e36675b57..ae8faab3897a55e88ff58b49f9aaf81f78f1f3c9 100644
--- a/dev/tests/integration/testsuite/Magento/Setup/Fixtures/FixturesAsserts/BundleProductsAssert.php
+++ b/dev/tests/integration/testsuite/Magento/Setup/Fixtures/FixturesAsserts/BundleProductsAssert.php
@@ -48,7 +48,7 @@ class BundleProductsAssert
     /**
      * Asserts that generated bundled products are valid
      *
-     * @return void
+     * @return bool
      * @throws \Magento\Framework\Exception\NoSuchEntityException
      * @throws \AssertionError
      */
@@ -74,5 +74,7 @@ class BundleProductsAssert
                 throw new \AssertionError('Bundle option product links amount is wrong');
             }
         }
+
+        return true;
     }
 }
diff --git a/dev/tests/integration/testsuite/Magento/Setup/Fixtures/FixturesAsserts/ConfigurableProductsAssert.php b/dev/tests/integration/testsuite/Magento/Setup/Fixtures/FixturesAsserts/ConfigurableProductsAssert.php
index b7463f48d4bffe22efba5e5d5dff801e0b93c8db..fce73b137763f8e8baa9e24c9bdafc358456ac60 100644
--- a/dev/tests/integration/testsuite/Magento/Setup/Fixtures/FixturesAsserts/ConfigurableProductsAssert.php
+++ b/dev/tests/integration/testsuite/Magento/Setup/Fixtures/FixturesAsserts/ConfigurableProductsAssert.php
@@ -46,7 +46,7 @@ class ConfigurableProductsAssert
     /**
      * Asserts that generated configurable products are valid
      *
-     * @return void
+     * @return bool
      * @throws \Magento\Framework\Exception\NoSuchEntityException
      * @throws \Magento\Framework\Exception\InputException
      * @throws \AssertionError
@@ -86,5 +86,7 @@ class ConfigurableProductsAssert
                 throw new \AssertionError('Configurable option values amount is wrong');
             }
         }
+
+        return true;
     }
 }
diff --git a/dev/tests/integration/testsuite/Magento/Setup/Fixtures/FixturesAsserts/ImagesAssert.php b/dev/tests/integration/testsuite/Magento/Setup/Fixtures/FixturesAsserts/ImagesAssert.php
index da868789962294cabd8d2b33cb5538405f663097..4c035b99ba7386f7f035cd5fe84e5b69a6752194 100644
--- a/dev/tests/integration/testsuite/Magento/Setup/Fixtures/FixturesAsserts/ImagesAssert.php
+++ b/dev/tests/integration/testsuite/Magento/Setup/Fixtures/FixturesAsserts/ImagesAssert.php
@@ -70,6 +70,7 @@ class ImagesAssert
     /**
      * Performs assertions over images
      *
+     * @return bool
      * @throws \AssertionError
      */
     public function assert()
@@ -82,6 +83,8 @@ class ImagesAssert
             $this->assertProductMediaAttributes($product);
             $this->assertProductImageExistsInFS($product);
         }
+
+        return true;
     }
 
     /**
diff --git a/dev/tests/integration/testsuite/Magento/Setup/Fixtures/FixturesAsserts/SimpleProductsAssert.php b/dev/tests/integration/testsuite/Magento/Setup/Fixtures/FixturesAsserts/SimpleProductsAssert.php
index f43622f13680b2244206ecb4354d2e02d2efaffc..d3e5d2226a87c61dde6d25c41aa9ef5eaace8421 100644
--- a/dev/tests/integration/testsuite/Magento/Setup/Fixtures/FixturesAsserts/SimpleProductsAssert.php
+++ b/dev/tests/integration/testsuite/Magento/Setup/Fixtures/FixturesAsserts/SimpleProductsAssert.php
@@ -43,7 +43,7 @@ class SimpleProductsAssert
     /**
      * Asserts that generated simple products are valid
      *
-     * @return void
+     * @return bool
      * @throws \Magento\Framework\Exception\NoSuchEntityException
      * @throws \AssertionError
      */
@@ -52,5 +52,7 @@ class SimpleProductsAssert
         $product = $this->productRepository->get(sprintf(SimpleProductsFixture::SKU_PATTERN, 1));
         $this->productAssert->assertProductsCount(SimpleProductsFixture::SKU_PATTERN, 2);
         $this->productAssert->assertProductType('simple', $product);
+
+        return true;
     }
 }
diff --git a/dev/tests/static/testsuite/Magento/Test/Integrity/_files/blacklist/exception_hierarchy.txt b/dev/tests/static/testsuite/Magento/Test/Integrity/_files/blacklist/exception_hierarchy.txt
index 6897f43a02b34f4cd9aeeefd77553a74448b6e8c..79f4cc280a15e3d1616dcb464efefb1d3e19073f 100644
--- a/dev/tests/static/testsuite/Magento/Test/Integrity/_files/blacklist/exception_hierarchy.txt
+++ b/dev/tests/static/testsuite/Magento/Test/Integrity/_files/blacklist/exception_hierarchy.txt
@@ -11,3 +11,4 @@
 \Magento\Framework\DB\FieldDataConversionException
 \Magento\Signifyd\Model\SignifydGateway\GatewayException
 \Magento\Signifyd\Model\SignifydGateway\ApiCallException
+\Magento\Catalog\Model\Product\Image\NotLoadInfoImageException
\ No newline at end of file
diff --git a/setup/performance-toolkit/README.md b/setup/performance-toolkit/README.md
index 0152f3f917ad30b58367d9d00fd578d577e30771..700f6cd0d775d4cd62a85a78892f203736b2a971 100644
--- a/setup/performance-toolkit/README.md
+++ b/setup/performance-toolkit/README.md
@@ -62,7 +62,7 @@ The following parameters can be passed to the `benchmark.jmx` scenario:
 | admin_user                                    | admin               | Admin backend user.                                                                      |
 | admin_password                                | 123123q             | Admin backend password.                                                                  |
 | customer_password                             | 123123q             | Storefront customer password.                                                            |
-| customers_page_size                           | 20                  | Page size for customers grid in Magento Admin.                                           |
+| customers_page_size                           | 50                  | Page size for customers grid in Magento Admin.                                           |
 | files_folder                                  | ./files/            | Path to various files that are used in scenario (`setup/performance-toolkit/files`).     |
 | loops                                         | 1                   | Number of loops to run.                                                                  |
 | frontendPoolUsers                             | 1                   | Total number of Frontend threads.                                                        |
diff --git a/setup/performance-toolkit/benchmark.jmx b/setup/performance-toolkit/benchmark.jmx
index 655b19760b958027886a4f5f75463f447d045857..154915cd3a4fcb7b9abd2bf5cb304625a50470a3 100644
--- a/setup/performance-toolkit/benchmark.jmx
+++ b/setup/performance-toolkit/benchmark.jmx
@@ -59,6 +59,11 @@
             <stringProp name="Argument.value">${__P(loops,1)}</stringProp>
             <stringProp name="Argument.metadata">=</stringProp>
           </elementProp>
+          <elementProp name="accountManagementPercentage" elementType="Argument">
+            <stringProp name="Argument.name">accountManagementPercentage</stringProp>
+            <stringProp name="Argument.value">${__P(accountManagementPercentage,0)}</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+          </elementProp>
           <elementProp name="addToCartByCustomerPercentage" elementType="Argument">
             <stringProp name="Argument.name">addToCartByCustomerPercentage</stringProp>
             <stringProp name="Argument.value">${__P(addToCartByCustomerPercentage,0)}</stringProp>
@@ -74,11 +79,6 @@
             <stringProp name="Argument.value">${__P(addToWishlistPercentage,2)}</stringProp>
             <stringProp name="Argument.metadata">=</stringProp>
           </elementProp>
-          <elementProp name="adminAccountManagementPercentage" elementType="Argument">
-            <stringProp name="Argument.name">adminAccountManagementPercentage</stringProp>
-            <stringProp name="Argument.value">${__P(adminAccountManagementPercentage,0)}</stringProp>
-            <stringProp name="Argument.metadata">=</stringProp>
-          </elementProp>
           <elementProp name="adminCMSManagementDelay" elementType="Argument">
             <stringProp name="Argument.name">adminCMSManagementDelay</stringProp>
             <stringProp name="Argument.value">${__P(adminCMSManagementDelay,0)}</stringProp>
@@ -224,9 +224,14 @@
             <stringProp name="Argument.value">${__P(apiOrderInvoiceShipmentSync,0)}</stringProp>
             <stringProp name="Argument.metadata">=</stringProp>
           </elementProp>
+          <elementProp name="apiPoolUsers" elementType="Argument">
+            <stringProp name="Argument.name">apiPoolUsers</stringProp>
+            <stringProp name="Argument.value">${__P(apiPoolUsers,0)}</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+          </elementProp>
           <elementProp name="apiProcessOrders" elementType="Argument">
             <stringProp name="Argument.name">apiProcessOrders</stringProp>
-            <stringProp name="Argument.value">${__P(apiProcessOrders,5)}</stringProp>
+            <stringProp name="Argument.value">${__P(apiProcessOrders,1)}</stringProp>
             <stringProp name="Argument.metadata">=</stringProp>
           </elementProp>
           <elementProp name="bamboo_build_number" elementType="Argument">
@@ -259,11 +264,6 @@
             <stringProp name="Argument.value">${__P(browseProductGridPercentage,0)}</stringProp>
             <stringProp name="Argument.metadata">=</stringProp>
           </elementProp>
-          <elementProp name="cache_indicator" elementType="Argument">
-            <stringProp name="Argument.name">cache_indicator</stringProp>
-            <stringProp name="Argument.value">${__P(cache_indicator,0)}</stringProp>
-            <stringProp name="Argument.metadata">=</stringProp>
-          </elementProp>
           <elementProp name="categories_count" elementType="Argument">
             <stringProp name="Argument.name">categories_count</stringProp>
             <stringProp name="Argument.value">${__P(categories_count,100)}</stringProp>
@@ -306,7 +306,7 @@
           </elementProp>
           <elementProp name="customers_page_size" elementType="Argument">
             <stringProp name="Argument.name">customers_page_size</stringProp>
-            <stringProp name="Argument.value">${__P(customers_page_size,20)}</stringProp>
+            <stringProp name="Argument.value">${__P(customers_page_size,100)}</stringProp>
             <stringProp name="Argument.metadata">=</stringProp>
           </elementProp>
           <elementProp name="dashboard_enabled" elementType="Argument">
@@ -314,6 +314,11 @@
             <stringProp name="Argument.value">${__P(dashboard_enabled,0)}</stringProp>
             <stringProp name="Argument.metadata">=</stringProp>
           </elementProp>
+          <elementProp name="deadLocksPoolUsers" elementType="Argument">
+            <stringProp name="Argument.name">deadLocksPoolUsers</stringProp>
+            <stringProp name="Argument.value">${__P(deadLocksPoolUsers,1)}</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+          </elementProp>
           <elementProp name="exportCustomersPercentage" elementType="Argument">
             <stringProp name="Argument.name">exportCustomersPercentage</stringProp>
             <stringProp name="Argument.value">${__P(exportCustomersPercentage,0)}</stringProp>
@@ -359,11 +364,6 @@
             <stringProp name="Argument.value">${__P(orders_page_size,20)}</stringProp>
             <stringProp name="Argument.metadata">=</stringProp>
           </elementProp>
-          <elementProp name="othersPoolUsers" elementType="Argument">
-            <stringProp name="Argument.name">othersPoolUsers</stringProp>
-            <stringProp name="Argument.value">${__P(othersPoolUsers,0)}</stringProp>
-            <stringProp name="Argument.metadata">=</stringProp>
-          </elementProp>
           <elementProp name="productCompareDelay" elementType="Argument">
             <stringProp name="Argument.name">productCompareDelay</stringProp>
             <stringProp name="Argument.value">${__P(productCompareDelay,0)}</stringProp>
@@ -1746,246 +1746,6 @@ idsList.add(vars.get("customer_id"));</stringProp>
       </hashTree>
     </hashTree>
   
-    <TestFragmentController guiclass="TestFragmentControllerGui" testclass="TestFragmentController" testname="Cache" enabled="true">
-  <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/setup/cache.jmx</stringProp>
-</TestFragmentController>
-    <hashTree>
-      <IfController guiclass="IfControllerPanel" testclass="IfController" testname="If Controller: Disable cache type?" enabled="true">
-        <stringProp name="IfController.condition">"${cache_indicator}" == "1" || "${cache_indicator}" == "2"</stringProp>
-        <boolProp name="IfController.evaluateAll">false</boolProp>
-      </IfController>
-      <hashTree>
-        <BeanShellSampler guiclass="BeanShellSamplerGui" testclass="BeanShellSampler" testname="SetUp - BeanShell Sampler: resolve cache types" enabled="true">
-          <stringProp name="BeanShellSampler.query">// Default to disable all cache types
-vars.put("cache_types", "config,layout,block_html,collections,reflection,db_ddl,eav,config_integration,full_page,translate,config_webservice,config_integration_api");
-
-if ("${cache_indicator}" == "1") {
-	// Only disable Full Page Cache
-	vars.put("cache_types", "full_page");
-}
-</stringProp>
-          <stringProp name="BeanShellSampler.filename"/>
-          <stringProp name="BeanShellSampler.parameters"/>
-          <boolProp name="BeanShellSampler.resetInterpreter">false</boolProp>
-        </BeanShellSampler>
-        <hashTree/>
-        <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="SetUp - HTTP Request: Admin - Disable Specific Cache Types" enabled="true">
-          <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
-            <collectionProp name="Arguments.arguments">
-              <elementProp name="form_key" elementType="HTTPArgument">
-                <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                <stringProp name="Argument.value">${admin_form_key}</stringProp>
-                <stringProp name="Argument.metadata">=</stringProp>
-                <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                <stringProp name="Argument.name">form_key</stringProp>
-              </elementProp>
-              <elementProp name="massaction_prepare_key" elementType="HTTPArgument">
-                <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                <stringProp name="Argument.value">types</stringProp>
-                <stringProp name="Argument.metadata">=</stringProp>
-                <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                <stringProp name="Argument.name">massaction_prepare_key</stringProp>
-              </elementProp>
-              <elementProp name="types" elementType="HTTPArgument">
-                <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                <stringProp name="Argument.value">${cache_types}</stringProp>
-                <stringProp name="Argument.metadata">=</stringProp>
-                <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                <stringProp name="Argument.name">types</stringProp>
-              </elementProp>
-            </collectionProp>
-          </elementProp>
-          <stringProp name="HTTPSampler.domain"/>
-          <stringProp name="HTTPSampler.port"/>
-          <stringProp name="HTTPSampler.connect_timeout"/>
-          <stringProp name="HTTPSampler.response_timeout"/>
-          <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
-          <stringProp name="HTTPSampler.contentEncoding"/>
-          <stringProp name="HTTPSampler.path">${base_path}${admin_path}/admin/cache/massDisable</stringProp>
-          <stringProp name="HTTPSampler.method">POST</stringProp>
-          <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
-          <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
-          <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
-          <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
-          <boolProp name="HTTPSampler.BROWSER_COMPATIBLE_MULTIPART">true</boolProp>
-          <boolProp name="HTTPSampler.monitor">false</boolProp>
-          <stringProp name="HTTPSampler.embedded_url_re"/>
-        </HTTPSamplerProxy>
-        <hashTree/>
-      </hashTree>
-      <IfController guiclass="IfControllerPanel" testclass="IfController" testname="If Controller - Cache Validation - All Enabled" enabled="true">
-        <stringProp name="IfController.condition">"${cache_indicator}" == "0"</stringProp>
-        <boolProp name="IfController.evaluateAll">false</boolProp>
-      </IfController>
-      <hashTree>
-        <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="SetUp - HTTP Request - Cache Validation - All Enabled" enabled="true">
-          <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
-            <collectionProp name="Arguments.arguments">
-              <elementProp name="form_key" elementType="HTTPArgument">
-                <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                <stringProp name="Argument.value">${admin_form_key}</stringProp>
-                <stringProp name="Argument.metadata">=</stringProp>
-                <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                <stringProp name="Argument.name">form_key</stringProp>
-                <stringProp name="Argument.desc">true</stringProp>
-              </elementProp>
-            </collectionProp>
-          </elementProp>
-          <stringProp name="HTTPSampler.domain"/>
-          <stringProp name="HTTPSampler.port"/>
-          <stringProp name="HTTPSampler.connect_timeout"/>
-          <stringProp name="HTTPSampler.response_timeout"/>
-          <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
-          <stringProp name="HTTPSampler.contentEncoding"/>
-          <stringProp name="HTTPSampler.path">${base_path}${admin_path}/admin/cache/</stringProp>
-          <stringProp name="HTTPSampler.method">GET</stringProp>
-          <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
-          <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
-          <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
-          <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
-          <boolProp name="HTTPSampler.BROWSER_COMPATIBLE_MULTIPART">true</boolProp>
-          <boolProp name="HTTPSampler.monitor">false</boolProp>
-          <stringProp name="HTTPSampler.embedded_url_re"/>
-        </HTTPSamplerProxy>
-        <hashTree>
-          <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Response Assertion - Cache Validation - All Enabled" enabled="true">
-            <collectionProp name="Asserion.test_strings">
-              <stringProp name="860336383">TRANSLATE(?s).+?&lt;span&gt;Enabled&lt;/span&gt;</stringProp>
-              <stringProp name="1466502763">CONFIG(?s).+?&lt;span&gt;Enabled&lt;/span&gt;</stringProp>
-              <stringProp name="-1659688004">LAYOUT_GENERAL_CACHE_TAG(?s).+?&lt;span&gt;Enabled&lt;/span&gt;</stringProp>
-              <stringProp name="-21423984">BLOCK_HTML(?s).+?&lt;span&gt;Enabled&lt;/span&gt;</stringProp>
-              <stringProp name="593884002">COLLECTION_DATA(?s).+?&lt;span&gt;Enabled&lt;/span&gt;</stringProp>
-              <stringProp name="-751452301">EAV(?s).+?&lt;span&gt;Enabled&lt;/span&gt;</stringProp>
-              <stringProp name="1611481748">FPC(?s).+?&lt;span&gt;Enabled&lt;/span&gt;</stringProp>
-              <stringProp name="846147458">DB_DDL(?s).+?&lt;span&gt;Enabled&lt;/span&gt;</stringProp>
-              <stringProp name="-534412103">INTEGRATION(?s).+?&lt;span&gt;Enabled&lt;/span&gt;</stringProp>
-              <stringProp name="-72935653">INTEGRATION_API_CONFIG(?s).+?&lt;span&gt;Enabled&lt;/span&gt;</stringProp>
-              <stringProp name="330643820">WEBSERVICE(?s).+?&lt;span&gt;Enabled&lt;/span&gt;</stringProp>
-              <stringProp name="-479894558">REFLECTION(?s).+?&lt;span&gt;Enabled&lt;/span&gt;</stringProp>
-            </collectionProp>
-            <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
-            <boolProp name="Assertion.assume_success">false</boolProp>
-            <intProp name="Assertion.test_type">2</intProp>
-          </ResponseAssertion>
-          <hashTree/>
-        </hashTree>
-      </hashTree>
-      <IfController guiclass="IfControllerPanel" testclass="IfController" testname="If Controller - Cache Validation - Only FPC Disabled" enabled="true">
-        <stringProp name="IfController.condition">"${cache_indicator}" == "1"</stringProp>
-        <boolProp name="IfController.evaluateAll">false</boolProp>
-      </IfController>
-      <hashTree>
-        <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="SetUp - HTTP Request - Cache Validation - Only FPC Disabled" enabled="true">
-          <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
-            <collectionProp name="Arguments.arguments">
-              <elementProp name="form_key" elementType="HTTPArgument">
-                <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                <stringProp name="Argument.value">${admin_form_key}</stringProp>
-                <stringProp name="Argument.metadata">=</stringProp>
-                <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                <stringProp name="Argument.name">form_key</stringProp>
-                <stringProp name="Argument.desc">true</stringProp>
-              </elementProp>
-            </collectionProp>
-          </elementProp>
-          <stringProp name="HTTPSampler.domain"/>
-          <stringProp name="HTTPSampler.port"/>
-          <stringProp name="HTTPSampler.connect_timeout"/>
-          <stringProp name="HTTPSampler.response_timeout"/>
-          <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
-          <stringProp name="HTTPSampler.contentEncoding"/>
-          <stringProp name="HTTPSampler.path">${base_path}${admin_path}/admin/cache/</stringProp>
-          <stringProp name="HTTPSampler.method">GET</stringProp>
-          <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
-          <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
-          <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
-          <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
-          <boolProp name="HTTPSampler.BROWSER_COMPATIBLE_MULTIPART">true</boolProp>
-          <boolProp name="HTTPSampler.monitor">false</boolProp>
-          <stringProp name="HTTPSampler.embedded_url_re"/>
-        </HTTPSamplerProxy>
-        <hashTree>
-          <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Response Assertion - Cache Validation - All Disabled" enabled="true">
-            <collectionProp name="Asserion.test_strings">
-              <stringProp name="860336383">TRANSLATE(?s).+?&lt;span&gt;Enabled&lt;/span&gt;</stringProp>
-              <stringProp name="1466502763">CONFIG(?s).+?&lt;span&gt;Enabled&lt;/span&gt;</stringProp>
-              <stringProp name="-1659688004">LAYOUT_GENERAL_CACHE_TAG(?s).+?&lt;span&gt;Enabled&lt;/span&gt;</stringProp>
-              <stringProp name="-21423984">BLOCK_HTML(?s).+?&lt;span&gt;Enabled&lt;/span&gt;</stringProp>
-              <stringProp name="593884002">COLLECTION_DATA(?s).+?&lt;span&gt;Enabled&lt;/span&gt;</stringProp>
-              <stringProp name="-751452301">EAV(?s).+?&lt;span&gt;Enabled&lt;/span&gt;</stringProp>
-              <stringProp name="-2075232047">FPC(?s).+?&lt;span&gt;Disabled&lt;/span&gt;</stringProp>
-              <stringProp name="846147458">DB_DDL(?s).+?&lt;span&gt;Enabled&lt;/span&gt;</stringProp>
-              <stringProp name="-534412103">INTEGRATION(?s).+?&lt;span&gt;Enabled&lt;/span&gt;</stringProp>
-              <stringProp name="-72935653">INTEGRATION_API_CONFIG(?s).+?&lt;span&gt;Enabled&lt;/span&gt;</stringProp>
-              <stringProp name="330643820">WEBSERVICE(?s).+?&lt;span&gt;Enabled&lt;/span&gt;</stringProp>
-              <stringProp name="-479894558">REFLECTION(?s).+?&lt;span&gt;Enabled&lt;/span&gt;</stringProp>
-            </collectionProp>
-            <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
-            <boolProp name="Assertion.assume_success">false</boolProp>
-            <intProp name="Assertion.test_type">2</intProp>
-          </ResponseAssertion>
-          <hashTree/>
-        </hashTree>
-      </hashTree>
-      <IfController guiclass="IfControllerPanel" testclass="IfController" testname="If Controller - Cache Validation - All Disabled" enabled="true">
-        <stringProp name="IfController.condition">"${cache_indicator}" == "2"</stringProp>
-        <boolProp name="IfController.evaluateAll">false</boolProp>
-      </IfController>
-      <hashTree>
-        <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="SetUp - HTTP Request - Cache Validation - All Disabled" enabled="true">
-          <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
-            <collectionProp name="Arguments.arguments">
-              <elementProp name="form_key" elementType="HTTPArgument">
-                <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                <stringProp name="Argument.value">${admin_form_key}</stringProp>
-                <stringProp name="Argument.metadata">=</stringProp>
-                <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                <stringProp name="Argument.name">form_key</stringProp>
-                <stringProp name="Argument.desc">true</stringProp>
-              </elementProp>
-            </collectionProp>
-          </elementProp>
-          <stringProp name="HTTPSampler.domain"/>
-          <stringProp name="HTTPSampler.port"/>
-          <stringProp name="HTTPSampler.connect_timeout"/>
-          <stringProp name="HTTPSampler.response_timeout"/>
-          <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
-          <stringProp name="HTTPSampler.contentEncoding"/>
-          <stringProp name="HTTPSampler.path">${base_path}${admin_path}/admin/cache/</stringProp>
-          <stringProp name="HTTPSampler.method">GET</stringProp>
-          <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
-          <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
-          <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
-          <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
-          <boolProp name="HTTPSampler.BROWSER_COMPATIBLE_MULTIPART">true</boolProp>
-          <boolProp name="HTTPSampler.monitor">false</boolProp>
-          <stringProp name="HTTPSampler.embedded_url_re"/>
-        </HTTPSamplerProxy>
-        <hashTree>
-          <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Response Assertion - Cache Validation - All Disabled" enabled="true">
-            <collectionProp name="Asserion.test_strings">
-              <stringProp name="409065414">TRANSLATE(?s).+?&lt;span&gt;Disabled&lt;/span&gt;</stringProp>
-              <stringProp name="2020354010">CONFIG(?s).+?&lt;span&gt;Disabled&lt;/span&gt;</stringProp>
-              <stringProp name="-402279255">LAYOUT_GENERAL_CACHE_TAG(?s).+?&lt;span&gt;Disabled&lt;/span&gt;</stringProp>
-              <stringProp name="-1155702187">BLOCK_HTML(?s).+?&lt;span&gt;Disabled&lt;/span&gt;</stringProp>
-              <stringProp name="738976195">COLLECTION_DATA(?s).+?&lt;span&gt;Disabled&lt;/span&gt;</stringProp>
-              <stringProp name="1983223762">EAV(?s).+?&lt;span&gt;Disabled&lt;/span&gt;</stringProp>
-              <stringProp name="-2075232047">FPC(?s).+?&lt;span&gt;Disabled&lt;/span&gt;</stringProp>
-              <stringProp name="-30791261">DB_DDL(?s).+?&lt;span&gt;Disabled&lt;/span&gt;</stringProp>
-              <stringProp name="121535308">INTEGRATION(?s).+?&lt;span&gt;Disabled&lt;/span&gt;</stringProp>
-              <stringProp name="1542403370">INTEGRATION_API_CONFIG(?s).+?&lt;span&gt;Disabled&lt;/span&gt;</stringProp>
-              <stringProp name="1168465145">WEBSERVICE(?s).+?&lt;span&gt;Disabled&lt;/span&gt;</stringProp>
-              <stringProp name="1811579203">REFLECTION(?s).+?&lt;span&gt;Disabled&lt;/span&gt;</stringProp>
-            </collectionProp>
-            <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
-            <boolProp name="Assertion.assume_success">false</boolProp>
-            <intProp name="Assertion.test_type">2</intProp>
-          </ResponseAssertion>
-          <hashTree/>
-        </hashTree>
-      </hashTree>
-    </hashTree>
-  
     <BeanShellSampler guiclass="BeanShellSamplerGui" testclass="BeanShellSampler" testname="SetUp - BeanShell Sampler: Validate properties and count users" enabled="true">
       <stringProp name="BeanShellSampler.query">Boolean stopTestOnError (String error) {
     log.error(error);
@@ -2151,11 +1911,11 @@ if (props.get("category_names_list") == null) {
             <stringProp name="ThreadGroup.delay"/>
         <stringProp name="TestPlan.comments">mpaf/tool/fragments/_system/thread_group.jmx</stringProp></ThreadGroup>
         <hashTree>
-    <ThroughputController guiclass="ThroughputControllerGui" testclass="ThroughputController" testname="Catalog Browsing By Guest" enabled="true">
+    <ThroughputController guiclass="ThroughputControllerGui" testclass="ThroughputController" testname="Catalog Browsing By Customer" enabled="true">
       <intProp name="ThroughputController.style">1</intProp>
       <boolProp name="ThroughputController.perThread">false</boolProp>
       <intProp name="ThroughputController.maxThroughput">1</intProp>
-      <stringProp name="ThroughputController.percentThroughput">${browseCatalogByGuestPercentage}</stringProp>
+      <stringProp name="ThroughputController.percentThroughput">${browseCatalogByCustomerPercentage}</stringProp>
     <stringProp name="TestPlan.comments">mpaf/tool/fragments/_system/scenario_controller_tmpl.jmx</stringProp></ThroughputController>
     <hashTree>
         <JSR223PreProcessor guiclass="TestBeanGUI" testclass="JSR223PreProcessor" testname="Set Test Label" enabled="true">
@@ -2176,7 +1936,539 @@ if (testLabel
         <hashTree/>
         <BeanShellSampler guiclass="BeanShellSamplerGui" testclass="BeanShellSampler" testname="SetUp - Set Label" enabled="true">
             <stringProp name="BeanShellSampler.query">
-                vars.put("testLabel", "Catalog Browsing By Guest");
+                vars.put("testLabel", "Catalog Browsing By Customer");
+            </stringProp>
+            <boolProp name="BeanShellSampler.resetInterpreter">true</boolProp>
+        </BeanShellSampler>
+        <hashTree/>
+    
+    <CookieManager guiclass="CookiePanel" testclass="CookieManager" testname="HTTP Cookie Manager" enabled="true">
+      <collectionProp name="CookieManager.cookies">
+        <elementProp name="product_list_limit" elementType="Cookie" testname="product_list_limit">
+          <stringProp name="Cookie.value">30</stringProp>
+          <stringProp name="Cookie.domain">${host}</stringProp>
+          <stringProp name="Cookie.path">/</stringProp>
+          <boolProp name="Cookie.secure">false</boolProp>
+          <longProp name="Cookie.expires">0</longProp>
+          <boolProp name="Cookie.path_specified">true</boolProp>
+          <boolProp name="Cookie.domain_specified">true</boolProp>
+        </elementProp>
+        <elementProp name="product_list_limit" elementType="Cookie" testname="form_key">
+          <stringProp name="Cookie.value">${form_key}</stringProp>
+          <stringProp name="Cookie.domain">${host}</stringProp>
+          <stringProp name="Cookie.path">${base_path}</stringProp>
+          <boolProp name="Cookie.secure">false</boolProp>
+          <longProp name="Cookie.expires">0</longProp>
+          <boolProp name="Cookie.path_specified">true</boolProp>
+          <boolProp name="Cookie.domain_specified">true</boolProp>
+        </elementProp>
+      </collectionProp>
+      <boolProp name="CookieManager.clearEachIteration">true</boolProp>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/http_cookie_manager.jmx</stringProp></CookieManager>
+    <hashTree/>
+  
+      <BeanShellSampler guiclass="BeanShellSamplerGui" testclass="BeanShellSampler" testname="SetUp - Init Random Generator" enabled="true">
+        <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/common/init_random_generator_setup.jmx</stringProp>
+        <stringProp name="BeanShellSampler.query">
+import java.util.Random;
+
+Random random = new Random();
+if (${seedForRandom} &gt; 0) {
+    random.setSeed(${seedForRandom} + ${__threadNum});
+}
+
+vars.putObject("randomIntGenerator", random);
+        </stringProp>
+        <stringProp name="BeanShellSampler.filename"/>
+        <stringProp name="BeanShellSampler.parameters"/>
+        <boolProp name="BeanShellSampler.resetInterpreter">true</boolProp>
+      </BeanShellSampler>
+      <hashTree/>
+    
+      <BeanShellSampler guiclass="BeanShellSamplerGui" testclass="BeanShellSampler" testname="SetUp - Prepare Category Data" enabled="true">
+        <stringProp name="BeanShellSampler.query">
+import java.util.Random;
+
+Random random = vars.getObject("randomIntGenerator");
+number = random.nextInt(props.get("category_url_keys_list").size());
+
+vars.put("category_url_key", props.get("category_url_keys_list").get(number));
+vars.put("category_name", props.get("category_names_list").get(number));
+        </stringProp>
+        <stringProp name="BeanShellSampler.filename"/>
+        <stringProp name="BeanShellSampler.parameters"/>
+        <boolProp name="BeanShellSampler.resetInterpreter">false</boolProp>
+      <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/common/extract_category_setup.jmx</stringProp></BeanShellSampler>
+      <hashTree/>
+    
+    <CriticalSectionController guiclass="CriticalSectionControllerGui" testclass="CriticalSectionController" testname="Get Customer Email" enabled="true">
+        <stringProp name="CriticalSectionController.lockName">get-email</stringProp>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/lock_controller.jmx</stringProp></CriticalSectionController>
+    <hashTree>
+    
+    <BeanShellSampler guiclass="BeanShellSamplerGui" testclass="BeanShellSampler" testname="SetUp - Get Customer Email" enabled="true">
+      <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/get_customer_email.jmx</stringProp>
+      <stringProp name="BeanShellSampler.query">
+customerUserList = props.get("customer_emails_list");
+customerUser = customerUserList.poll();
+if (customerUser == null) {
+  SampleResult.setResponseMessage("customernUser list is empty");
+  SampleResult.setResponseData("customerUser list is empty","UTF-8");
+  IsSuccess=false;
+  SampleResult.setSuccessful(false);
+  SampleResult.setStopThread(true);
+}
+vars.put("customer_email", customerUser);
+      </stringProp>
+      <stringProp name="BeanShellSampler.filename"/>
+      <stringProp name="BeanShellSampler.parameters"/>
+      <boolProp name="BeanShellSampler.resetInterpreter">true</boolProp>
+    </BeanShellSampler>
+    <hashTree/>
+  </hashTree>
+  
+    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Open Login Page" enabled="true">
+      <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
+        <collectionProp name="Arguments.arguments"/>
+      </elementProp>
+      <stringProp name="HTTPSampler.domain"/>
+      <stringProp name="HTTPSampler.port"/>
+      <stringProp name="HTTPSampler.connect_timeout"/>
+      <stringProp name="HTTPSampler.response_timeout"/>
+      <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
+      <stringProp name="HTTPSampler.contentEncoding"/>
+      <stringProp name="HTTPSampler.path">${base_path}customer/account/login/</stringProp>
+      <stringProp name="HTTPSampler.method">GET</stringProp>
+      <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
+      <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
+      <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
+      <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
+      <boolProp name="HTTPSampler.monitor">false</boolProp>
+      <stringProp name="HTTPSampler.embedded_url_re"/>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/common/open_login_page.jmx</stringProp></HTTPSamplerProxy>
+    <hashTree>
+      <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Response Assertion" enabled="true">
+        <collectionProp name="Asserion.test_strings">
+          <stringProp name="637394530">&lt;title&gt;Customer Login&lt;/title&gt;</stringProp>
+        </collectionProp>
+        <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
+        <boolProp name="Assertion.assume_success">false</boolProp>
+        <intProp name="Assertion.test_type">2</intProp>
+      </ResponseAssertion>
+      <hashTree/>
+    </hashTree>
+  
+    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Login" enabled="true">
+      <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
+        <collectionProp name="Arguments.arguments">
+          <elementProp name="form_key" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">${form_key}</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">form_key</stringProp>
+          </elementProp>
+          <elementProp name="login[username]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">${customer_email}</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">login[username]</stringProp>
+          </elementProp>
+          <elementProp name="login[password]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">${customer_password}</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">login[password]</stringProp>
+          </elementProp>
+          <elementProp name="send" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value"/>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">send</stringProp>
+          </elementProp>
+        </collectionProp>
+      </elementProp>
+      <stringProp name="HTTPSampler.domain"/>
+      <stringProp name="HTTPSampler.port"/>
+      <stringProp name="HTTPSampler.connect_timeout"/>
+      <stringProp name="HTTPSampler.response_timeout"/>
+      <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
+      <stringProp name="HTTPSampler.contentEncoding"/>
+      <stringProp name="HTTPSampler.path">${base_path}customer/account/loginPost/</stringProp>
+      <stringProp name="HTTPSampler.method">POST</stringProp>
+      <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
+      <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
+      <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
+      <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
+      <boolProp name="HTTPSampler.monitor">false</boolProp>
+      <stringProp name="HTTPSampler.embedded_url_re"/>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/common/login.jmx</stringProp></HTTPSamplerProxy>
+    <hashTree>
+      <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Response Assertion" enabled="true">
+        <collectionProp name="Asserion.test_strings">
+          <stringProp name="1312950388">&lt;title&gt;My Account&lt;/title&gt;</stringProp>
+        </collectionProp>
+        <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
+        <boolProp name="Assertion.assume_success">false</boolProp>
+        <intProp name="Assertion.test_type">2</intProp>
+      </ResponseAssertion>
+      <hashTree/>
+      <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract Address" enabled="true">
+        <stringProp name="RegexExtractor.useHeaders">false</stringProp>
+        <stringProp name="RegexExtractor.refname">addressId</stringProp>
+        <stringProp name="RegexExtractor.regex">customer/address/edit/id/([^'"]+)/</stringProp>
+        <stringProp name="RegexExtractor.template">$1$</stringProp>
+        <stringProp name="RegexExtractor.default"/>
+        <stringProp name="RegexExtractor.match_number">1</stringProp>
+      </RegexExtractor>
+      <hashTree/>
+      <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert addressId extracted" enabled="true">
+        <collectionProp name="Asserion.test_strings">
+          <stringProp name="2845929">^.+$</stringProp>
+        </collectionProp>
+        <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
+        <boolProp name="Assertion.assume_success">false</boolProp>
+        <intProp name="Assertion.test_type">1</intProp>
+        <stringProp name="Assertion.scope">variable</stringProp>
+        <stringProp name="Scope.variable">addressId</stringProp>
+      </ResponseAssertion>
+      <hashTree/>
+    </hashTree>
+    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Load Customer Private Data" enabled="true">
+      <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
+        <collectionProp name="Arguments.arguments">
+          <elementProp name="sections" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value"/>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">sections</stringProp>
+          </elementProp>
+          <elementProp name="update_section_id" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">false</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">update_section_id</stringProp>
+          </elementProp>
+          <elementProp name="_" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">${__time()}${__Random(1,1000000)}</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">_</stringProp>
+          </elementProp>
+        </collectionProp>
+      </elementProp>
+      <stringProp name="HTTPSampler.domain"/>
+      <stringProp name="HTTPSampler.port"/>
+      <stringProp name="HTTPSampler.connect_timeout"/>
+      <stringProp name="HTTPSampler.response_timeout"/>
+      <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
+      <stringProp name="HTTPSampler.contentEncoding"/>
+      <stringProp name="HTTPSampler.path">${base_path}customer/section/load/</stringProp>
+      <stringProp name="HTTPSampler.method">GET</stringProp>
+      <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
+      <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
+      <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
+      <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
+      <boolProp name="HTTPSampler.monitor">false</boolProp>
+      <stringProp name="HTTPSampler.embedded_url_re"/>
+    </HTTPSamplerProxy>
+    <hashTree/>
+  
+      <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Open Home Page" enabled="true">
+        <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
+          <collectionProp name="Arguments.arguments"/>
+        </elementProp>
+        <stringProp name="HTTPSampler.domain"/>
+        <stringProp name="HTTPSampler.port"/>
+        <stringProp name="HTTPSampler.connect_timeout"/>
+        <stringProp name="HTTPSampler.response_timeout"/>
+        <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
+        <stringProp name="HTTPSampler.contentEncoding"/>
+        <stringProp name="HTTPSampler.path">${base_path}</stringProp>
+        <stringProp name="HTTPSampler.method">GET</stringProp>
+        <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
+        <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
+        <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
+        <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
+        <boolProp name="HTTPSampler.monitor">false</boolProp>
+        <stringProp name="HTTPSampler.embedded_url_re"/>
+      <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/common/open_home_page.jmx</stringProp></HTTPSamplerProxy>
+      <hashTree>
+        <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Response Assertion" enabled="true">
+          <collectionProp name="Asserion.test_strings">
+            <stringProp name="571386695">&lt;title&gt;Home page&lt;/title&gt;</stringProp>
+          </collectionProp>
+          <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
+          <boolProp name="Assertion.assume_success">false</boolProp>
+          <intProp name="Assertion.test_type">2</intProp>
+        </ResponseAssertion>
+        <hashTree/>
+      </hashTree>
+  
+    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Open Category" enabled="true">
+      <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
+        <collectionProp name="Arguments.arguments"/>
+      </elementProp>
+      <stringProp name="HTTPSampler.domain"/>
+      <stringProp name="HTTPSampler.port"/>
+      <stringProp name="HTTPSampler.connect_timeout"/>
+      <stringProp name="HTTPSampler.response_timeout"/>
+      <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
+      <stringProp name="HTTPSampler.contentEncoding"/>
+      <stringProp name="HTTPSampler.path">${base_path}${category_url_key}${url_suffix}</stringProp>
+      <stringProp name="HTTPSampler.method">GET</stringProp>
+      <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
+      <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
+      <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
+      <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
+      <boolProp name="HTTPSampler.monitor">false</boolProp>
+      <stringProp name="HTTPSampler.embedded_url_re"/>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/common/open_category.jmx</stringProp></HTTPSamplerProxy>
+    <hashTree>
+      <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Response Assertion" enabled="true">
+        <collectionProp name="Asserion.test_strings">
+          <stringProp name="1210004667">&lt;span class="base" data-ui-id="page-title"&gt;${category_name}&lt;/span&gt;</stringProp>
+        </collectionProp>
+        <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
+        <boolProp name="Assertion.assume_success">false</boolProp>
+        <intProp name="Assertion.test_type">6</intProp>
+      </ResponseAssertion>
+      <hashTree/>
+      <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Regular Expression Extractor: Extract category id" enabled="true">
+        <stringProp name="RegexExtractor.useHeaders">false</stringProp>
+        <stringProp name="RegexExtractor.refname">category_id</stringProp>
+        <stringProp name="RegexExtractor.regex">&lt;li class="item category([^'"]+)"&gt;\s*&lt;strong&gt;${category_name}&lt;/strong&gt;\s*&lt;/li&gt;</stringProp>
+        <stringProp name="RegexExtractor.template">$1$</stringProp>
+        <stringProp name="RegexExtractor.default"/>
+        <stringProp name="RegexExtractor.match_number">1</stringProp>
+        <stringProp name="Scope.variable">simple_product_1_url_key</stringProp>
+      </RegexExtractor>
+      <hashTree/>
+      <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Response Assertion: Assert category id" enabled="true">
+        <collectionProp name="Asserion.test_strings">
+          <stringProp name="1191417111">^[0-9]+$</stringProp>
+        </collectionProp>
+        <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
+        <boolProp name="Assertion.assume_success">false</boolProp>
+        <intProp name="Assertion.test_type">1</intProp>
+        <stringProp name="Assertion.scope">variable</stringProp>
+        <stringProp name="Scope.variable">category_id</stringProp>
+      </ResponseAssertion>
+      <hashTree/>
+    </hashTree>
+  
+    <LoopController guiclass="LoopControlPanel" testclass="LoopController" testname="View Simple Products" enabled="true">
+      <boolProp name="LoopController.continue_forever">true</boolProp>
+      <stringProp name="LoopController.loops">2</stringProp>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/loop_controller.jmx</stringProp></LoopController>
+    <hashTree>
+      <CounterConfig guiclass="CounterConfigGui" testclass="CounterConfig" testname="Counter" enabled="true">
+        <stringProp name="CounterConfig.start">1</stringProp>
+        <stringProp name="CounterConfig.end"/>
+        <stringProp name="CounterConfig.incr">1</stringProp>
+        <stringProp name="CounterConfig.name">_counter</stringProp>
+        <stringProp name="CounterConfig.format"/>
+        <boolProp name="CounterConfig.per_user">true</boolProp>
+        <boolProp name="CounterConfig.reset_on_tg_iteration">true</boolProp>
+      </CounterConfig>
+      <hashTree/>
+    
+    <BeanShellSampler guiclass="BeanShellSamplerGui" testclass="BeanShellSampler" testname="SetUp - Prepare Simple Product Data" enabled="true">
+      <stringProp name="BeanShellSampler.query">
+import java.util.Random;
+
+Random random = vars.getObject("randomIntGenerator");
+number = random.nextInt(props.get("simple_products_list").size());
+product = props.get("simple_products_list").get(number);
+
+vars.put("product_url_key", product.get("url_key"));
+vars.put("product_id", product.get("id"));
+vars.put("product_name", product.get("title"));
+vars.put("product_uenc", product.get("uenc"));
+vars.put("product_sku", product.get("sku"));
+      </stringProp>
+      <stringProp name="BeanShellSampler.filename"/>
+      <stringProp name="BeanShellSampler.parameters"/>
+      <boolProp name="BeanShellSampler.resetInterpreter">true</boolProp>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/product_browsing_and_adding_items_to_the_cart/simple_products_setup.jmx</stringProp></BeanShellSampler>
+    <hashTree/>
+  
+        <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Simple Product ${_counter} View" enabled="true">
+            <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
+                <collectionProp name="Arguments.arguments"/>
+            </elementProp>
+            <stringProp name="HTTPSampler.domain"/>
+            <stringProp name="HTTPSampler.port"/>
+            <stringProp name="HTTPSampler.connect_timeout"/>
+            <stringProp name="HTTPSampler.response_timeout"/>
+            <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
+            <stringProp name="HTTPSampler.contentEncoding"/>
+            <stringProp name="HTTPSampler.path">${base_path}${product_url_key}${url_suffix}</stringProp>
+            <stringProp name="HTTPSampler.method">GET</stringProp>
+            <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
+            <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
+            <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
+            <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
+            <boolProp name="HTTPSampler.monitor">false</boolProp>
+            <stringProp name="HTTPSampler.embedded_url_re"/>
+        <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/product_browsing_and_adding_items_to_the_cart/product_view.jmx</stringProp></HTTPSamplerProxy>
+        <hashTree>
+            <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Response Assertion" enabled="true">
+                <collectionProp name="Asserion.test_strings">
+                    <stringProp name="-1787050162">&lt;span&gt;In stock&lt;/span&gt;</stringProp>
+                </collectionProp>
+                <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
+                <boolProp name="Assertion.assume_success">false</boolProp>
+                <intProp name="Assertion.test_type">2</intProp>
+            </ResponseAssertion>
+            <hashTree/>
+        </hashTree>
+    </hashTree>
+  
+    <LoopController guiclass="LoopControlPanel" testclass="LoopController" testname="View Configurable Products" enabled="true">
+      <boolProp name="LoopController.continue_forever">true</boolProp>
+      <stringProp name="LoopController.loops">1</stringProp>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/loop_controller.jmx</stringProp></LoopController>
+    <hashTree>
+      <CounterConfig guiclass="CounterConfigGui" testclass="CounterConfig" testname="Counter" enabled="true">
+        <stringProp name="CounterConfig.start">1</stringProp>
+        <stringProp name="CounterConfig.end"/>
+        <stringProp name="CounterConfig.incr">1</stringProp>
+        <stringProp name="CounterConfig.name">_counter</stringProp>
+        <stringProp name="CounterConfig.format"/>
+        <boolProp name="CounterConfig.per_user">true</boolProp>
+        <boolProp name="CounterConfig.reset_on_tg_iteration">true</boolProp>
+      </CounterConfig>
+      <hashTree/>
+    
+    <BeanShellSampler guiclass="BeanShellSamplerGui" testclass="BeanShellSampler" testname="SetUp - Prepare Configurable Product Data" enabled="true">
+      <stringProp name="BeanShellSampler.query">
+import java.util.Random;
+
+Random random = vars.getObject("randomIntGenerator");
+number = random.nextInt(props.get("configurable_products_list").size());
+product = props.get("configurable_products_list").get(number);
+
+vars.put("product_url_key", product.get("url_key"));
+vars.put("product_id", product.get("id"));
+vars.put("product_name", product.get("title"));
+vars.put("product_uenc", product.get("uenc"));
+vars.put("product_sku", product.get("sku"));
+      </stringProp>
+      <stringProp name="BeanShellSampler.filename"/>
+      <stringProp name="BeanShellSampler.parameters"/>
+      <boolProp name="BeanShellSampler.resetInterpreter">true</boolProp>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/product_browsing_and_adding_items_to_the_cart/configurable_products_setup.jmx</stringProp></BeanShellSampler>
+    <hashTree/>
+  
+        <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Configurable Product ${_counter} View" enabled="true">
+            <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
+                <collectionProp name="Arguments.arguments"/>
+            </elementProp>
+            <stringProp name="HTTPSampler.domain"/>
+            <stringProp name="HTTPSampler.port"/>
+            <stringProp name="HTTPSampler.connect_timeout"/>
+            <stringProp name="HTTPSampler.response_timeout"/>
+            <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
+            <stringProp name="HTTPSampler.contentEncoding"/>
+            <stringProp name="HTTPSampler.path">${base_path}${product_url_key}${url_suffix}</stringProp>
+            <stringProp name="HTTPSampler.method">GET</stringProp>
+            <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
+            <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
+            <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
+            <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
+            <boolProp name="HTTPSampler.monitor">false</boolProp>
+            <stringProp name="HTTPSampler.embedded_url_re"/>
+        <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/product_browsing_and_adding_items_to_the_cart/product_view.jmx</stringProp></HTTPSamplerProxy>
+        <hashTree>
+            <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Response Assertion" enabled="true">
+                <collectionProp name="Asserion.test_strings">
+                    <stringProp name="-1787050162">&lt;span&gt;In stock&lt;/span&gt;</stringProp>
+                </collectionProp>
+                <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
+                <boolProp name="Assertion.assume_success">false</boolProp>
+                <intProp name="Assertion.test_type">2</intProp>
+            </ResponseAssertion>
+            <hashTree/>
+        </hashTree>
+    </hashTree>
+  
+    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Logout" enabled="true">
+      <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
+        <collectionProp name="Arguments.arguments"/>
+      </elementProp>
+      <stringProp name="HTTPSampler.domain"/>
+      <stringProp name="HTTPSampler.port"/>
+      <stringProp name="HTTPSampler.connect_timeout"/>
+      <stringProp name="HTTPSampler.response_timeout"/>
+      <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
+      <stringProp name="HTTPSampler.contentEncoding"/>
+      <stringProp name="HTTPSampler.path">${base_path}customer/account/logout/</stringProp>
+      <stringProp name="HTTPSampler.method">GET</stringProp>
+      <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
+      <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
+      <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
+      <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
+      <boolProp name="HTTPSampler.monitor">false</boolProp>
+      <stringProp name="HTTPSampler.embedded_url_re"/>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/common/logout.jmx</stringProp></HTTPSamplerProxy>
+    <hashTree>
+      <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert success" enabled="true">
+        <collectionProp name="Asserion.test_strings">
+          <stringProp name="1723813687">You are signed out.</stringProp>
+        </collectionProp>
+        <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
+        <boolProp name="Assertion.assume_success">false</boolProp>
+        <intProp name="Assertion.test_type">2</intProp>
+      </ResponseAssertion>
+      <hashTree/>
+    
+    <BeanShellPostProcessor guiclass="TestBeanGUI" testclass="BeanShellPostProcessor" testname="Return Customer to Pool" enabled="true">
+        <boolProp name="resetInterpreter">false</boolProp>
+        <stringProp name="parameters"/>
+        <stringProp name="filename"/>
+        <stringProp name="script">
+customerUserList = props.get("customer_emails_list");
+customerUserList.add(vars.get("customer_email"));
+        </stringProp>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/common/return_email_to_pool.jmx</stringProp></BeanShellPostProcessor>
+    <hashTree/>
+  </hashTree>
+  </hashTree>
+
+  
+    <ThroughputController guiclass="ThroughputControllerGui" testclass="ThroughputController" testname="Catalog Browsing By Guest" enabled="true">
+      <intProp name="ThroughputController.style">1</intProp>
+      <boolProp name="ThroughputController.perThread">false</boolProp>
+      <intProp name="ThroughputController.maxThroughput">1</intProp>
+      <stringProp name="ThroughputController.percentThroughput">${browseCatalogByGuestPercentage}</stringProp>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/_system/scenario_controller_tmpl.jmx</stringProp></ThroughputController>
+    <hashTree>
+        <JSR223PreProcessor guiclass="TestBeanGUI" testclass="JSR223PreProcessor" testname="Set Test Label" enabled="true">
+            <stringProp name="script">
+var testLabel = "${testLabel}" ? " (${testLabel})" : "";
+if (testLabel
+    &amp;&amp; sampler.getClass().getName() == 'org.apache.jmeter.protocol.http.sampler.HTTPSamplerProxy'
+) {
+    if (sampler.getName().indexOf(testLabel) == -1) {
+       sampler.setName(sampler.getName() + testLabel);
+    }
+} else if (sampler.getName().indexOf("SetUp - ") == -1) {
+    sampler.setName("SetUp - " + sampler.getName());
+}
+            </stringProp>
+            <stringProp name="scriptLanguage">javascript</stringProp>
+        <stringProp name="TestPlan.comments">mpaf/tool/fragments/_system/setup_label.jmx</stringProp></JSR223PreProcessor>
+        <hashTree/>
+        <BeanShellSampler guiclass="BeanShellSamplerGui" testclass="BeanShellSampler" testname="SetUp - Set Label" enabled="true">
+            <stringProp name="BeanShellSampler.query">
+                vars.put("testLabel", "Catalog Browsing By Guest");
             </stringProp>
             <boolProp name="BeanShellSampler.resetInterpreter">true</boolProp>
         </BeanShellSampler>
@@ -2867,7 +3159,7 @@ if (testLabel
       <XPathExtractor guiclass="XPathExtractorGui" testclass="XPathExtractor" testname="Extract filter link from layered navigation" enabled="true">
         <stringProp name="XPathExtractor.default"/>
         <stringProp name="XPathExtractor.refname">attribute_1_filter_url</stringProp>
-        <stringProp name="XPathExtractor.xpathQuery">((//div[@class="filter-options-content"])[1]//li[@class="item"]//a)[${__javaScript(Math.floor(Math.random()*${attribute_1_options_count})+1)}]/@href</stringProp>
+        <stringProp name="XPathExtractor.xpathQuery">((//div[@class="filter-options-content"])[1]//li[@class="item"]//a)[1]/@href</stringProp>
         <boolProp name="XPathExtractor.validate">false</boolProp>
         <boolProp name="XPathExtractor.tolerant">true</boolProp>
         <boolProp name="XPathExtractor.namespace">false</boolProp>
@@ -2938,7 +3230,7 @@ if (testLabel
         <XPathExtractor guiclass="XPathExtractorGui" testclass="XPathExtractor" testname="Extract filter link from layered navigation" enabled="true">
           <stringProp name="XPathExtractor.default"/>
           <stringProp name="XPathExtractor.refname">attribute_2_filter_url</stringProp>
-          <stringProp name="XPathExtractor.xpathQuery">((//div[@class="filter-options-content"])[2]//li[@class="item"]//a)[${__javaScript(Math.floor(Math.random()*${attribute_2_options_count})+1)}]/@href</stringProp>
+          <stringProp name="XPathExtractor.xpathQuery">((//div[@class="filter-options-content"])[2]//li[@class="item"]//a)[1]/@href</stringProp>
           <boolProp name="XPathExtractor.validate">false</boolProp>
           <boolProp name="XPathExtractor.tolerant">true</boolProp>
           <boolProp name="XPathExtractor.namespace">false</boolProp>
@@ -3228,7 +3520,7 @@ if (testLabel
       <XPathExtractor guiclass="XPathExtractorGui" testclass="XPathExtractor" testname="Extract attribute value" enabled="true">
         <stringProp name="XPathExtractor.default"/>
         <stringProp name="XPathExtractor.refname">attribute_value</stringProp>
-        <stringProp name="XPathExtractor.xpathQuery">((//select[@class="multiselect"])[last()]/option)[${__javaScript(Math.floor(Math.random()*${attribute_options_count})+1)}]/@value</stringProp>
+        <stringProp name="XPathExtractor.xpathQuery">((//select[@class="multiselect"])[last()]/option)[1]/@value</stringProp>
         <boolProp name="XPathExtractor.validate">false</boolProp>
         <boolProp name="XPathExtractor.tolerant">true</boolProp>
         <boolProp name="XPathExtractor.namespace">false</boolProp>
@@ -4260,44 +4552,31 @@ vars.putObject("randomIntGenerator", random);
       </BeanShellSampler>
       <hashTree/>
     
+    <CriticalSectionController guiclass="CriticalSectionControllerGui" testclass="CriticalSectionController" testname="Get Customer Email" enabled="true">
+        <stringProp name="CriticalSectionController.lockName">get-email</stringProp>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/lock_controller.jmx</stringProp></CriticalSectionController>
+    <hashTree>
+    
     <BeanShellSampler guiclass="BeanShellSamplerGui" testclass="BeanShellSampler" testname="SetUp - Get Customer Email" enabled="true">
       <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/get_customer_email.jmx</stringProp>
-      <stringProp name="BeanShellSampler.query">import org.apache.jmeter.samplers.SampleResult;
-
-String siterator = vars.get("customer_emails_index");
-int iterator;
-if(siterator == null){
-    iterator = 0;
-    vars.put("customer_emails_index", "0");
-} else {
-    iterator = Integer.parseInt(siterator);
-    iterator ++;
-    vars.put("customer_emails_index", iterator.toString());
-}
-
-emails_list = props.get("customer_emails_list");
-
-threadsNumber = ctx.getThreadGroup().getNumThreads();
-emailsCount = emails_list.size();
-if (threadsNumber &gt; emailsCount) {
-    log.error(" There are not enough customers for this scenario.");
-} else {
-    clusterLength = Math.round(emailsCount / threadsNumber);
-    threadNum = ctx.getThreadNum();
-    emails_index = clusterLength * threadNum + iterator;
-    maxLimit = clusterLength * (threadNum + 1);
-    if (emails_index &gt;= maxLimit) {
-        iterator = 0;
-        emails_index = clusterLength * threadNum + iterator;
-        vars.put("customer_emails_index", iterator.toString());
-    }
+      <stringProp name="BeanShellSampler.query">
+customerUserList = props.get("customer_emails_list");
+customerUser = customerUserList.poll();
+if (customerUser == null) {
+  SampleResult.setResponseMessage("customernUser list is empty");
+  SampleResult.setResponseData("customerUser list is empty","UTF-8");
+  IsSuccess=false;
+  SampleResult.setSuccessful(false);
+  SampleResult.setStopThread(true);
 }
-vars.put("customer_email", emails_list.get(emails_index));</stringProp>
+vars.put("customer_email", customerUser);
+      </stringProp>
       <stringProp name="BeanShellSampler.filename"/>
       <stringProp name="BeanShellSampler.parameters"/>
       <boolProp name="BeanShellSampler.resetInterpreter">true</boolProp>
     </BeanShellSampler>
     <hashTree/>
+  </hashTree>
   
     <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Open Login Page" enabled="true">
       <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
@@ -4488,7 +4767,7 @@ vars.put("product_sku", product.get("sku"));
     <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/product_browsing_and_adding_items_to_the_cart/simple_products_setup.jmx</stringProp></BeanShellSampler>
     <hashTree/>
   
-        <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Simple Product View" enabled="true">
+        <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Simple Product ${_counter} View" enabled="true">
             <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
                 <collectionProp name="Arguments.arguments"/>
             </elementProp>
@@ -4519,7 +4798,7 @@ vars.put("product_sku", product.get("sku"));
             <hashTree/>
         </hashTree>
     
-      <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Simple Product Add To Wishlist" enabled="true">
+      <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Simple Product ${_counter} Add To Wishlist" enabled="true">
         <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
           <collectionProp name="Arguments.arguments">
             <elementProp name="form_key" elementType="HTTPArgument">
@@ -4582,7 +4861,7 @@ vars.put("product_sku", product.get("sku"));
         <hashTree/>
       </hashTree>
   
-      <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Load Wishlist Section" enabled="true">
+      <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Load Wishlist Section ${_counter}" enabled="true">
         <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
           <collectionProp name="Arguments.arguments">
             <elementProp name="sections" elementType="HTTPArgument">
@@ -4656,7 +4935,7 @@ vars.put("product_sku", product.get("sku"));
         <boolProp name="CounterConfig.reset_on_tg_iteration">true</boolProp>
       </CounterConfig>
       <hashTree/>
-      <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Clear Wishlist" enabled="true">
+      <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Clear Wishlist ${counter}" enabled="true">
         <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
           <collectionProp name="Arguments.arguments">
             <elementProp name="form_key" elementType="HTTPArgument">
@@ -4723,7 +5002,18 @@ vars.put("product_sku", product.get("sku"));
         <intProp name="Assertion.test_type">2</intProp>
       </ResponseAssertion>
       <hashTree/>
-    </hashTree>
+    
+    <BeanShellPostProcessor guiclass="TestBeanGUI" testclass="BeanShellPostProcessor" testname="Return Customer to Pool" enabled="true">
+        <boolProp name="resetInterpreter">false</boolProp>
+        <stringProp name="parameters"/>
+        <stringProp name="filename"/>
+        <stringProp name="script">
+customerUserList = props.get("customer_emails_list");
+customerUserList.add(vars.get("customer_email"));
+        </stringProp>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/common/return_email_to_pool.jmx</stringProp></BeanShellPostProcessor>
+    <hashTree/>
+  </hashTree>
   </hashTree>
 
   
@@ -6522,44 +6812,31 @@ vars.put("category_name", props.get("category_names_list").get(number));
       <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/common/extract_category_setup.jmx</stringProp></BeanShellSampler>
       <hashTree/>
     
+    <CriticalSectionController guiclass="CriticalSectionControllerGui" testclass="CriticalSectionController" testname="Get Customer Email" enabled="true">
+        <stringProp name="CriticalSectionController.lockName">get-email</stringProp>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/lock_controller.jmx</stringProp></CriticalSectionController>
+    <hashTree>
+    
     <BeanShellSampler guiclass="BeanShellSamplerGui" testclass="BeanShellSampler" testname="SetUp - Get Customer Email" enabled="true">
       <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/get_customer_email.jmx</stringProp>
-      <stringProp name="BeanShellSampler.query">import org.apache.jmeter.samplers.SampleResult;
-
-String siterator = vars.get("customer_emails_index");
-int iterator;
-if(siterator == null){
-    iterator = 0;
-    vars.put("customer_emails_index", "0");
-} else {
-    iterator = Integer.parseInt(siterator);
-    iterator ++;
-    vars.put("customer_emails_index", iterator.toString());
-}
-
-emails_list = props.get("customer_emails_list");
-
-threadsNumber = ctx.getThreadGroup().getNumThreads();
-emailsCount = emails_list.size();
-if (threadsNumber &gt; emailsCount) {
-    log.error(" There are not enough customers for this scenario.");
-} else {
-    clusterLength = Math.round(emailsCount / threadsNumber);
-    threadNum = ctx.getThreadNum();
-    emails_index = clusterLength * threadNum + iterator;
-    maxLimit = clusterLength * (threadNum + 1);
-    if (emails_index &gt;= maxLimit) {
-        iterator = 0;
-        emails_index = clusterLength * threadNum + iterator;
-        vars.put("customer_emails_index", iterator.toString());
-    }
+      <stringProp name="BeanShellSampler.query">
+customerUserList = props.get("customer_emails_list");
+customerUser = customerUserList.poll();
+if (customerUser == null) {
+  SampleResult.setResponseMessage("customernUser list is empty");
+  SampleResult.setResponseData("customerUser list is empty","UTF-8");
+  IsSuccess=false;
+  SampleResult.setSuccessful(false);
+  SampleResult.setStopThread(true);
 }
-vars.put("customer_email", emails_list.get(emails_index));</stringProp>
+vars.put("customer_email", customerUser);
+      </stringProp>
       <stringProp name="BeanShellSampler.filename"/>
       <stringProp name="BeanShellSampler.parameters"/>
       <boolProp name="BeanShellSampler.resetInterpreter">true</boolProp>
     </BeanShellSampler>
     <hashTree/>
+  </hashTree>
   
       <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Open Home Page" enabled="true">
         <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
@@ -7742,32 +8019,26 @@ if(curSampler.getName().contains("Checkout success")) {
 </stringProp>
     <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/customer_checkout/checkout_clear_cookie.jmx</stringProp></BeanShellPostProcessor>
     <hashTree/>
+  
+    <BeanShellPostProcessor guiclass="TestBeanGUI" testclass="BeanShellPostProcessor" testname="Return Customer to Pool" enabled="true">
+        <boolProp name="resetInterpreter">false</boolProp>
+        <stringProp name="parameters"/>
+        <stringProp name="filename"/>
+        <stringProp name="script">
+customerUserList = props.get("customer_emails_list");
+customerUserList.add(vars.get("customer_email"));
+        </stringProp>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/common/return_email_to_pool.jmx</stringProp></BeanShellPostProcessor>
+    <hashTree/>
   </hashTree>
   </hashTree>
 
-  </hashTree>
-
-    
-        <ThreadGroup guiclass="ThreadGroupGui" testclass="ThreadGroup" testname="Admin Pool" enabled="true">
-            <stringProp name="ThreadGroup.on_sample_error">continue</stringProp>
-            <elementProp name="ThreadGroup.main_controller" elementType="LoopController" guiclass="LoopControlPanel" testclass="LoopController" testname="Loop Controller" enabled="true">
-                <boolProp name="LoopController.continue_forever">false</boolProp>
-                <stringProp name="LoopController.loops">${loops}</stringProp>
-            </elementProp>
-            <stringProp name="ThreadGroup.num_threads">${adminPoolUsers}</stringProp>
-            <stringProp name="ThreadGroup.ramp_time">${ramp_period}</stringProp>
-            <longProp name="ThreadGroup.start_time">1505803944000</longProp>
-            <longProp name="ThreadGroup.end_time">1505803944000</longProp>
-            <boolProp name="ThreadGroup.scheduler">false</boolProp>
-            <stringProp name="ThreadGroup.duration"/>
-            <stringProp name="ThreadGroup.delay"/>
-        <stringProp name="TestPlan.comments">mpaf/tool/fragments/_system/thread_group.jmx</stringProp></ThreadGroup>
-        <hashTree>
-    <ThroughputController guiclass="ThroughputControllerGui" testclass="ThroughputController" testname="Admin Edit Product" enabled="true">
+  
+    <ThroughputController guiclass="ThroughputControllerGui" testclass="ThroughputController" testname="Product Review By Customer" enabled="true">
       <intProp name="ThroughputController.style">1</intProp>
       <boolProp name="ThroughputController.perThread">false</boolProp>
       <intProp name="ThroughputController.maxThroughput">1</intProp>
-      <stringProp name="ThroughputController.percentThroughput">${adminProductEditingPercentage}</stringProp>
+      <stringProp name="ThroughputController.percentThroughput">${reviewByCustomerPercentage}</stringProp>
     <stringProp name="TestPlan.comments">mpaf/tool/fragments/_system/scenario_controller_tmpl.jmx</stringProp></ThroughputController>
     <hashTree>
         <JSR223PreProcessor guiclass="TestBeanGUI" testclass="JSR223PreProcessor" testname="Set Test Label" enabled="true">
@@ -7788,71 +8059,82 @@ if (testLabel
         <hashTree/>
         <BeanShellSampler guiclass="BeanShellSamplerGui" testclass="BeanShellSampler" testname="SetUp - Set Label" enabled="true">
             <stringProp name="BeanShellSampler.query">
-                vars.put("testLabel", "Admin Edit Product");
+                vars.put("testLabel", "Product Review By Customer");
             </stringProp>
             <boolProp name="BeanShellSampler.resetInterpreter">true</boolProp>
         </BeanShellSampler>
         <hashTree/>
     
-        <JSR223PostProcessor guiclass="TestBeanGUI" testclass="JSR223PostProcessor" testname="Get admin form key PostProcessor" enabled="true">
-        <stringProp name="script">
-        function getFormKeyFromResponse()
-        {
-            var url = prev.getUrlAsString(),
-            responseCode =  prev.getResponseCode(),
-            formKey = null;
-            searchPattern = /var FORM_KEY = '(.+)'/;
-            if (responseCode == "200" &amp;&amp; url) {
-                response = prev.getResponseDataAsString();
-                formKey = response  &amp;&amp; response.match(searchPattern) ? response.match(searchPattern)[1] : null;
-            }
-            return formKey;
-        }
-
-        formKey = vars.get("form_key_storage");
+    <CookieManager guiclass="CookiePanel" testclass="CookieManager" testname="HTTP Cookie Manager" enabled="true">
+      <collectionProp name="CookieManager.cookies">
+        <elementProp name="product_list_limit" elementType="Cookie" testname="product_list_limit">
+          <stringProp name="Cookie.value">30</stringProp>
+          <stringProp name="Cookie.domain">${host}</stringProp>
+          <stringProp name="Cookie.path">/</stringProp>
+          <boolProp name="Cookie.secure">false</boolProp>
+          <longProp name="Cookie.expires">0</longProp>
+          <boolProp name="Cookie.path_specified">true</boolProp>
+          <boolProp name="Cookie.domain_specified">true</boolProp>
+        </elementProp>
+        <elementProp name="product_list_limit" elementType="Cookie" testname="form_key">
+          <stringProp name="Cookie.value">${form_key}</stringProp>
+          <stringProp name="Cookie.domain">${host}</stringProp>
+          <stringProp name="Cookie.path">${base_path}</stringProp>
+          <boolProp name="Cookie.secure">false</boolProp>
+          <longProp name="Cookie.expires">0</longProp>
+          <boolProp name="Cookie.path_specified">true</boolProp>
+          <boolProp name="Cookie.domain_specified">true</boolProp>
+        </elementProp>
+      </collectionProp>
+      <boolProp name="CookieManager.clearEachIteration">true</boolProp>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/http_cookie_manager.jmx</stringProp></CookieManager>
+    <hashTree/>
+  
+      <BeanShellSampler guiclass="BeanShellSamplerGui" testclass="BeanShellSampler" testname="SetUp - Init Random Generator" enabled="true">
+        <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/common/init_random_generator_setup.jmx</stringProp>
+        <stringProp name="BeanShellSampler.query">
+import java.util.Random;
 
-	   currentFormKey = getFormKeyFromResponse();
+Random random = new Random();
+if (${seedForRandom} &gt; 0) {
+    random.setSeed(${seedForRandom} + ${__threadNum});
+}
 
-	   if (currentFormKey != null &amp;&amp; currentFormKey != formKey) {
-		  vars.put("form_key_storage", currentFormKey);
-	   }
+vars.putObject("randomIntGenerator", random);
         </stringProp>
-        <stringProp name="scriptLanguage">javascript</stringProp>
-        <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin/handle_admin_form_key.jmx</stringProp></JSR223PostProcessor>
-        <hashTree/>
-        <JSR223PreProcessor guiclass="TestBeanGUI" testclass="JSR223PreProcessor" testname="Set admin form key PreProcessor" enabled="true">
-            <stringProp name="script">
-                formKey =  vars.get("form_key_storage");
-                if (formKey
-                    &amp;&amp; sampler.getClass().getName() == 'org.apache.jmeter.protocol.http.sampler.HTTPSamplerProxy'
-                    &amp;&amp; sampler.getMethod() == "POST")
-                    {
-                        arguments = sampler.getArguments();
-                        for (i=0; i&lt;arguments.getArgumentCount(); i++)
-                        {
-                            argument = arguments.getArgument(i);
-                            if (argument.getName() == 'form_key' &amp;&amp; argument.getValue() != formKey) {
-                            log.info("admin form key updated: " + argument.getValue() + " =&gt; " + formKey);
-                            argument.setValue(formKey);
-                        }
-                    }
-                }
-            </stringProp>
-            <stringProp name="scriptLanguage">javascript</stringProp>
-        </JSR223PreProcessor>
-        <hashTree/>
+        <stringProp name="BeanShellSampler.filename"/>
+        <stringProp name="BeanShellSampler.parameters"/>
+        <boolProp name="BeanShellSampler.resetInterpreter">true</boolProp>
+      </BeanShellSampler>
+      <hashTree/>
     
-    <CookieManager guiclass="CookiePanel" testclass="CookieManager" testname="HTTP Cookie Manager" enabled="true">
-      <collectionProp name="CookieManager.cookies"/>
-      <boolProp name="CookieManager.clearEachIteration">false</boolProp>
-    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/http_cookie_manager_without_clear_each_iteration.jmx</stringProp></CookieManager>
+    <CriticalSectionController guiclass="CriticalSectionControllerGui" testclass="CriticalSectionController" testname="Get Customer Email" enabled="true">
+        <stringProp name="CriticalSectionController.lockName">get-email</stringProp>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/lock_controller.jmx</stringProp></CriticalSectionController>
+    <hashTree>
+    
+    <BeanShellSampler guiclass="BeanShellSamplerGui" testclass="BeanShellSampler" testname="SetUp - Get Customer Email" enabled="true">
+      <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/get_customer_email.jmx</stringProp>
+      <stringProp name="BeanShellSampler.query">
+customerUserList = props.get("customer_emails_list");
+customerUser = customerUserList.poll();
+if (customerUser == null) {
+  SampleResult.setResponseMessage("customernUser list is empty");
+  SampleResult.setResponseData("customerUser list is empty","UTF-8");
+  IsSuccess=false;
+  SampleResult.setSuccessful(false);
+  SampleResult.setStopThread(true);
+}
+vars.put("customer_email", customerUser);
+      </stringProp>
+      <stringProp name="BeanShellSampler.filename"/>
+      <stringProp name="BeanShellSampler.parameters"/>
+      <boolProp name="BeanShellSampler.resetInterpreter">true</boolProp>
+    </BeanShellSampler>
     <hashTree/>
+  </hashTree>
   
-    <OnceOnlyController guiclass="OnceOnlyControllerGui" testclass="OnceOnlyController" testname="Once Only Controller" enabled="true">
-  <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/once_only_controller.jmx</stringProp>
-</OnceOnlyController>
-    <hashTree>
-    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="SetUp - Login" enabled="true">
+    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Open Login Page" enabled="true">
       <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
         <collectionProp name="Arguments.arguments"/>
       </elementProp>
@@ -7862,7 +8144,7 @@ if (testLabel
       <stringProp name="HTTPSampler.response_timeout"/>
       <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
       <stringProp name="HTTPSampler.contentEncoding"/>
-      <stringProp name="HTTPSampler.path">${base_path}${admin_path}</stringProp>
+      <stringProp name="HTTPSampler.path">${base_path}customer/account/login/</stringProp>
       <stringProp name="HTTPSampler.method">GET</stringProp>
       <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
       <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
@@ -7870,28 +8152,87 @@ if (testLabel
       <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
       <boolProp name="HTTPSampler.monitor">false</boolProp>
       <stringProp name="HTTPSampler.embedded_url_re"/>
-    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_login/admin_login.jmx</stringProp></HTTPSamplerProxy>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/common/open_login_page.jmx</stringProp></HTTPSamplerProxy>
     <hashTree>
-      <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert login form shown" enabled="true">
+      <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Response Assertion" enabled="true">
         <collectionProp name="Asserion.test_strings">
-          <stringProp name="-1397214398">Welcome</stringProp>
-          <stringProp name="-515240035">&lt;title&gt;Magento Admin&lt;/title&gt;</stringProp>
+          <stringProp name="637394530">&lt;title&gt;Customer Login&lt;/title&gt;</stringProp>
         </collectionProp>
         <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
         <boolProp name="Assertion.assume_success">false</boolProp>
         <intProp name="Assertion.test_type">2</intProp>
       </ResponseAssertion>
       <hashTree/>
-      <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract form key" enabled="true">
+    </hashTree>
+  
+    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Login" enabled="true">
+      <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
+        <collectionProp name="Arguments.arguments">
+          <elementProp name="form_key" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">${form_key}</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">form_key</stringProp>
+          </elementProp>
+          <elementProp name="login[username]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">${customer_email}</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">login[username]</stringProp>
+          </elementProp>
+          <elementProp name="login[password]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">${customer_password}</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">login[password]</stringProp>
+          </elementProp>
+          <elementProp name="send" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value"/>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">send</stringProp>
+          </elementProp>
+        </collectionProp>
+      </elementProp>
+      <stringProp name="HTTPSampler.domain"/>
+      <stringProp name="HTTPSampler.port"/>
+      <stringProp name="HTTPSampler.connect_timeout"/>
+      <stringProp name="HTTPSampler.response_timeout"/>
+      <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
+      <stringProp name="HTTPSampler.contentEncoding"/>
+      <stringProp name="HTTPSampler.path">${base_path}customer/account/loginPost/</stringProp>
+      <stringProp name="HTTPSampler.method">POST</stringProp>
+      <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
+      <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
+      <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
+      <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
+      <boolProp name="HTTPSampler.monitor">false</boolProp>
+      <stringProp name="HTTPSampler.embedded_url_re"/>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/common/login.jmx</stringProp></HTTPSamplerProxy>
+    <hashTree>
+      <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Response Assertion" enabled="true">
+        <collectionProp name="Asserion.test_strings">
+          <stringProp name="1312950388">&lt;title&gt;My Account&lt;/title&gt;</stringProp>
+        </collectionProp>
+        <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
+        <boolProp name="Assertion.assume_success">false</boolProp>
+        <intProp name="Assertion.test_type">2</intProp>
+      </ResponseAssertion>
+      <hashTree/>
+      <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract Address" enabled="true">
         <stringProp name="RegexExtractor.useHeaders">false</stringProp>
-        <stringProp name="RegexExtractor.refname">admin_form_key</stringProp>
-        <stringProp name="RegexExtractor.regex">&lt;input name="form_key" type="hidden" value="([^'"]+)" /&gt;</stringProp>
+        <stringProp name="RegexExtractor.refname">addressId</stringProp>
+        <stringProp name="RegexExtractor.regex">customer/address/edit/id/([^'"]+)/</stringProp>
         <stringProp name="RegexExtractor.template">$1$</stringProp>
         <stringProp name="RegexExtractor.default"/>
         <stringProp name="RegexExtractor.match_number">1</stringProp>
       </RegexExtractor>
       <hashTree/>
-      <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert form_key extracted" enabled="true">
+      <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert addressId extracted" enabled="true">
         <collectionProp name="Asserion.test_strings">
           <stringProp name="2845929">^.+$</stringProp>
         </collectionProp>
@@ -7899,41 +8240,164 @@ if (testLabel
         <boolProp name="Assertion.assume_success">false</boolProp>
         <intProp name="Assertion.test_type">1</intProp>
         <stringProp name="Assertion.scope">variable</stringProp>
-        <stringProp name="Scope.variable">admin_form_key</stringProp>
+        <stringProp name="Scope.variable">addressId</stringProp>
       </ResponseAssertion>
       <hashTree/>
     </hashTree>
-  
-    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="SetUp - Login Submit Form" enabled="true">
+    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Load Customer Private Data" enabled="true">
       <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
         <collectionProp name="Arguments.arguments">
-          <elementProp name="dummy" elementType="HTTPArgument">
+          <elementProp name="sections" elementType="HTTPArgument">
             <boolProp name="HTTPArgument.always_encode">true</boolProp>
             <stringProp name="Argument.value"/>
             <stringProp name="Argument.metadata">=</stringProp>
             <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">dummy</stringProp>
+            <stringProp name="Argument.name">sections</stringProp>
+          </elementProp>
+          <elementProp name="update_section_id" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">false</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">update_section_id</stringProp>
+          </elementProp>
+          <elementProp name="_" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">${__time()}${__Random(1,1000000)}</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">_</stringProp>
           </elementProp>
+        </collectionProp>
+      </elementProp>
+      <stringProp name="HTTPSampler.domain"/>
+      <stringProp name="HTTPSampler.port"/>
+      <stringProp name="HTTPSampler.connect_timeout"/>
+      <stringProp name="HTTPSampler.response_timeout"/>
+      <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
+      <stringProp name="HTTPSampler.contentEncoding"/>
+      <stringProp name="HTTPSampler.path">${base_path}customer/section/load/</stringProp>
+      <stringProp name="HTTPSampler.method">GET</stringProp>
+      <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
+      <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
+      <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
+      <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
+      <boolProp name="HTTPSampler.monitor">false</boolProp>
+      <stringProp name="HTTPSampler.embedded_url_re"/>
+    </HTTPSamplerProxy>
+    <hashTree/>
+  
+    <LoopController guiclass="LoopControlPanel" testclass="LoopController" testname="Review Simple Products" enabled="true">
+      <boolProp name="LoopController.continue_forever">true</boolProp>
+      <stringProp name="LoopController.loops">1</stringProp>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/loop_controller.jmx</stringProp></LoopController>
+    <hashTree>
+      <CounterConfig guiclass="CounterConfigGui" testclass="CounterConfig" testname="Counter" enabled="true">
+        <stringProp name="CounterConfig.start">1</stringProp>
+        <stringProp name="CounterConfig.end"/>
+        <stringProp name="CounterConfig.incr">1</stringProp>
+        <stringProp name="CounterConfig.name">_counter</stringProp>
+        <stringProp name="CounterConfig.format"/>
+        <boolProp name="CounterConfig.per_user">true</boolProp>
+        <boolProp name="CounterConfig.reset_on_tg_iteration">true</boolProp>
+      </CounterConfig>
+      <hashTree/>
+    
+    <BeanShellSampler guiclass="BeanShellSamplerGui" testclass="BeanShellSampler" testname="SetUp - Prepare Simple Product Data" enabled="true">
+      <stringProp name="BeanShellSampler.query">
+import java.util.Random;
+
+Random random = vars.getObject("randomIntGenerator");
+number = random.nextInt(props.get("simple_products_list").size());
+product = props.get("simple_products_list").get(number);
+
+vars.put("product_url_key", product.get("url_key"));
+vars.put("product_id", product.get("id"));
+vars.put("product_name", product.get("title"));
+vars.put("product_uenc", product.get("uenc"));
+vars.put("product_sku", product.get("sku"));
+      </stringProp>
+      <stringProp name="BeanShellSampler.filename"/>
+      <stringProp name="BeanShellSampler.parameters"/>
+      <boolProp name="BeanShellSampler.resetInterpreter">true</boolProp>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/product_browsing_and_adding_items_to_the_cart/simple_products_setup.jmx</stringProp></BeanShellSampler>
+    <hashTree/>
+  
+        <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Simple Product ${_counter} View" enabled="true">
+            <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
+                <collectionProp name="Arguments.arguments"/>
+            </elementProp>
+            <stringProp name="HTTPSampler.domain"/>
+            <stringProp name="HTTPSampler.port"/>
+            <stringProp name="HTTPSampler.connect_timeout"/>
+            <stringProp name="HTTPSampler.response_timeout"/>
+            <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
+            <stringProp name="HTTPSampler.contentEncoding"/>
+            <stringProp name="HTTPSampler.path">${base_path}${product_url_key}${url_suffix}</stringProp>
+            <stringProp name="HTTPSampler.method">GET</stringProp>
+            <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
+            <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
+            <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
+            <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
+            <boolProp name="HTTPSampler.monitor">false</boolProp>
+            <stringProp name="HTTPSampler.embedded_url_re"/>
+        <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/product_browsing_and_adding_items_to_the_cart/product_view.jmx</stringProp></HTTPSamplerProxy>
+        <hashTree>
+            <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Response Assertion" enabled="true">
+                <collectionProp name="Asserion.test_strings">
+                    <stringProp name="-1787050162">&lt;span&gt;In stock&lt;/span&gt;</stringProp>
+                </collectionProp>
+                <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
+                <boolProp name="Assertion.assume_success">false</boolProp>
+                <intProp name="Assertion.test_type">2</intProp>
+            </ResponseAssertion>
+            <hashTree/>
+        </hashTree>
+    
+    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Simple Product 1 Rate and Review" enabled="true">
+      <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
+        <collectionProp name="Arguments.arguments">
           <elementProp name="form_key" elementType="HTTPArgument">
             <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">${admin_form_key}</stringProp>
+            <stringProp name="Argument.value">${form_key}</stringProp>
             <stringProp name="Argument.metadata">=</stringProp>
             <boolProp name="HTTPArgument.use_equals">true</boolProp>
             <stringProp name="Argument.name">form_key</stringProp>
           </elementProp>
-          <elementProp name="login[password]" elementType="HTTPArgument">
+          <elementProp name="ratings[1]" elementType="HTTPArgument">
             <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">${admin_password}</stringProp>
+            <stringProp name="Argument.value">3</stringProp>
             <stringProp name="Argument.metadata">=</stringProp>
             <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">login[password]</stringProp>
+            <stringProp name="Argument.name">ratings[1]</stringProp>
           </elementProp>
-          <elementProp name="login[username]" elementType="HTTPArgument">
+          <elementProp name="validate_rating" elementType="HTTPArgument">
             <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">${admin_user}</stringProp>
+            <stringProp name="Argument.value"/>
             <stringProp name="Argument.metadata">=</stringProp>
             <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">login[username]</stringProp>
+            <stringProp name="Argument.name">validate_rating</stringProp>
+          </elementProp>
+          <elementProp name="nickname" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">FirstName</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">nickname</stringProp>
+          </elementProp>
+          <elementProp name="title" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">Some Review Title</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">title</stringProp>
+          </elementProp>
+          <elementProp name="detail" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">Some Review Text</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">detail</stringProp>
           </elementProp>
         </collectionProp>
       </elementProp>
@@ -7943,14646 +8407,815 @@ if (testLabel
       <stringProp name="HTTPSampler.response_timeout"/>
       <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
       <stringProp name="HTTPSampler.contentEncoding"/>
-      <stringProp name="HTTPSampler.path">${base_path}${admin_path}/admin/dashboard/</stringProp>
+      <stringProp name="HTTPSampler.path">${base_path}review/product/post/id/${product_id}</stringProp>
       <stringProp name="HTTPSampler.method">POST</stringProp>
       <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
       <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
       <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
       <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
-      <stringProp name="HTTPSampler.implementation">Java</stringProp>
       <boolProp name="HTTPSampler.monitor">false</boolProp>
       <stringProp name="HTTPSampler.embedded_url_re"/>
-      <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_login/admin_login_submit_form.jmx</stringProp>
-    </HTTPSamplerProxy>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/product_review/product_review.jmx</stringProp></HTTPSamplerProxy>
     <hashTree>
-        <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract form key" enabled="true">
-            <stringProp name="RegexExtractor.useHeaders">false</stringProp>
-            <stringProp name="RegexExtractor.refname">admin_form_key</stringProp>
-            <stringProp name="RegexExtractor.regex">&lt;input name="form_key" type="hidden" value="([^'"]+)" /&gt;</stringProp>
-            <stringProp name="RegexExtractor.template">$1$</stringProp>
-            <stringProp name="RegexExtractor.default"/>
-            <stringProp name="RegexExtractor.match_number">1</stringProp>
-        <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_login/admin_retrieve_form_key.jmx</stringProp></RegexExtractor>
-        <hashTree/>
+      <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Response Assertion" enabled="true">
+        <collectionProp name="Asserion.test_strings">
+          <stringProp name="-1606201635">HTTP/1.1 200 OK</stringProp>
+        </collectionProp>
+        <stringProp name="Assertion.test_field">Assertion.response_headers</stringProp>
+        <boolProp name="Assertion.assume_success">false</boolProp>
+        <intProp name="Assertion.test_type">16</intProp>
+      </ResponseAssertion>
+      <hashTree/>
     </hashTree>
+  
+    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Load Review Section" enabled="true">
+      <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
+        <collectionProp name="Arguments.arguments">
+          <elementProp name="sections" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">review,messages</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">sections</stringProp>
+          </elementProp>
+          <elementProp name="update_section_id" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">false</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">update_section_id</stringProp>
+          </elementProp>
+          <elementProp name="_" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">${__time()}${__Random(1,1000000)}</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">_</stringProp>
+          </elementProp>
+        </collectionProp>
+      </elementProp>
+      <stringProp name="HTTPSampler.domain"/>
+      <stringProp name="HTTPSampler.port"/>
+      <stringProp name="HTTPSampler.connect_timeout"/>
+      <stringProp name="HTTPSampler.response_timeout"/>
+      <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
+      <stringProp name="HTTPSampler.contentEncoding"/>
+      <stringProp name="HTTPSampler.path">${base_path}customer/section/load/</stringProp>
+      <stringProp name="HTTPSampler.method">GET</stringProp>
+      <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
+      <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
+      <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
+      <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
+      <boolProp name="HTTPSampler.monitor">false</boolProp>
+      <stringProp name="HTTPSampler.embedded_url_re"/>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/product_review/load_review.jmx</stringProp></HTTPSamplerProxy>
+    <hashTree/>
+  
+    <TestAction guiclass="TestActionGui" testclass="TestAction" testname="Product Rating and Review - Pause" enabled="true">
+      <intProp name="ActionProcessor.action">1</intProp>
+      <intProp name="ActionProcessor.target">0</intProp>
+      <stringProp name="ActionProcessor.duration">${__javaScript(Math.round(${reviewDelay}*1000))}</stringProp>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/product_review/product_review_pause.jmx</stringProp></TestAction>
+    <hashTree/>
   </hashTree>
   
-    <GenericController guiclass="LogicControllerGui" testclass="GenericController" testname="Simple Controller" enabled="true">
-  <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/simple_controller.jmx</stringProp>
-</GenericController>
+    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Logout" enabled="true">
+      <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
+        <collectionProp name="Arguments.arguments"/>
+      </elementProp>
+      <stringProp name="HTTPSampler.domain"/>
+      <stringProp name="HTTPSampler.port"/>
+      <stringProp name="HTTPSampler.connect_timeout"/>
+      <stringProp name="HTTPSampler.response_timeout"/>
+      <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
+      <stringProp name="HTTPSampler.contentEncoding"/>
+      <stringProp name="HTTPSampler.path">${base_path}customer/account/logout/</stringProp>
+      <stringProp name="HTTPSampler.method">GET</stringProp>
+      <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
+      <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
+      <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
+      <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
+      <boolProp name="HTTPSampler.monitor">false</boolProp>
+      <stringProp name="HTTPSampler.embedded_url_re"/>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/common/logout.jmx</stringProp></HTTPSamplerProxy>
     <hashTree>
-    <TestFragmentController guiclass="TestFragmentControllerGui" testclass="TestFragmentController" testname="Admin Edit Product" enabled="true"/>
-              <hashTree>
-                <BeanShellSampler guiclass="BeanShellSamplerGui" testclass="BeanShellSampler" testname="SetUp - Generate Unique Ids for each Thread" enabled="true">
-                  <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_edit_product/admin_edit_product_updated.jmx</stringProp>
-                  <stringProp name="BeanShellSampler.query">import java.util.ArrayList;
-    import java.util.HashMap;
-
-try {
-    simpleCount = props.get("simple_products_list").size();
-    configCount = props.get("configurable_products_list").size();
-    productCount = 0;
-    if (simpleCount &gt; configCount) {
-    	productCount = configCount;
-    } else {
-    	productCount = simpleCount;
-    }
-    int threadsNumber = ctx.getThreadGroup().getNumThreads();
-    if (threadsNumber == 0) {
-    	threadsNumber = 1;
-    }
-    //Current thread number starts from 0
-    currentThreadNum = ctx.getThreadNum();
+      <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert success" enabled="true">
+        <collectionProp name="Asserion.test_strings">
+          <stringProp name="1723813687">You are signed out.</stringProp>
+        </collectionProp>
+        <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
+        <boolProp name="Assertion.assume_success">false</boolProp>
+        <intProp name="Assertion.test_type">2</intProp>
+      </ResponseAssertion>
+      <hashTree/>
+    
+    <BeanShellPostProcessor guiclass="TestBeanGUI" testclass="BeanShellPostProcessor" testname="Return Customer to Pool" enabled="true">
+        <boolProp name="resetInterpreter">false</boolProp>
+        <stringProp name="parameters"/>
+        <stringProp name="filename"/>
+        <stringProp name="script">
+customerUserList = props.get("customer_emails_list");
+customerUserList.add(vars.get("customer_email"));
+        </stringProp>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/common/return_email_to_pool.jmx</stringProp></BeanShellPostProcessor>
+    <hashTree/>
+  </hashTree>
+  </hashTree>
 
-    String siterator = vars.get("threadIterator_" + currentThreadNum.toString());
-    iterator = 0;
-    if(siterator == null){
-    	vars.put("threadIterator_" + currentThreadNum.toString() , "0");
-    } else {
-    	iterator = Integer.parseInt(siterator);
-    	iterator ++;
-    	vars.put("threadIterator_" + currentThreadNum.toString() , iterator.toString());
+  
+    <ThroughputController guiclass="ThroughputControllerGui" testclass="ThroughputController" testname="Add To Cart By Customer" enabled="true">
+      <intProp name="ThroughputController.style">1</intProp>
+      <boolProp name="ThroughputController.perThread">false</boolProp>
+      <intProp name="ThroughputController.maxThroughput">1</intProp>
+      <stringProp name="ThroughputController.percentThroughput">${addToCartByCustomerPercentage}</stringProp>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/_system/scenario_controller_tmpl.jmx</stringProp></ThroughputController>
+    <hashTree>
+        <JSR223PreProcessor guiclass="TestBeanGUI" testclass="JSR223PreProcessor" testname="Set Test Label" enabled="true">
+            <stringProp name="script">
+var testLabel = "${testLabel}" ? " (${testLabel})" : "";
+if (testLabel
+    &amp;&amp; sampler.getClass().getName() == 'org.apache.jmeter.protocol.http.sampler.HTTPSamplerProxy'
+) {
+    if (sampler.getName().indexOf(testLabel) == -1) {
+       sampler.setName(sampler.getName() + testLabel);
     }
+} else if (sampler.getName().indexOf("SetUp - ") == -1) {
+    sampler.setName("SetUp - " + sampler.getName());
+}
+            </stringProp>
+            <stringProp name="scriptLanguage">javascript</stringProp>
+        <stringProp name="TestPlan.comments">mpaf/tool/fragments/_system/setup_label.jmx</stringProp></JSR223PreProcessor>
+        <hashTree/>
+        <BeanShellSampler guiclass="BeanShellSamplerGui" testclass="BeanShellSampler" testname="SetUp - Set Label" enabled="true">
+            <stringProp name="BeanShellSampler.query">
+                vars.put("testLabel", "Add To Cart By Customer");
+            </stringProp>
+            <boolProp name="BeanShellSampler.resetInterpreter">true</boolProp>
+        </BeanShellSampler>
+        <hashTree/>
+    
+    <CookieManager guiclass="CookiePanel" testclass="CookieManager" testname="HTTP Cookie Manager" enabled="true">
+      <collectionProp name="CookieManager.cookies">
+        <elementProp name="product_list_limit" elementType="Cookie" testname="product_list_limit">
+          <stringProp name="Cookie.value">30</stringProp>
+          <stringProp name="Cookie.domain">${host}</stringProp>
+          <stringProp name="Cookie.path">/</stringProp>
+          <boolProp name="Cookie.secure">false</boolProp>
+          <longProp name="Cookie.expires">0</longProp>
+          <boolProp name="Cookie.path_specified">true</boolProp>
+          <boolProp name="Cookie.domain_specified">true</boolProp>
+        </elementProp>
+        <elementProp name="product_list_limit" elementType="Cookie" testname="form_key">
+          <stringProp name="Cookie.value">${form_key}</stringProp>
+          <stringProp name="Cookie.domain">${host}</stringProp>
+          <stringProp name="Cookie.path">${base_path}</stringProp>
+          <boolProp name="Cookie.secure">false</boolProp>
+          <longProp name="Cookie.expires">0</longProp>
+          <boolProp name="Cookie.path_specified">true</boolProp>
+          <boolProp name="Cookie.domain_specified">true</boolProp>
+        </elementProp>
+      </collectionProp>
+      <boolProp name="CookieManager.clearEachIteration">true</boolProp>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/http_cookie_manager.jmx</stringProp></CookieManager>
+    <hashTree/>
+  
+      <BeanShellSampler guiclass="BeanShellSamplerGui" testclass="BeanShellSampler" testname="SetUp - Init Random Generator" enabled="true">
+        <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/common/init_random_generator_setup.jmx</stringProp>
+        <stringProp name="BeanShellSampler.query">
+import java.util.Random;
 
-    //Number of products for one thread
-    productClusterLength = productCount / threadsNumber;
+Random random = new Random();
+if (${seedForRandom} &gt; 0) {
+    random.setSeed(${seedForRandom} + ${__threadNum});
+}
 
-    if (iterator &gt;= productClusterLength) {
-    	vars.put("threadIterator_" + currentThreadNum.toString(), "0");
-    	iterator = 0;
-    }
+vars.putObject("randomIntGenerator", random);
+        </stringProp>
+        <stringProp name="BeanShellSampler.filename"/>
+        <stringProp name="BeanShellSampler.parameters"/>
+        <boolProp name="BeanShellSampler.resetInterpreter">true</boolProp>
+      </BeanShellSampler>
+      <hashTree/>
+    
+      <BeanShellSampler guiclass="BeanShellSamplerGui" testclass="BeanShellSampler" testname="SetUp - Init Total Products In Cart" enabled="true">
+        <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/common/init_total_products_in_cart_setup.jmx</stringProp>
+        <stringProp name="BeanShellSampler.query">
+vars.put("totalProductsAdded", "0");
+        </stringProp>
+        <stringProp name="BeanShellSampler.filename"/>
+        <stringProp name="BeanShellSampler.parameters"/>
+        <boolProp name="BeanShellSampler.resetInterpreter">true</boolProp>
+      </BeanShellSampler>
+      <hashTree/>
+    
+      <BeanShellSampler guiclass="BeanShellSamplerGui" testclass="BeanShellSampler" testname="SetUp - Prepare Category Data" enabled="true">
+        <stringProp name="BeanShellSampler.query">
+import java.util.Random;
 
-    //Index of the current product from the cluster
-    i = productClusterLength * currentThreadNum + iterator;
+Random random = vars.getObject("randomIntGenerator");
+number = random.nextInt(props.get("category_url_keys_list").size());
 
-    //ids of simple and configurable products to edit
-    vars.put("simple_product_id", props.get("simple_products_list").get(i).get("id"));
-    vars.put("configurable_product_id", props.get("configurable_products_list").get(i).get("id"));
+vars.put("category_url_key", props.get("category_url_keys_list").get(number));
+vars.put("category_name", props.get("category_names_list").get(number));
+        </stringProp>
+        <stringProp name="BeanShellSampler.filename"/>
+        <stringProp name="BeanShellSampler.parameters"/>
+        <boolProp name="BeanShellSampler.resetInterpreter">false</boolProp>
+      <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/common/extract_category_setup.jmx</stringProp></BeanShellSampler>
+      <hashTree/>
+    
+    <CriticalSectionController guiclass="CriticalSectionControllerGui" testclass="CriticalSectionController" testname="Get Customer Email" enabled="true">
+        <stringProp name="CriticalSectionController.lockName">get-email</stringProp>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/lock_controller.jmx</stringProp></CriticalSectionController>
+    <hashTree>
+    
+    <BeanShellSampler guiclass="BeanShellSamplerGui" testclass="BeanShellSampler" testname="SetUp - Get Customer Email" enabled="true">
+      <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/get_customer_email.jmx</stringProp>
+      <stringProp name="BeanShellSampler.query">
+customerUserList = props.get("customer_emails_list");
+customerUser = customerUserList.poll();
+if (customerUser == null) {
+  SampleResult.setResponseMessage("customernUser list is empty");
+  SampleResult.setResponseData("customerUser list is empty","UTF-8");
+  IsSuccess=false;
+  SampleResult.setSuccessful(false);
+  SampleResult.setStopThread(true);
+}
+vars.put("customer_email", customerUser);
+      </stringProp>
+      <stringProp name="BeanShellSampler.filename"/>
+      <stringProp name="BeanShellSampler.parameters"/>
+      <boolProp name="BeanShellSampler.resetInterpreter">true</boolProp>
+    </BeanShellSampler>
+    <hashTree/>
+  </hashTree>
+  
+    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Open Login Page" enabled="true">
+      <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
+        <collectionProp name="Arguments.arguments"/>
+      </elementProp>
+      <stringProp name="HTTPSampler.domain"/>
+      <stringProp name="HTTPSampler.port"/>
+      <stringProp name="HTTPSampler.connect_timeout"/>
+      <stringProp name="HTTPSampler.response_timeout"/>
+      <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
+      <stringProp name="HTTPSampler.contentEncoding"/>
+      <stringProp name="HTTPSampler.path">${base_path}customer/account/login/</stringProp>
+      <stringProp name="HTTPSampler.method">GET</stringProp>
+      <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
+      <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
+      <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
+      <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
+      <boolProp name="HTTPSampler.monitor">false</boolProp>
+      <stringProp name="HTTPSampler.embedded_url_re"/>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/common/open_login_page.jmx</stringProp></HTTPSamplerProxy>
+    <hashTree>
+      <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Response Assertion" enabled="true">
+        <collectionProp name="Asserion.test_strings">
+          <stringProp name="637394530">&lt;title&gt;Customer Login&lt;/title&gt;</stringProp>
+        </collectionProp>
+        <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
+        <boolProp name="Assertion.assume_success">false</boolProp>
+        <intProp name="Assertion.test_type">2</intProp>
+      </ResponseAssertion>
+      <hashTree/>
+    </hashTree>
+  
+    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Login" enabled="true">
+      <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
+        <collectionProp name="Arguments.arguments">
+          <elementProp name="form_key" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">${form_key}</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">form_key</stringProp>
+          </elementProp>
+          <elementProp name="login[username]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">${customer_email}</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">login[username]</stringProp>
+          </elementProp>
+          <elementProp name="login[password]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">${customer_password}</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">login[password]</stringProp>
+          </elementProp>
+          <elementProp name="send" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value"/>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">send</stringProp>
+          </elementProp>
+        </collectionProp>
+      </elementProp>
+      <stringProp name="HTTPSampler.domain"/>
+      <stringProp name="HTTPSampler.port"/>
+      <stringProp name="HTTPSampler.connect_timeout"/>
+      <stringProp name="HTTPSampler.response_timeout"/>
+      <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
+      <stringProp name="HTTPSampler.contentEncoding"/>
+      <stringProp name="HTTPSampler.path">${base_path}customer/account/loginPost/</stringProp>
+      <stringProp name="HTTPSampler.method">POST</stringProp>
+      <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
+      <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
+      <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
+      <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
+      <boolProp name="HTTPSampler.monitor">false</boolProp>
+      <stringProp name="HTTPSampler.embedded_url_re"/>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/common/login.jmx</stringProp></HTTPSamplerProxy>
+    <hashTree>
+      <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Response Assertion" enabled="true">
+        <collectionProp name="Asserion.test_strings">
+          <stringProp name="1312950388">&lt;title&gt;My Account&lt;/title&gt;</stringProp>
+        </collectionProp>
+        <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
+        <boolProp name="Assertion.assume_success">false</boolProp>
+        <intProp name="Assertion.test_type">2</intProp>
+      </ResponseAssertion>
+      <hashTree/>
+      <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract Address" enabled="true">
+        <stringProp name="RegexExtractor.useHeaders">false</stringProp>
+        <stringProp name="RegexExtractor.refname">addressId</stringProp>
+        <stringProp name="RegexExtractor.regex">customer/address/edit/id/([^'"]+)/</stringProp>
+        <stringProp name="RegexExtractor.template">$1$</stringProp>
+        <stringProp name="RegexExtractor.default"/>
+        <stringProp name="RegexExtractor.match_number">1</stringProp>
+      </RegexExtractor>
+      <hashTree/>
+      <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert addressId extracted" enabled="true">
+        <collectionProp name="Asserion.test_strings">
+          <stringProp name="2845929">^.+$</stringProp>
+        </collectionProp>
+        <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
+        <boolProp name="Assertion.assume_success">false</boolProp>
+        <intProp name="Assertion.test_type">1</intProp>
+        <stringProp name="Assertion.scope">variable</stringProp>
+        <stringProp name="Scope.variable">addressId</stringProp>
+      </ResponseAssertion>
+      <hashTree/>
+    </hashTree>
+    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Load Customer Private Data" enabled="true">
+      <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
+        <collectionProp name="Arguments.arguments">
+          <elementProp name="sections" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value"/>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">sections</stringProp>
+          </elementProp>
+          <elementProp name="update_section_id" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">false</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">update_section_id</stringProp>
+          </elementProp>
+          <elementProp name="_" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">${__time()}${__Random(1,1000000)}</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">_</stringProp>
+          </elementProp>
+        </collectionProp>
+      </elementProp>
+      <stringProp name="HTTPSampler.domain"/>
+      <stringProp name="HTTPSampler.port"/>
+      <stringProp name="HTTPSampler.connect_timeout"/>
+      <stringProp name="HTTPSampler.response_timeout"/>
+      <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
+      <stringProp name="HTTPSampler.contentEncoding"/>
+      <stringProp name="HTTPSampler.path">${base_path}customer/section/load/</stringProp>
+      <stringProp name="HTTPSampler.method">GET</stringProp>
+      <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
+      <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
+      <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
+      <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
+      <boolProp name="HTTPSampler.monitor">false</boolProp>
+      <stringProp name="HTTPSampler.embedded_url_re"/>
+    </HTTPSamplerProxy>
+    <hashTree/>
+  
+      <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Open Home Page" enabled="true">
+        <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
+          <collectionProp name="Arguments.arguments"/>
+        </elementProp>
+        <stringProp name="HTTPSampler.domain"/>
+        <stringProp name="HTTPSampler.port"/>
+        <stringProp name="HTTPSampler.connect_timeout"/>
+        <stringProp name="HTTPSampler.response_timeout"/>
+        <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
+        <stringProp name="HTTPSampler.contentEncoding"/>
+        <stringProp name="HTTPSampler.path">${base_path}</stringProp>
+        <stringProp name="HTTPSampler.method">GET</stringProp>
+        <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
+        <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
+        <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
+        <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
+        <boolProp name="HTTPSampler.monitor">false</boolProp>
+        <stringProp name="HTTPSampler.embedded_url_re"/>
+      <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/common/open_home_page.jmx</stringProp></HTTPSamplerProxy>
+      <hashTree>
+        <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Response Assertion" enabled="true">
+          <collectionProp name="Asserion.test_strings">
+            <stringProp name="571386695">&lt;title&gt;Home page&lt;/title&gt;</stringProp>
+          </collectionProp>
+          <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
+          <boolProp name="Assertion.assume_success">false</boolProp>
+          <intProp name="Assertion.test_type">2</intProp>
+        </ResponseAssertion>
+        <hashTree/>
+      </hashTree>
+  
+    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Open Category" enabled="true">
+      <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
+        <collectionProp name="Arguments.arguments"/>
+      </elementProp>
+      <stringProp name="HTTPSampler.domain"/>
+      <stringProp name="HTTPSampler.port"/>
+      <stringProp name="HTTPSampler.connect_timeout"/>
+      <stringProp name="HTTPSampler.response_timeout"/>
+      <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
+      <stringProp name="HTTPSampler.contentEncoding"/>
+      <stringProp name="HTTPSampler.path">${base_path}${category_url_key}${url_suffix}</stringProp>
+      <stringProp name="HTTPSampler.method">GET</stringProp>
+      <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
+      <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
+      <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
+      <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
+      <boolProp name="HTTPSampler.monitor">false</boolProp>
+      <stringProp name="HTTPSampler.embedded_url_re"/>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/common/open_category.jmx</stringProp></HTTPSamplerProxy>
+    <hashTree>
+      <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Response Assertion" enabled="true">
+        <collectionProp name="Asserion.test_strings">
+          <stringProp name="1210004667">&lt;span class="base" data-ui-id="page-title"&gt;${category_name}&lt;/span&gt;</stringProp>
+        </collectionProp>
+        <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
+        <boolProp name="Assertion.assume_success">false</boolProp>
+        <intProp name="Assertion.test_type">6</intProp>
+      </ResponseAssertion>
+      <hashTree/>
+      <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Regular Expression Extractor: Extract category id" enabled="true">
+        <stringProp name="RegexExtractor.useHeaders">false</stringProp>
+        <stringProp name="RegexExtractor.refname">category_id</stringProp>
+        <stringProp name="RegexExtractor.regex">&lt;li class="item category([^'"]+)"&gt;\s*&lt;strong&gt;${category_name}&lt;/strong&gt;\s*&lt;/li&gt;</stringProp>
+        <stringProp name="RegexExtractor.template">$1$</stringProp>
+        <stringProp name="RegexExtractor.default"/>
+        <stringProp name="RegexExtractor.match_number">1</stringProp>
+        <stringProp name="Scope.variable">simple_product_1_url_key</stringProp>
+      </RegexExtractor>
+      <hashTree/>
+      <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Response Assertion: Assert category id" enabled="true">
+        <collectionProp name="Asserion.test_strings">
+          <stringProp name="1191417111">^[0-9]+$</stringProp>
+        </collectionProp>
+        <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
+        <boolProp name="Assertion.assume_success">false</boolProp>
+        <intProp name="Assertion.test_type">1</intProp>
+        <stringProp name="Assertion.scope">variable</stringProp>
+        <stringProp name="Scope.variable">category_id</stringProp>
+      </ResponseAssertion>
+      <hashTree/>
+    </hashTree>
+  
+    <LoopController guiclass="LoopControlPanel" testclass="LoopController" testname="Add Simple Products to Cart" enabled="true">
+      <boolProp name="LoopController.continue_forever">true</boolProp>
+      <stringProp name="LoopController.loops">2</stringProp>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/loop_controller.jmx</stringProp></LoopController>
+    <hashTree>
+      <CounterConfig guiclass="CounterConfigGui" testclass="CounterConfig" testname="Counter" enabled="true">
+        <stringProp name="CounterConfig.start">1</stringProp>
+        <stringProp name="CounterConfig.end"/>
+        <stringProp name="CounterConfig.incr">1</stringProp>
+        <stringProp name="CounterConfig.name">_counter</stringProp>
+        <stringProp name="CounterConfig.format"/>
+        <boolProp name="CounterConfig.per_user">true</boolProp>
+        <boolProp name="CounterConfig.reset_on_tg_iteration">true</boolProp>
+      </CounterConfig>
+      <hashTree/>
+    
+    <BeanShellSampler guiclass="BeanShellSamplerGui" testclass="BeanShellSampler" testname="SetUp - Prepare Simple Product Data" enabled="true">
+      <stringProp name="BeanShellSampler.query">
+import java.util.Random;
 
-    //id of related product
-    do {
-    	relatedIndex = (int)(Math.random() * props.get("simple_products_list").size());
-    } while(i == relatedIndex);
-    vars.put("related_product_id", props.get("simple_products_list").get(relatedIndex).get("id"));
-    } catch (Exception ex) {
-    log.info("Script execution failed", ex);
-}</stringProp>
-                  <stringProp name="BeanShellSampler.filename"/>
-                  <stringProp name="BeanShellSampler.parameters"/>
-                  <boolProp name="BeanShellSampler.resetInterpreter">false</boolProp>
-                </BeanShellSampler>
-                <hashTree/>
-                <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Edit Simple Product" enabled="true">
-                  <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
-                    <collectionProp name="Arguments.arguments"/>
-                  </elementProp>
-                  <stringProp name="HTTPSampler.domain"/>
-                  <stringProp name="HTTPSampler.port"/>
-                  <stringProp name="HTTPSampler.connect_timeout"/>
-                  <stringProp name="HTTPSampler.response_timeout"/>
-                  <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
-                  <stringProp name="HTTPSampler.contentEncoding"/>
-                  <stringProp name="HTTPSampler.path">${base_path}${admin_path}/catalog/product/edit/id/${simple_product_id}/</stringProp>
-                  <stringProp name="HTTPSampler.method">GET</stringProp>
-                  <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
-                  <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
-                  <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
-                  <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
-                  <boolProp name="HTTPSampler.monitor">false</boolProp>
-                  <stringProp name="HTTPSampler.embedded_url_re"/>
-                </HTTPSamplerProxy>
-                <hashTree>
-                  <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Response Assertion" enabled="true">
-                    <collectionProp name="Asserion.test_strings">
-                      <stringProp name="1355179215">Product</stringProp>
-                    </collectionProp>
-                    <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
-                    <boolProp name="Assertion.assume_success">false</boolProp>
-                    <intProp name="Assertion.test_type">16</intProp>
-                  </ResponseAssertion>
-                  <hashTree/>
-                  <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract name" enabled="true">
-                    <stringProp name="RegexExtractor.useHeaders">false</stringProp>
-                    <stringProp name="RegexExtractor.refname">simple_product_name</stringProp>
-                    <stringProp name="RegexExtractor.regex">,"name":"([^'"]+)",</stringProp>
-                    <stringProp name="RegexExtractor.template">$1$</stringProp>
-                    <stringProp name="RegexExtractor.default"/>
-                    <stringProp name="RegexExtractor.match_number">1</stringProp>
-                  </RegexExtractor>
-                  <hashTree/>
-                  <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract sku" enabled="true">
-                    <stringProp name="RegexExtractor.useHeaders">false</stringProp>
-                    <stringProp name="RegexExtractor.refname">simple_product_sku</stringProp>
-                    <stringProp name="RegexExtractor.regex">,"sku":"([^'"]+)",</stringProp>
-                    <stringProp name="RegexExtractor.template">$1$</stringProp>
-                    <stringProp name="RegexExtractor.default"/>
-                    <stringProp name="RegexExtractor.match_number">1</stringProp>
-                  </RegexExtractor>
-                  <hashTree/>
-                  <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract category" enabled="true">
-                    <stringProp name="RegexExtractor.useHeaders">false</stringProp>
-                    <stringProp name="RegexExtractor.refname">simple_product_category_id</stringProp>
-                    <stringProp name="RegexExtractor.regex">,"category_ids":."(\d+)".</stringProp>
-                    <stringProp name="RegexExtractor.template">$1$</stringProp>
-                    <stringProp name="RegexExtractor.default"/>
-                    <stringProp name="RegexExtractor.match_number">1</stringProp>
-                  </RegexExtractor>
-                  <hashTree/>
-                </hashTree>
-                <BeanShellSampler guiclass="BeanShellSamplerGui" testclass="BeanShellSampler" testname="SetUp - Set updated values" enabled="true">
-                  <stringProp name="TestPlan.comments">Passing arguments between threads</stringProp>
-                  <stringProp name="BeanShellSampler.query">//Additional category to be added
+Random random = vars.getObject("randomIntGenerator");
+number = random.nextInt(props.get("simple_products_list").size());
+product = props.get("simple_products_list").get(number);
 
-    int categoryId = Integer.parseInt(vars.get("simple_product_category_id"));
-    if (categoryId &gt; 4) {
-        categoryId = categoryId - 1;
-    } else {
-        categoryId = categoryId + 1;
-    }
-    vars.put("category_additional", categoryId.toString());
-    //New price
-    vars.put("price_new", "9999");
-    //New special price
-    vars.put("special_price_new", "8888");
-    //New quantity
-    vars.put("quantity_new", "100600");</stringProp>
-                  <stringProp name="BeanShellSampler.filename"/>
-                  <stringProp name="BeanShellSampler.parameters"/>
-                  <boolProp name="BeanShellSampler.resetInterpreter">false</boolProp>
-                </BeanShellSampler>
-                <hashTree/>
-                <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Edit Simple Product Validate" enabled="true">
-                  <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
-                    <collectionProp name="Arguments.arguments">
-                      <elementProp name="ajax" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value">true</stringProp>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">ajax</stringProp>
-                        <stringProp name="Argument.desc">false</stringProp>
-                      </elementProp>
-                      <elementProp name="isAjax" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value">true</stringProp>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">isAjax</stringProp>
-                        <stringProp name="Argument.desc">false</stringProp>
-                      </elementProp>
-                      <elementProp name="form_key" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value">${admin_form_key}</stringProp>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">form_key</stringProp>
-                        <stringProp name="Argument.desc">false</stringProp>
-                      </elementProp>
-                      <elementProp name="product[name]" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value">${simple_product_name}</stringProp>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">product[name]</stringProp>
-                        <stringProp name="Argument.desc">false</stringProp>
-                      </elementProp>
-                      <elementProp name="product[sku]" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value">${simple_product_sku}</stringProp>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">product[sku]</stringProp>
-                        <stringProp name="Argument.desc">false</stringProp>
-                      </elementProp>
-                      <elementProp name="product[price]" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value">${price_new}</stringProp>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">product[price]</stringProp>
-                        <stringProp name="Argument.desc">false</stringProp>
-                      </elementProp>
-                      <elementProp name="product[tax_class_id]" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value">2</stringProp>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">product[tax_class_id]</stringProp>
-                        <stringProp name="Argument.desc">false</stringProp>
-                      </elementProp>
-                      <elementProp name="product[quantity_and_stock_status][qty]" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value">${quantity_new}</stringProp>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">product[quantity_and_stock_status][qty]</stringProp>
-                        <stringProp name="Argument.desc">false</stringProp>
-                      </elementProp>
-                      <elementProp name="product[quantity_and_stock_status][is_in_stock]" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value">1</stringProp>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">product[quantity_and_stock_status][is_in_stock]</stringProp>
-                        <stringProp name="Argument.desc">false</stringProp>
-                      </elementProp>
-                      <elementProp name="product[weight]" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value">1.0000</stringProp>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">product[weight]</stringProp>
-                        <stringProp name="Argument.desc">false</stringProp>
-                      </elementProp>
-                      <elementProp name="product[product_has_weight]" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value">1</stringProp>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">product[product_has_weight]</stringProp>
-                        <stringProp name="Argument.desc">false</stringProp>
-                      </elementProp>
-                      <elementProp name="product[category_ids][]" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value">${simple_product_category_id}</stringProp>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">product[category_ids][]</stringProp>
-                        <stringProp name="Argument.desc">false</stringProp>
-                      </elementProp>
-                      <elementProp name="product[description]" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value">&lt;p&gt;Full simple product Description ${simple_product_id} Edited&lt;/p&gt;</stringProp>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">product[description]</stringProp>
-                        <stringProp name="Argument.desc">false</stringProp>
-                      </elementProp>
-                      <elementProp name="product[status]" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value">1</stringProp>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">product[status]</stringProp>
-                        <stringProp name="Argument.desc">false</stringProp>
-                      </elementProp>
-                      <elementProp name="product[configurable_variations]" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value"/>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">product[configurable_variations]</stringProp>
-                        <stringProp name="Argument.desc">false</stringProp>
-                      </elementProp>
-                      <elementProp name="affect_configurable_product_attributes" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value">1</stringProp>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">affect_configurable_product_attributes</stringProp>
-                        <stringProp name="Argument.desc">false</stringProp>
-                      </elementProp>
-                      <elementProp name="product[image]" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value"/>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">product[image]</stringProp>
-                        <stringProp name="Argument.desc">false</stringProp>
-                      </elementProp>
-                      <elementProp name="product[small_image]" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value"/>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">product[small_image]</stringProp>
-                        <stringProp name="Argument.desc">false</stringProp>
-                      </elementProp>
-                      <elementProp name="product[thumbnail]" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value"/>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">product[thumbnail]</stringProp>
-                        <stringProp name="Argument.desc">false</stringProp>
-                      </elementProp>
-                      <elementProp name="product[url_key]" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value">${simple_product_name}</stringProp>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">product[url_key]</stringProp>
-                        <stringProp name="Argument.desc">false</stringProp>
-                      </elementProp>
-                      <elementProp name="product[meta_title]" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value">${simple_product_name} Meta Title Edited</stringProp>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">product[meta_title]</stringProp>
-                        <stringProp name="Argument.desc">false</stringProp>
-                      </elementProp>
-                      <elementProp name="product[meta_keyword]" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value">${simple_product_name} Meta Keyword Edited</stringProp>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">product[meta_keyword]</stringProp>
-                        <stringProp name="Argument.desc">false</stringProp>
-                      </elementProp>
-                      <elementProp name="product[meta_description]" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value">${simple_product_name} Meta Description Edited</stringProp>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">product[meta_description]</stringProp>
-                        <stringProp name="Argument.desc">false</stringProp>
-                      </elementProp>
-                      <elementProp name="product[website_ids][]" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value">1</stringProp>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">product[website_ids][]</stringProp>
-                        <stringProp name="Argument.desc">false</stringProp>
-                      </elementProp>
-                      <elementProp name="product[special_price]" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value">${special_price_new}</stringProp>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">product[special_price]</stringProp>
-                        <stringProp name="Argument.desc">false</stringProp>
-                      </elementProp>
-                      <elementProp name="product[special_from_date]" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value"/>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">product[special_from_date]</stringProp>
-                        <stringProp name="Argument.desc">false</stringProp>
-                      </elementProp>
-                      <elementProp name="product[special_to_date]" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value"/>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">product[special_to_date]</stringProp>
-                        <stringProp name="Argument.desc">false</stringProp>
-                      </elementProp>
-                      <elementProp name="product[cost]" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value"/>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">product[cost]</stringProp>
-                        <stringProp name="Argument.desc">false</stringProp>
-                      </elementProp>
-                      <elementProp name="product[stock_data][use_config_manage_stock]" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value">1</stringProp>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">product[stock_data][use_config_manage_stock]</stringProp>
-                        <stringProp name="Argument.desc">false</stringProp>
-                      </elementProp>
-                      <elementProp name="product[stock_data][original_inventory_qty]" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value">${quantity_new}</stringProp>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">product[stock_data][original_inventory_qty]</stringProp>
-                        <stringProp name="Argument.desc">false</stringProp>
-                      </elementProp>
-                      <elementProp name="product[stock_data][qty]" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value">${quantity_new}</stringProp>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">product[stock_data][qty]</stringProp>
-                        <stringProp name="Argument.desc">false</stringProp>
-                      </elementProp>
-                      <elementProp name="product[stock_data][min_qty]" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value">0</stringProp>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">product[stock_data][min_qty]</stringProp>
-                        <stringProp name="Argument.desc">false</stringProp>
-                      </elementProp>
-                      <elementProp name="product[stock_data][use_config_min_qty]" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value">1</stringProp>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">product[stock_data][use_config_min_qty]</stringProp>
-                        <stringProp name="Argument.desc">false</stringProp>
-                      </elementProp>
-                      <elementProp name="product[stock_data][min_sale_qty]" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value">1</stringProp>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">product[stock_data][min_sale_qty]</stringProp>
-                        <stringProp name="Argument.desc">false</stringProp>
-                      </elementProp>
-                      <elementProp name="product[stock_data][use_config_min_sale_qty]" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value">1</stringProp>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">product[stock_data][use_config_min_sale_qty]</stringProp>
-                        <stringProp name="Argument.desc">false</stringProp>
-                      </elementProp>
-                      <elementProp name="product[stock_data][max_sale_qty]" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value">10000</stringProp>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">product[stock_data][max_sale_qty]</stringProp>
-                        <stringProp name="Argument.desc">false</stringProp>
-                      </elementProp>
-                      <elementProp name="product[stock_data][use_config_max_sale_qty]" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value">1</stringProp>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">product[stock_data][use_config_max_sale_qty]</stringProp>
-                        <stringProp name="Argument.desc">false</stringProp>
-                      </elementProp>
-                      <elementProp name="product[stock_data][is_qty_decimal]" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value">0</stringProp>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">product[stock_data][is_qty_decimal]</stringProp>
-                        <stringProp name="Argument.desc">false</stringProp>
-                      </elementProp>
-                      <elementProp name="product[stock_data][is_decimal_divided]" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value">0</stringProp>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">product[stock_data][is_decimal_divided]</stringProp>
-                        <stringProp name="Argument.desc">false</stringProp>
-                      </elementProp>
-                      <elementProp name="product[stock_data][backorders]" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value">0</stringProp>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">product[stock_data][backorders]</stringProp>
-                        <stringProp name="Argument.desc">false</stringProp>
-                      </elementProp>
-                      <elementProp name="product[stock_data][use_config_backorders]" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value">1</stringProp>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">product[stock_data][use_config_backorders]</stringProp>
-                        <stringProp name="Argument.desc">false</stringProp>
-                      </elementProp>
-                      <elementProp name="product[stock_data][notify_stock_qty]" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value">1</stringProp>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">product[stock_data][notify_stock_qty]</stringProp>
-                        <stringProp name="Argument.desc">false</stringProp>
-                      </elementProp>
-                      <elementProp name="product[stock_data][use_config_notify_stock_qty]" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value">1</stringProp>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">product[stock_data][use_config_notify_stock_qty]</stringProp>
-                        <stringProp name="Argument.desc">false</stringProp>
-                      </elementProp>
-                      <elementProp name="product[stock_data][enable_qty_increments]" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value">0</stringProp>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">product[stock_data][enable_qty_increments]</stringProp>
-                        <stringProp name="Argument.desc">false</stringProp>
-                      </elementProp>
-                      <elementProp name="product[stock_data][qty_increments]" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value">0</stringProp>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">product[stock_data][qty_increments]</stringProp>
-                        <stringProp name="Argument.desc">false</stringProp>
-                      </elementProp>
-                      <elementProp name="product[stock_data][use_config_qty_increments]" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value">1</stringProp>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">product[stock_data][use_config_qty_increments]</stringProp>
-                        <stringProp name="Argument.desc">false</stringProp>
-                      </elementProp>
-                      <elementProp name="product[stock_data][is_in_stock]" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value">1</stringProp>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">product[stock_data][is_in_stock]</stringProp>
-                        <stringProp name="Argument.desc">false</stringProp>
-                      </elementProp>
-                      <elementProp name="product[custom_design]" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value"/>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">product[custom_design]</stringProp>
-                        <stringProp name="Argument.desc">false</stringProp>
-                      </elementProp>
-                      <elementProp name="product[custom_design_from]" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value"/>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">product[custom_design_from]</stringProp>
-                        <stringProp name="Argument.desc">false</stringProp>
-                      </elementProp>
-                      <elementProp name="product[custom_design_to]" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value"/>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">product[custom_design_to]</stringProp>
-                        <stringProp name="Argument.desc">false</stringProp>
-                      </elementProp>
-                      <elementProp name="product[custom_layout_update]" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value"/>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">product[custom_layout_update]</stringProp>
-                        <stringProp name="Argument.desc">false</stringProp>
-                      </elementProp>
-                      <elementProp name="product[page_layout]" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value"/>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">product[page_layout]</stringProp>
-                        <stringProp name="Argument.desc">false</stringProp>
-                      </elementProp>
-                      <elementProp name="product[options_container]" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value">container2</stringProp>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">product[options_container]</stringProp>
-                        <stringProp name="Argument.desc">false</stringProp>
-                      </elementProp>
-                      <elementProp name="new-variations-attribute-set-id" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value"/>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">new-variations-attribute-set-id</stringProp>
-                        <stringProp name="Argument.desc">false</stringProp>
-                      </elementProp>
-                    </collectionProp>
-                  </elementProp>
-                  <stringProp name="HTTPSampler.domain"/>
-                  <stringProp name="HTTPSampler.port"/>
-                  <stringProp name="HTTPSampler.connect_timeout"/>
-                  <stringProp name="HTTPSampler.response_timeout"/>
-                  <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
-                  <stringProp name="HTTPSampler.contentEncoding"/>
-                  <stringProp name="HTTPSampler.path">${base_path}${admin_path}/catalog/product/validate/id/${simple_product_id}/?isAjax=true</stringProp>
-                  <stringProp name="HTTPSampler.method">POST</stringProp>
-                  <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
-                  <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
-                  <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
-                  <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
-                  <boolProp name="HTTPSampler.monitor">false</boolProp>
-                  <stringProp name="HTTPSampler.embedded_url_re"/>
-                </HTTPSamplerProxy>
-                <hashTree>
-                  <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Response Assertion" enabled="true">
-                    <collectionProp name="Asserion.test_strings">
-                      <stringProp name="1853918323">{"error":false}</stringProp>
-                    </collectionProp>
-                    <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
-                    <boolProp name="Assertion.assume_success">false</boolProp>
-                    <intProp name="Assertion.test_type">2</intProp>
-                  </ResponseAssertion>
-                  <hashTree/>
-                </hashTree>
-                <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Edit Simple Product Save" enabled="true">
-                  <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
-                    <collectionProp name="Arguments.arguments">
-                      <elementProp name="ajax" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value">true</stringProp>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">ajax</stringProp>
-                        <stringProp name="Argument.desc">false</stringProp>
-                      </elementProp>
-                      <elementProp name="isAjax" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value">true</stringProp>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">isAjax</stringProp>
-                        <stringProp name="Argument.desc">false</stringProp>
-                      </elementProp>
-                      <elementProp name="form_key" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value">${admin_form_key}</stringProp>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">form_key</stringProp>
-                        <stringProp name="Argument.desc">false</stringProp>
-                      </elementProp>
-                      <elementProp name="product[name]" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value">${simple_product_name}</stringProp>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">product[name]</stringProp>
-                        <stringProp name="Argument.desc">false</stringProp>
-                      </elementProp>
-                      <elementProp name="product[sku]" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value">${simple_product_sku}</stringProp>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">product[sku]</stringProp>
-                        <stringProp name="Argument.desc">false</stringProp>
-                      </elementProp>
-                      <elementProp name="product[price]" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value">${price_new}</stringProp>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">product[price]</stringProp>
-                        <stringProp name="Argument.desc">false</stringProp>
-                      </elementProp>
-                      <elementProp name="product[tax_class_id]" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value">2</stringProp>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">product[tax_class_id]</stringProp>
-                        <stringProp name="Argument.desc">false</stringProp>
-                      </elementProp>
-                      <elementProp name="product[quantity_and_stock_status][qty]" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value">${quantity_new}</stringProp>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">product[quantity_and_stock_status][qty]</stringProp>
-                        <stringProp name="Argument.desc">false</stringProp>
-                      </elementProp>
-                      <elementProp name="product[quantity_and_stock_status][is_in_stock]" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value">1</stringProp>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">product[quantity_and_stock_status][is_in_stock]</stringProp>
-                        <stringProp name="Argument.desc">false</stringProp>
-                      </elementProp>
-                      <elementProp name="product[weight]" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value">1.0000</stringProp>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">product[weight]</stringProp>
-                        <stringProp name="Argument.desc">false</stringProp>
-                      </elementProp>
-                      <elementProp name="product[product_has_weight]" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value">1</stringProp>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">product[product_has_weight]</stringProp>
-                        <stringProp name="Argument.desc">false</stringProp>
-                      </elementProp>
-                      <elementProp name="product[category_ids][]" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value">${simple_product_category_id}</stringProp>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">product[category_ids][]</stringProp>
-                        <stringProp name="Argument.desc">false</stringProp>
-                      </elementProp>
-                      <elementProp name="product[category_ids][]" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value">${category_additional}</stringProp>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">product[category_ids][]</stringProp>
-                      </elementProp>
-                      <elementProp name="product[description]" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value">&lt;p&gt;Full simple product Description ${simple_product_id} Edited&lt;/p&gt;</stringProp>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">product[description]</stringProp>
-                        <stringProp name="Argument.desc">false</stringProp>
-                      </elementProp>
-                      <elementProp name="product[status]" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value">1</stringProp>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">product[status]</stringProp>
-                        <stringProp name="Argument.desc">false</stringProp>
-                      </elementProp>
-                      <elementProp name="product[configurable_variations]" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value"/>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">product[configurable_variations]</stringProp>
-                        <stringProp name="Argument.desc">false</stringProp>
-                      </elementProp>
-                      <elementProp name="affect_configurable_product_attributes" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value">1</stringProp>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">affect_configurable_product_attributes</stringProp>
-                        <stringProp name="Argument.desc">false</stringProp>
-                      </elementProp>
-                      <elementProp name="product[image]" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value"/>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">product[image]</stringProp>
-                        <stringProp name="Argument.desc">false</stringProp>
-                      </elementProp>
-                      <elementProp name="product[small_image]" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value"/>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">product[small_image]</stringProp>
-                        <stringProp name="Argument.desc">false</stringProp>
-                      </elementProp>
-                      <elementProp name="product[thumbnail]" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value"/>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">product[thumbnail]</stringProp>
-                        <stringProp name="Argument.desc">false</stringProp>
-                      </elementProp>
-                      <elementProp name="product[url_key]" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value">${simple_product_name}</stringProp>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">product[url_key]</stringProp>
-                        <stringProp name="Argument.desc">false</stringProp>
-                      </elementProp>
-                      <elementProp name="product[meta_title]" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value">${simple_product_name} Meta Title Edited</stringProp>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">product[meta_title]</stringProp>
-                        <stringProp name="Argument.desc">false</stringProp>
-                      </elementProp>
-                      <elementProp name="product[meta_keyword]" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value">${simple_product_name} Meta Keyword Edited</stringProp>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">product[meta_keyword]</stringProp>
-                        <stringProp name="Argument.desc">false</stringProp>
-                      </elementProp>
-                      <elementProp name="product[meta_description]" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value">${simple_product_name} Meta Description Edited</stringProp>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">product[meta_description]</stringProp>
-                        <stringProp name="Argument.desc">false</stringProp>
-                      </elementProp>
-                      <elementProp name="product[website_ids][]" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value">1</stringProp>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">product[website_ids][]</stringProp>
-                        <stringProp name="Argument.desc">false</stringProp>
-                      </elementProp>
-                      <elementProp name="product[special_price]" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value">${special_price_new}</stringProp>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">product[special_price]</stringProp>
-                        <stringProp name="Argument.desc">false</stringProp>
-                      </elementProp>
-                      <elementProp name="product[special_from_date]" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value"/>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">product[special_from_date]</stringProp>
-                        <stringProp name="Argument.desc">false</stringProp>
-                      </elementProp>
-                      <elementProp name="product[special_to_date]" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value"/>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">product[special_to_date]</stringProp>
-                        <stringProp name="Argument.desc">false</stringProp>
-                      </elementProp>
-                      <elementProp name="product[cost]" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value"/>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">product[cost]</stringProp>
-                        <stringProp name="Argument.desc">false</stringProp>
-                      </elementProp>
-                      <elementProp name="product[stock_data][use_config_manage_stock]" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value">1</stringProp>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">product[stock_data][use_config_manage_stock]</stringProp>
-                        <stringProp name="Argument.desc">false</stringProp>
-                      </elementProp>
-                      <elementProp name="product[stock_data][original_inventory_qty]" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value">${quantity_new}</stringProp>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">product[stock_data][original_inventory_qty]</stringProp>
-                        <stringProp name="Argument.desc">false</stringProp>
-                      </elementProp>
-                      <elementProp name="product[stock_data][qty]" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value">${quantity_new}</stringProp>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">product[stock_data][qty]</stringProp>
-                        <stringProp name="Argument.desc">false</stringProp>
-                      </elementProp>
-                      <elementProp name="product[stock_data][min_qty]" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value">0</stringProp>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">product[stock_data][min_qty]</stringProp>
-                        <stringProp name="Argument.desc">false</stringProp>
-                      </elementProp>
-                      <elementProp name="product[stock_data][use_config_min_qty]" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value">1</stringProp>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">product[stock_data][use_config_min_qty]</stringProp>
-                        <stringProp name="Argument.desc">false</stringProp>
-                      </elementProp>
-                      <elementProp name="product[stock_data][min_sale_qty]" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value">1</stringProp>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">product[stock_data][min_sale_qty]</stringProp>
-                        <stringProp name="Argument.desc">false</stringProp>
-                      </elementProp>
-                      <elementProp name="product[stock_data][use_config_min_sale_qty]" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value">1</stringProp>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">product[stock_data][use_config_min_sale_qty]</stringProp>
-                        <stringProp name="Argument.desc">false</stringProp>
-                      </elementProp>
-                      <elementProp name="product[stock_data][max_sale_qty]" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value">10000</stringProp>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">product[stock_data][max_sale_qty]</stringProp>
-                        <stringProp name="Argument.desc">false</stringProp>
-                      </elementProp>
-                      <elementProp name="product[stock_data][use_config_max_sale_qty]" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value">1</stringProp>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">product[stock_data][use_config_max_sale_qty]</stringProp>
-                        <stringProp name="Argument.desc">false</stringProp>
-                      </elementProp>
-                      <elementProp name="product[stock_data][is_qty_decimal]" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value">0</stringProp>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">product[stock_data][is_qty_decimal]</stringProp>
-                        <stringProp name="Argument.desc">false</stringProp>
-                      </elementProp>
-                      <elementProp name="product[stock_data][is_decimal_divided]" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value">0</stringProp>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">product[stock_data][is_decimal_divided]</stringProp>
-                        <stringProp name="Argument.desc">false</stringProp>
-                      </elementProp>
-                      <elementProp name="product[stock_data][backorders]" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value">0</stringProp>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">product[stock_data][backorders]</stringProp>
-                        <stringProp name="Argument.desc">false</stringProp>
-                      </elementProp>
-                      <elementProp name="product[stock_data][use_config_backorders]" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value">1</stringProp>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">product[stock_data][use_config_backorders]</stringProp>
-                        <stringProp name="Argument.desc">false</stringProp>
-                      </elementProp>
-                      <elementProp name="product[stock_data][notify_stock_qty]" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value">1</stringProp>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">product[stock_data][notify_stock_qty]</stringProp>
-                        <stringProp name="Argument.desc">false</stringProp>
-                      </elementProp>
-                      <elementProp name="product[stock_data][use_config_notify_stock_qty]" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value">1</stringProp>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">product[stock_data][use_config_notify_stock_qty]</stringProp>
-                        <stringProp name="Argument.desc">false</stringProp>
-                      </elementProp>
-                      <elementProp name="product[stock_data][enable_qty_increments]" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value">0</stringProp>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">product[stock_data][enable_qty_increments]</stringProp>
-                        <stringProp name="Argument.desc">false</stringProp>
-                      </elementProp>
-                      <elementProp name="product[stock_data][qty_increments]" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value">0</stringProp>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">product[stock_data][qty_increments]</stringProp>
-                        <stringProp name="Argument.desc">false</stringProp>
-                      </elementProp>
-                      <elementProp name="product[stock_data][use_config_qty_increments]" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value">1</stringProp>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">product[stock_data][use_config_qty_increments]</stringProp>
-                        <stringProp name="Argument.desc">false</stringProp>
-                      </elementProp>
-                      <elementProp name="product[stock_data][is_in_stock]" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value">1</stringProp>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">product[stock_data][is_in_stock]</stringProp>
-                        <stringProp name="Argument.desc">false</stringProp>
-                      </elementProp>
-                      <elementProp name="product[custom_design]" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value"/>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">product[custom_design]</stringProp>
-                        <stringProp name="Argument.desc">false</stringProp>
-                      </elementProp>
-                      <elementProp name="product[custom_design_from]" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value"/>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">product[custom_design_from]</stringProp>
-                        <stringProp name="Argument.desc">false</stringProp>
-                      </elementProp>
-                      <elementProp name="product[custom_design_to]" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value"/>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">product[custom_design_to]</stringProp>
-                        <stringProp name="Argument.desc">false</stringProp>
-                      </elementProp>
-                      <elementProp name="product[custom_layout_update]" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value"/>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">product[custom_layout_update]</stringProp>
-                        <stringProp name="Argument.desc">false</stringProp>
-                      </elementProp>
-                      <elementProp name="product[page_layout]" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value"/>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">product[page_layout]</stringProp>
-                        <stringProp name="Argument.desc">false</stringProp>
-                      </elementProp>
-                      <elementProp name="product[options_container]" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value">container2</stringProp>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">product[options_container]</stringProp>
-                        <stringProp name="Argument.desc">false</stringProp>
-                      </elementProp>
-                      <elementProp name="new-variations-attribute-set-id" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value"/>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">new-variations-attribute-set-id</stringProp>
-                        <stringProp name="Argument.desc">false</stringProp>
-                      </elementProp>
-                    </collectionProp>
-                  </elementProp>
-                  <stringProp name="HTTPSampler.domain"/>
-                  <stringProp name="HTTPSampler.port"/>
-                  <stringProp name="HTTPSampler.connect_timeout"/>
-                  <stringProp name="HTTPSampler.response_timeout"/>
-                  <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
-                  <stringProp name="HTTPSampler.contentEncoding"/>
-                  <stringProp name="HTTPSampler.path">${base_path}${admin_path}/catalog/product/save/id/${simple_product_id}/back/edit/active_tab/product-details/</stringProp>
-                  <stringProp name="HTTPSampler.method">POST</stringProp>
-                  <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
-                  <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
-                  <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
-                  <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
-                  <boolProp name="HTTPSampler.monitor">false</boolProp>
-                  <stringProp name="HTTPSampler.embedded_url_re"/>
-                </HTTPSamplerProxy>
-                <hashTree>
-                  <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Response Assertion" enabled="true">
-                    <collectionProp name="Asserion.test_strings">
-                      <stringProp name="-583471546">You saved the product</stringProp>
-                    </collectionProp>
-                    <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
-                    <boolProp name="Assertion.assume_success">false</boolProp>
-                    <intProp name="Assertion.test_type">2</intProp>
-                  </ResponseAssertion>
-                  <hashTree/>
-                </hashTree>
-                <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Edit Configurable Product" enabled="true">
-                  <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
-                    <collectionProp name="Arguments.arguments"/>
-                  </elementProp>
-                  <stringProp name="HTTPSampler.domain"/>
-                  <stringProp name="HTTPSampler.port"/>
-                  <stringProp name="HTTPSampler.connect_timeout"/>
-                  <stringProp name="HTTPSampler.response_timeout"/>
-                  <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
-                  <stringProp name="HTTPSampler.contentEncoding"/>
-                  <stringProp name="HTTPSampler.path">${base_path}${admin_path}/catalog/product/edit/id/${configurable_product_id}/</stringProp>
-                  <stringProp name="HTTPSampler.method">GET</stringProp>
-                  <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
-                  <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
-                  <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
-                  <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
-                  <boolProp name="HTTPSampler.monitor">false</boolProp>
-                  <stringProp name="HTTPSampler.embedded_url_re"/>
-                </HTTPSamplerProxy>
-                <hashTree>
-                  <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Response Assertion" enabled="true">
-                    <collectionProp name="Asserion.test_strings">
-                      <stringProp name="1355179215">Product</stringProp>
-                    </collectionProp>
-                    <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
-                    <boolProp name="Assertion.assume_success">false</boolProp>
-                    <intProp name="Assertion.test_type">16</intProp>
-                  </ResponseAssertion>
-                  <hashTree/>
-                  <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract name" enabled="true">
-                    <stringProp name="RegexExtractor.useHeaders">false</stringProp>
-                    <stringProp name="RegexExtractor.refname">configurable_product_name</stringProp>
-                    <stringProp name="RegexExtractor.regex">,"name":"([^'"]+)",</stringProp>
-                    <stringProp name="RegexExtractor.template">$1$</stringProp>
-                    <stringProp name="RegexExtractor.default"/>
-                    <stringProp name="RegexExtractor.match_number">1</stringProp>
-                  </RegexExtractor>
-                  <hashTree/>
-                  <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract sku" enabled="true">
-                    <stringProp name="RegexExtractor.useHeaders">false</stringProp>
-                    <stringProp name="RegexExtractor.refname">configurable_product_sku</stringProp>
-                    <stringProp name="RegexExtractor.regex">,"sku":"([^'"]+)",</stringProp>
-                    <stringProp name="RegexExtractor.template">$1$</stringProp>
-                    <stringProp name="RegexExtractor.default"/>
-                    <stringProp name="RegexExtractor.match_number">1</stringProp>
-                  </RegexExtractor>
-                  <hashTree/>
-                  <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract category" enabled="true">
-                    <stringProp name="RegexExtractor.useHeaders">false</stringProp>
-                    <stringProp name="RegexExtractor.refname">configurable_product_category_id</stringProp>
-                    <stringProp name="RegexExtractor.regex">,"category_ids":."(\d+)"</stringProp>
-                    <stringProp name="RegexExtractor.template">$1$</stringProp>
-                    <stringProp name="RegexExtractor.default"/>
-                    <stringProp name="RegexExtractor.match_number">1</stringProp>
-                  </RegexExtractor>
-                  <hashTree/>
-                  <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract configurable attribute id" enabled="true">
-                    <stringProp name="RegexExtractor.useHeaders">false</stringProp>
-                    <stringProp name="RegexExtractor.refname">configurable_attribute_id</stringProp>
-                    <stringProp name="RegexExtractor.regex">,"configurable_variation":"([^'"]+)",</stringProp>
-                    <stringProp name="RegexExtractor.template">$1$</stringProp>
-                    <stringProp name="RegexExtractor.default"/>
-                    <stringProp name="RegexExtractor.match_number">1</stringProp>
-                    <boolProp name="RegexExtractor.default_empty_value">true</boolProp>
-                  </RegexExtractor>
-                  <hashTree/>
-                  <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract configurable matrix" enabled="true">
-                    <stringProp name="RegexExtractor.useHeaders">false</stringProp>
-                    <stringProp name="RegexExtractor.refname">configurable_matrix</stringProp>
-                    <stringProp name="RegexExtractor.regex">"configurable-matrix":(\[.*?\])</stringProp>
-                    <stringProp name="RegexExtractor.template">$1$</stringProp>
-                    <stringProp name="RegexExtractor.default"/>
-                    <stringProp name="RegexExtractor.match_number">1</stringProp>
-                    <boolProp name="RegexExtractor.default_empty_value">true</boolProp>
-                  </RegexExtractor>
-                  <hashTree/>
-                  <com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor guiclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.gui.JSONPathExtractorGui" testclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor" testname="Extract associated products ids" enabled="true">
-                    <stringProp name="VAR">associated_products_ids</stringProp>
-                    <stringProp name="JSONPATH">$.[*].id</stringProp>
-                    <stringProp name="DEFAULT"/>
-                    <stringProp name="VARIABLE">configurable_matrix</stringProp>
-                    <stringProp name="SUBJECT">VAR</stringProp>
-                  </com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor>
-                  <hashTree/>
-                  <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract configurable product json" enabled="true">
-                    <stringProp name="RegexExtractor.useHeaders">false</stringProp>
-                    <stringProp name="RegexExtractor.refname">configurable_product_data</stringProp>
-                    <stringProp name="RegexExtractor.regex">(\{"product":.*?configurable_attributes_data.*?\})\s*&lt;</stringProp>
-                    <stringProp name="RegexExtractor.template">$1$</stringProp>
-                    <stringProp name="RegexExtractor.default"/>
-                    <stringProp name="RegexExtractor.match_number">1</stringProp>
-                  </RegexExtractor>
-                  <hashTree/>
-                  <com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor guiclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.gui.JSONPathExtractorGui" testclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor" testname="Extract configurable attributes data" enabled="true">
-                    <stringProp name="VAR">configurable_attributes_data</stringProp>
-                    <stringProp name="JSONPATH">$.product.configurable_attributes_data</stringProp>
-                    <stringProp name="DEFAULT"/>
-                    <stringProp name="VARIABLE">configurable_product_data</stringProp>
-                    <stringProp name="SUBJECT">VAR</stringProp>
-                  </com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor>
-                  <hashTree/>
-                  <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract attribute ids" enabled="true">
-                    <stringProp name="RegexExtractor.useHeaders">false</stringProp>
-                    <stringProp name="RegexExtractor.refname">configurable_attribute_ids</stringProp>
-                    <stringProp name="RegexExtractor.regex">"attribute_id":"(\d+)"</stringProp>
-                    <stringProp name="RegexExtractor.template">$1$</stringProp>
-                    <stringProp name="RegexExtractor.default"/>
-                    <stringProp name="RegexExtractor.match_number">-1</stringProp>
-                    <stringProp name="Sample.scope">variable</stringProp>
-                    <stringProp name="Scope.variable">configurable_attributes_data</stringProp>
-                  </RegexExtractor>
-                  <hashTree/>
-                  <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract attribute codes" enabled="true">
-                    <stringProp name="RegexExtractor.useHeaders">false</stringProp>
-                    <stringProp name="RegexExtractor.refname">configurable_attribute_codes</stringProp>
-                    <stringProp name="RegexExtractor.regex">"code":"(\w+)"</stringProp>
-                    <stringProp name="RegexExtractor.template">$1$</stringProp>
-                    <stringProp name="RegexExtractor.default"/>
-                    <stringProp name="RegexExtractor.match_number">-1</stringProp>
-                    <stringProp name="Sample.scope">variable</stringProp>
-                    <stringProp name="Scope.variable">configurable_attributes_data</stringProp>
-                  </RegexExtractor>
-                  <hashTree/>
-                  <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract attribute labels" enabled="true">
-                    <stringProp name="RegexExtractor.useHeaders">false</stringProp>
-                    <stringProp name="RegexExtractor.refname">configurable_attribute_labels</stringProp>
-                    <stringProp name="RegexExtractor.regex">"label":"(.*?)"</stringProp>
-                    <stringProp name="RegexExtractor.template">$1$</stringProp>
-                    <stringProp name="RegexExtractor.default"/>
-                    <stringProp name="RegexExtractor.match_number">-1</stringProp>
-                    <stringProp name="Sample.scope">variable</stringProp>
-                    <stringProp name="Scope.variable">configurable_attributes_data</stringProp>
-                  </RegexExtractor>
-                  <hashTree/>
-                  <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract attribute values" enabled="true">
-                    <stringProp name="RegexExtractor.useHeaders">false</stringProp>
-                    <stringProp name="RegexExtractor.refname">configurable_attribute_values</stringProp>
-                    <stringProp name="RegexExtractor.regex">"values":(\{(?:\}|.*?\}\}))</stringProp>
-                    <stringProp name="RegexExtractor.template">$1$</stringProp>
-                    <stringProp name="RegexExtractor.default"/>
-                    <stringProp name="RegexExtractor.match_number">-1</stringProp>
-                    <stringProp name="Sample.scope">variable</stringProp>
-                    <stringProp name="Scope.variable">configurable_attributes_data</stringProp>
-                  </RegexExtractor>
-                  <hashTree/>
-                </hashTree>
-                <ForeachController guiclass="ForeachControlPanel" testclass="ForeachController" testname="ForEach configurable attribute id" enabled="true">
-                  <stringProp name="ForeachController.inputVal">configurable_attribute_ids</stringProp>
-                  <stringProp name="ForeachController.returnVal">configurable_attribute_id</stringProp>
-                  <boolProp name="ForeachController.useSeparator">true</boolProp>
-                </ForeachController>
-                <hashTree>
-                  <CounterConfig guiclass="CounterConfigGui" testclass="CounterConfig" testname="Counter" enabled="true">
-                    <stringProp name="CounterConfig.start">1</stringProp>
-                    <stringProp name="CounterConfig.end">${configurable_attribute_ids_matchNr}</stringProp>
-                    <stringProp name="CounterConfig.incr">1</stringProp>
-                    <stringProp name="CounterConfig.name">attribute_counter</stringProp>
-                    <stringProp name="CounterConfig.format"/>
-                    <boolProp name="CounterConfig.per_user">true</boolProp>
-                    <boolProp name="CounterConfig.reset_on_tg_iteration">true</boolProp>
-                  </CounterConfig>
-                  <hashTree/>
-                  <BeanShellSampler guiclass="BeanShellSamplerGui" testclass="BeanShellSampler" testname="Process configurable attribute values" enabled="true">
-                    <stringProp name="BeanShellSampler.query">return vars.get("configurable_attribute_values_" + vars.get("attribute_counter"));</stringProp>
-                    <stringProp name="BeanShellSampler.filename"/>
-                    <stringProp name="BeanShellSampler.parameters"/>
-                    <boolProp name="BeanShellSampler.resetInterpreter">false</boolProp>
-                  </BeanShellSampler>
-                  <hashTree>
-                    <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Exctract attribute values" enabled="true">
-                      <stringProp name="RegexExtractor.useHeaders">false</stringProp>
-                      <stringProp name="RegexExtractor.refname">attribute_${configurable_attribute_id}_values</stringProp>
-                      <stringProp name="RegexExtractor.regex">"value_index":"(\d+)"</stringProp>
-                      <stringProp name="RegexExtractor.template">$1$</stringProp>
-                      <stringProp name="RegexExtractor.default"/>
-                      <stringProp name="RegexExtractor.match_number">-1</stringProp>
-                      <stringProp name="Scope.variable">configurable_attribute_values_${attribute_counter}</stringProp>
-                    </RegexExtractor>
-                    <hashTree/>
-                  </hashTree>
-                </hashTree>
-                <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Edit Configurable Product Validate" enabled="true">
-                  <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
-                    <collectionProp name="Arguments.arguments">
-                      <elementProp name="isAjax" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value">true</stringProp>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">isAjax</stringProp>
-                        <stringProp name="Argument.desc">false</stringProp>
-                      </elementProp>
-                      <elementProp name="form_key" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value">${admin_form_key}</stringProp>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">form_key</stringProp>
-                        <stringProp name="Argument.desc">false</stringProp>
-                      </elementProp>
-                      <elementProp name="product[name]" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value">${configurable_product_name}</stringProp>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">product[name]</stringProp>
-                        <stringProp name="Argument.desc">false</stringProp>
-                      </elementProp>
-                      <elementProp name="product[sku]" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value">${configurable_product_sku}</stringProp>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">product[sku]</stringProp>
-                        <stringProp name="Argument.desc">false</stringProp>
-                      </elementProp>
-                      <elementProp name="product[price]" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value">${price_new}</stringProp>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">product[price]</stringProp>
-                        <stringProp name="Argument.desc">false</stringProp>
-                      </elementProp>
-                      <elementProp name="product[tax_class_id]" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value">2</stringProp>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">product[tax_class_id]</stringProp>
-                        <stringProp name="Argument.desc">false</stringProp>
-                      </elementProp>
-                      <elementProp name="product[quantity_and_stock_status][is_in_stock]" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value">1</stringProp>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">product[quantity_and_stock_status][is_in_stock]</stringProp>
-                        <stringProp name="Argument.desc">false</stringProp>
-                      </elementProp>
-                      <elementProp name="product[weight]" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value">3</stringProp>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">product[weight]</stringProp>
-                        <stringProp name="Argument.desc">false</stringProp>
-                      </elementProp>
-                      <elementProp name="product[category_ids][]" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value">${configurable_product_category_id}</stringProp>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">product[category_ids][]</stringProp>
-                        <stringProp name="Argument.desc">false</stringProp>
-                      </elementProp>
-                      <elementProp name="product[category_ids][]" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value">${category_additional}</stringProp>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">product[category_ids][]</stringProp>
-                        <stringProp name="Argument.desc">false</stringProp>
-                      </elementProp>
-                      <elementProp name="product[description]" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value">&lt;p&gt;Configurable product description ${configurable_product_id} Edited&lt;/p&gt;</stringProp>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">product[description]</stringProp>
-                        <stringProp name="Argument.desc">false</stringProp>
-                      </elementProp>
-                      <elementProp name="product[status]" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value">1</stringProp>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">product[status]</stringProp>
-                        <stringProp name="Argument.desc">false</stringProp>
-                      </elementProp>
-                      <elementProp name="product[meta_title]" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value">${configurable_product_name} Meta Title Edited</stringProp>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">product[meta_title]</stringProp>
-                        <stringProp name="Argument.desc">false</stringProp>
-                      </elementProp>
-                      <elementProp name="product[meta_keyword]" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value">${configurable_product_name} Meta Keyword Edited</stringProp>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">product[meta_keyword]</stringProp>
-                        <stringProp name="Argument.desc">false</stringProp>
-                      </elementProp>
-                      <elementProp name="product[meta_description]" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value">${configurable_product_name} Meta Description Edited</stringProp>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">product[meta_description]</stringProp>
-                        <stringProp name="Argument.desc">false</stringProp>
-                      </elementProp>
-                      <elementProp name="product[website_ids][]" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value">1</stringProp>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">product[website_ids][]</stringProp>
-                        <stringProp name="Argument.desc">false</stringProp>
-                      </elementProp>
-                      <elementProp name="product[special_price]" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value">${special_price_new}</stringProp>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">product[special_price]</stringProp>
-                        <stringProp name="Argument.desc">false</stringProp>
-                      </elementProp>
-                      <elementProp name="product[special_from_date]" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value"/>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">product[special_from_date]</stringProp>
-                        <stringProp name="Argument.desc">false</stringProp>
-                      </elementProp>
-                      <elementProp name="product[special_to_date]" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value"/>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">product[special_to_date]</stringProp>
-                        <stringProp name="Argument.desc">false</stringProp>
-                      </elementProp>
-                      <elementProp name="product[cost]" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value"/>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">product[cost]</stringProp>
-                        <stringProp name="Argument.desc">false</stringProp>
-                      </elementProp>
-                      <elementProp name="product[stock_data][use_config_manage_stock]" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value">1</stringProp>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">product[stock_data][use_config_manage_stock]</stringProp>
-                        <stringProp name="Argument.desc">false</stringProp>
-                      </elementProp>
-                      <elementProp name="product[stock_data][min_qty]" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value">0</stringProp>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">product[stock_data][min_qty]</stringProp>
-                        <stringProp name="Argument.desc">false</stringProp>
-                      </elementProp>
-                      <elementProp name="product[stock_data][use_config_min_qty]" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value">1</stringProp>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">product[stock_data][use_config_min_qty]</stringProp>
-                        <stringProp name="Argument.desc">false</stringProp>
-                      </elementProp>
-                      <elementProp name="product[stock_data][min_sale_qty]" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value">1</stringProp>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">product[stock_data][min_sale_qty]</stringProp>
-                        <stringProp name="Argument.desc">false</stringProp>
-                      </elementProp>
-                      <elementProp name="product[stock_data][use_config_min_sale_qty]" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value">1</stringProp>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">product[stock_data][use_config_min_sale_qty]</stringProp>
-                        <stringProp name="Argument.desc">false</stringProp>
-                      </elementProp>
-                      <elementProp name="product[stock_data][use_config_max_sale_qty]" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value">1</stringProp>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">product[stock_data][use_config_max_sale_qty]</stringProp>
-                        <stringProp name="Argument.desc">false</stringProp>
-                      </elementProp>
-                      <elementProp name="product[stock_data][is_qty_decimal]" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value">0</stringProp>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">product[stock_data][is_qty_decimal]</stringProp>
-                        <stringProp name="Argument.desc">false</stringProp>
-                      </elementProp>
-                      <elementProp name="product[stock_data][is_decimal_divided]" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value">0</stringProp>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">product[stock_data][is_decimal_divided]</stringProp>
-                        <stringProp name="Argument.desc">false</stringProp>
-                      </elementProp>
-                      <elementProp name="product[stock_data][backorders]" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value">0</stringProp>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">product[stock_data][backorders]</stringProp>
-                        <stringProp name="Argument.desc">false</stringProp>
-                      </elementProp>
-                      <elementProp name="product[stock_data][use_config_backorders]" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value">1</stringProp>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">product[stock_data][use_config_backorders]</stringProp>
-                        <stringProp name="Argument.desc">false</stringProp>
-                      </elementProp>
-                      <elementProp name="product[stock_data][notify_stock_qty]" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value">1</stringProp>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">product[stock_data][notify_stock_qty]</stringProp>
-                        <stringProp name="Argument.desc">false</stringProp>
-                      </elementProp>
-                      <elementProp name="product[stock_data][use_config_notify_stock_qty]" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value">1</stringProp>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">product[stock_data][use_config_notify_stock_qty]</stringProp>
-                        <stringProp name="Argument.desc">false</stringProp>
-                      </elementProp>
-                      <elementProp name="product[stock_data][enable_qty_increments]" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value">0</stringProp>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">product[stock_data][enable_qty_increments]</stringProp>
-                        <stringProp name="Argument.desc">false</stringProp>
-                      </elementProp>
-                      <elementProp name="product[stock_data][qty_increments]" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value">0</stringProp>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">product[stock_data][qty_increments]</stringProp>
-                        <stringProp name="Argument.desc">false</stringProp>
-                      </elementProp>
-                      <elementProp name="product[stock_data][use_config_qty_increments]" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value">1</stringProp>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">product[stock_data][use_config_qty_increments]</stringProp>
-                        <stringProp name="Argument.desc">false</stringProp>
-                      </elementProp>
-                      <elementProp name="product[stock_data][is_in_stock]" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value">1</stringProp>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">product[stock_data][is_in_stock]</stringProp>
-                        <stringProp name="Argument.desc">false</stringProp>
-                      </elementProp>
-                      <elementProp name="product[custom_design]" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value"/>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">product[custom_design]</stringProp>
-                        <stringProp name="Argument.desc">false</stringProp>
-                      </elementProp>
-                      <elementProp name="product[custom_design_from]" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value"/>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">product[custom_design_from]</stringProp>
-                        <stringProp name="Argument.desc">false</stringProp>
-                      </elementProp>
-                      <elementProp name="product[custom_design_to]" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value"/>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">product[custom_design_to]</stringProp>
-                        <stringProp name="Argument.desc">false</stringProp>
-                      </elementProp>
-                      <elementProp name="product[custom_layout_update]" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value"/>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">product[custom_layout_update]</stringProp>
-                        <stringProp name="Argument.desc">false</stringProp>
-                      </elementProp>
-                      <elementProp name="product[page_layout]" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value"/>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">product[page_layout]</stringProp>
-                        <stringProp name="Argument.desc">false</stringProp>
-                      </elementProp>
-                      <elementProp name="product[options_container]" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value">container2</stringProp>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">product[options_container]</stringProp>
-                        <stringProp name="Argument.desc">false</stringProp>
-                      </elementProp>
-                      <elementProp name="product[configurable_variation]" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value">${configurable_attribute_id}</stringProp>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">product[configurable_variation]</stringProp>
-                        <stringProp name="Argument.desc">false</stringProp>
-                      </elementProp>
-                      <elementProp name="product[url_key]" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value">${configurable_product_name}</stringProp>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">product[url_key]</stringProp>
-                      </elementProp>
-                      <elementProp name="product[use_config_gift_message_available]" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value">1</stringProp>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">product[use_config_gift_message_available]</stringProp>
-                      </elementProp>
-                      <elementProp name="product[use_config_gift_wrapping_available]" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value">1</stringProp>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">product[use_config_gift_wrapping_available]</stringProp>
-                      </elementProp>
-                      <elementProp name="product[visibility]" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value">4</stringProp>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">product[visibility]</stringProp>
-                      </elementProp>
-                      <elementProp name="product[product_has_weight]" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value">1</stringProp>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">product[product_has_weight]</stringProp>
-                        <stringProp name="Argument.desc">true</stringProp>
-                      </elementProp>
-                      <elementProp name="product[stock_data][qty]" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value">50</stringProp>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">product[stock_data][qty]</stringProp>
-                        <stringProp name="Argument.desc">false</stringProp>
-                      </elementProp>
-                      <elementProp name="product[stock_data][type_id]" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value">configurable</stringProp>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">product[stock_data][type_id]</stringProp>
-                        <stringProp name="Argument.desc">false</stringProp>
-                      </elementProp>
-                    </collectionProp>
-                  </elementProp>
-                  <stringProp name="HTTPSampler.domain"/>
-                  <stringProp name="HTTPSampler.port"/>
-                  <stringProp name="HTTPSampler.connect_timeout"/>
-                  <stringProp name="HTTPSampler.response_timeout"/>
-                  <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
-                  <stringProp name="HTTPSampler.contentEncoding"/>
-                  <stringProp name="HTTPSampler.path">${base_path}${admin_path}/catalog/product/validate/id/${configurable_product_id}/</stringProp>
-                  <stringProp name="HTTPSampler.method">POST</stringProp>
-                  <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
-                  <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
-                  <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
-                  <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
-                  <boolProp name="HTTPSampler.monitor">false</boolProp>
-                  <stringProp name="HTTPSampler.embedded_url_re"/>
-                </HTTPSamplerProxy>
-                <hashTree>
-                  <BeanShellPreProcessor guiclass="TestBeanGUI" testclass="BeanShellPreProcessor" testname="Configure product options" enabled="true">
-                    <boolProp name="resetInterpreter">false</boolProp>
-                    <stringProp name="parameters"/>
-                    <stringProp name="filename"/>
-                    <stringProp name="script">try {
-    	int attributesCount = Integer.parseInt(vars.get("configurable_attribute_ids_matchNr"));
-    	for (int i = 1; i &lt;= attributesCount; i++) {
-    		attributeId = vars.get("configurable_attribute_ids_" + i.toString());
-    		attributeCode = vars.get("configurable_attribute_codes_" + i.toString());
-    		attributeLabel = vars.get("configurable_attribute_labels_" + i.toString());
-    		ctx.getCurrentSampler().addArgument("attributes[" + (i - 1).toString() + "]", attributeId);
-    		ctx.getCurrentSampler().addArgument("attribute_codes[" + (i - 1).toString() + "]", attributeCode);
-    		ctx.getCurrentSampler().addArgument("product[" + attributeCode + "]", attributeId);
-    		ctx.getCurrentSampler().addArgument("product[configurable_attributes_data][" + attributeId + "][attribute_id]", attributeId);
-    		ctx.getCurrentSampler().addArgument("product[configurable_attributes_data][" + attributeId + "][position]", (i - 1).toString());
-    		ctx.getCurrentSampler().addArgument("product[configurable_attributes_data][" + attributeId + "][code]", attributeCode);
-    		ctx.getCurrentSampler().addArgument("product[configurable_attributes_data][" + attributeId + "][label]", attributeLabel);
-
-    		int valuesCount = Integer.parseInt(vars.get("attribute_" + attributeId + "_values_matchNr"));
-    		for (int j = 1; j &lt;= valuesCount; j++) {
-    			attributeValue = vars.get("attribute_" + attributeId + "_values_" + j.toString());
-    			ctx.getCurrentSampler().addArgument(
-    				"product[configurable_attributes_data][" + attributeId + "][values][" + attributeValue + "][include]",
-    				"1"
-    			);
-    			ctx.getCurrentSampler().addArgument(
-    				"product[configurable_attributes_data][" + attributeId + "][values][" + attributeValue + "][value_index]",
-    				attributeValue
-    			);
-    		}
-    	}
-    	ctx.getCurrentSampler().addArgument("associated_product_ids_serialized", vars.get("associated_products_ids").toString());
-    } catch (Exception e) {
-        log.error("error???", e);
-    }</stringProp>
-                  </BeanShellPreProcessor>
-                  <hashTree/>
-                  <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Response Assertion" enabled="true">
-                    <collectionProp name="Asserion.test_strings">
-                      <stringProp name="1853918323">{"error":false}</stringProp>
-                    </collectionProp>
-                    <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
-                    <boolProp name="Assertion.assume_success">false</boolProp>
-                    <intProp name="Assertion.test_type">2</intProp>
-                  </ResponseAssertion>
-                  <hashTree/>
-                </hashTree>
-                <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Edit Configurable Product Save" enabled="true">
-                  <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
-                    <collectionProp name="Arguments.arguments">
-                      <elementProp name="ajax" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value">true</stringProp>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">ajax</stringProp>
-                        <stringProp name="Argument.desc">false</stringProp>
-                      </elementProp>
-                      <elementProp name="isAjax" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value">true</stringProp>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">isAjax</stringProp>
-                        <stringProp name="Argument.desc">false</stringProp>
-                      </elementProp>
-                      <elementProp name="form_key" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value">${admin_form_key}</stringProp>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">form_key</stringProp>
-                        <stringProp name="Argument.desc">false</stringProp>
-                      </elementProp>
-                      <elementProp name="product[name]" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value">${configurable_product_name}</stringProp>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">product[name]</stringProp>
-                        <stringProp name="Argument.desc">false</stringProp>
-                      </elementProp>
-                      <elementProp name="product[sku]" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value">${configurable_product_sku}</stringProp>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">product[sku]</stringProp>
-                        <stringProp name="Argument.desc">false</stringProp>
-                      </elementProp>
-                      <elementProp name="product[price]" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value">${price_new}</stringProp>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">product[price]</stringProp>
-                        <stringProp name="Argument.desc">false</stringProp>
-                      </elementProp>
-                      <elementProp name="product[tax_class_id]admin" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value">2</stringProp>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">product[tax_class_id]admin</stringProp>
-                        <stringProp name="Argument.desc">false</stringProp>
-                      </elementProp>
-                      <elementProp name="product[quantity_and_stock_status][is_in_stock]" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value">1</stringProp>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">product[quantity_and_stock_status][is_in_stock]</stringProp>
-                        <stringProp name="Argument.desc">false</stringProp>
-                      </elementProp>
-                      <elementProp name="product[weight]" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value">3</stringProp>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">product[weight]</stringProp>
-                        <stringProp name="Argument.desc">false</stringProp>
-                      </elementProp>
-                      <elementProp name="product[category_ids][]" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value">${configurable_product_category_id}</stringProp>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">product[category_ids][]</stringProp>
-                        <stringProp name="Argument.desc">false</stringProp>
-                      </elementProp>
-                      <elementProp name="product[category_ids][]" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value">${category_additional}</stringProp>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">product[category_ids][]</stringProp>
-                        <stringProp name="Argument.desc">false</stringProp>
-                      </elementProp>
-                      <elementProp name="product[description]" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value">&lt;p&gt;Configurable product description ${configurable_product_id} Edited&lt;/p&gt;</stringProp>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">product[description]</stringProp>
-                        <stringProp name="Argument.desc">false</stringProp>
-                      </elementProp>
-                      <elementProp name="product[status]" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value">1</stringProp>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">product[status]</stringProp>
-                        <stringProp name="Argument.desc">false</stringProp>
-                      </elementProp>
-                      <elementProp name="product[meta_title]" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value">${configurable_product_name} Meta Title Edited</stringProp>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">product[meta_title]</stringProp>
-                        <stringProp name="Argument.desc">false</stringProp>
-                      </elementProp>
-                      <elementProp name="product[meta_keyword]" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value">${configurable_product_name} Meta Keyword Edited</stringProp>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">product[meta_keyword]</stringProp>
-                        <stringProp name="Argument.desc">false</stringProp>
-                      </elementProp>
-                      <elementProp name="product[meta_description]" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value">${configurable_product_name} Meta Description Edited</stringProp>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">product[meta_description]</stringProp>
-                        <stringProp name="Argument.desc">false</stringProp>
-                      </elementProp>
-                      <elementProp name="product[website_ids][]" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value">1</stringProp>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">product[website_ids][]</stringProp>
-                        <stringProp name="Argument.desc">false</stringProp>
-                      </elementProp>
-                      <elementProp name="product[special_price]" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value">${special_price_new}</stringProp>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">product[special_price]</stringProp>
-                        <stringProp name="Argument.desc">false</stringProp>
-                      </elementProp>
-                      <elementProp name="product[special_from_date]" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value"/>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">product[special_from_date]</stringProp>
-                        <stringProp name="Argument.desc">false</stringProp>
-                      </elementProp>
-                      <elementProp name="product[special_to_date]" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value"/>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">product[special_to_date]</stringProp>
-                        <stringProp name="Argument.desc">false</stringProp>
-                      </elementProp>
-                      <elementProp name="product[cost]" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value"/>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">product[cost]</stringProp>
-                        <stringProp name="Argument.desc">false</stringProp>
-                      </elementProp>
-                      <elementProp name="product[stock_data][use_config_manage_stock]" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value">1</stringProp>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">product[stock_data][use_config_manage_stock]</stringProp>
-                        <stringProp name="Argument.desc">false</stringProp>
-                      </elementProp>
-                      <elementProp name="product[stock_data][min_qty]" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value">0</stringProp>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">product[stock_data][min_qty]</stringProp>
-                        <stringProp name="Argument.desc">false</stringProp>
-                      </elementProp>
-                      <elementProp name="product[stock_data][use_config_min_qty]" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value">1</stringProp>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">product[stock_data][use_config_min_qty]</stringProp>
-                        <stringProp name="Argument.desc">false</stringProp>
-                      </elementProp>
-                      <elementProp name="product[stock_data][min_sale_qty]" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value">1</stringProp>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">product[stock_data][min_sale_qty]</stringProp>
-                        <stringProp name="Argument.desc">false</stringProp>
-                      </elementProp>
-                      <elementProp name="product[stock_data][use_config_min_sale_qty]" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value">1</stringProp>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">product[stock_data][use_config_min_sale_qty]</stringProp>
-                        <stringProp name="Argument.desc">false</stringProp>
-                      </elementProp>
-                      <elementProp name="product[stock_data][use_config_max_sale_qty]" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value">1</stringProp>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">product[stock_data][use_config_max_sale_qty]</stringProp>
-                        <stringProp name="Argument.desc">false</stringProp>
-                      </elementProp>
-                      <elementProp name="product[stock_data][is_qty_decimal]" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value">0</stringProp>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">product[stock_data][is_qty_decimal]</stringProp>
-                        <stringProp name="Argument.desc">false</stringProp>
-                      </elementProp>
-                      <elementProp name="product[stock_data][is_decimal_divided]" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value">0</stringProp>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">product[stock_data][is_decimal_divided]</stringProp>
-                        <stringProp name="Argument.desc">false</stringProp>
-                      </elementProp>
-                      <elementProp name="product[stock_data][backorders]" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value">0</stringProp>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">product[stock_data][backorders]</stringProp>
-                        <stringProp name="Argument.desc">false</stringProp>
-                      </elementProp>
-                      <elementProp name="product[stock_data][use_config_backorders]" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value">1</stringProp>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">product[stock_data][use_config_backorders]</stringProp>
-                        <stringProp name="Argument.desc">false</stringProp>
-                      </elementProp>
-                      <elementProp name="product[stock_data][notify_stock_qty]" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value">1</stringProp>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">product[stock_data][notify_stock_qty]</stringProp>
-                        <stringProp name="Argument.desc">false</stringProp>
-                      </elementProp>
-                      <elementProp name="product[stock_data][use_config_notify_stock_qty]" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value">1</stringProp>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">product[stock_data][use_config_notify_stock_qty]</stringProp>
-                        <stringProp name="Argument.desc">false</stringProp>
-                      </elementProp>
-                      <elementProp name="product[stock_data][enable_qty_increments]" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value">0</stringProp>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">product[stock_data][enable_qty_increments]</stringProp>
-                        <stringProp name="Argument.desc">false</stringProp>
-                      </elementProp>
-                      <elementProp name="product[stock_data][qty_increments]" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value">0</stringProp>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">product[stock_data][qty_increments]</stringProp>
-                        <stringProp name="Argument.desc">false</stringProp>
-                      </elementProp>
-                      <elementProp name="product[stock_data][use_config_qty_increments]" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value">1</stringProp>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">product[stock_data][use_config_qty_increments]</stringProp>
-                        <stringProp name="Argument.desc">false</stringProp>
-                      </elementProp>
-                      <elementProp name="product[stock_data][is_in_stock]" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value">1</stringProp>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">product[stock_data][is_in_stock]</stringProp>
-                        <stringProp name="Argument.desc">false</stringProp>
-                      </elementProp>
-                      <elementProp name="product[custom_design]" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value"/>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">product[custom_design]</stringProp>
-                        <stringProp name="Argument.desc">false</stringProp>
-                      </elementProp>
-                      <elementProp name="product[custom_design_from]" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value"/>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">product[custom_design_from]</stringProp>
-                        <stringProp name="Argument.desc">false</stringProp>
-                      </elementProp>
-                      <elementProp name="product[custom_design_to]" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value"/>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">product[custom_design_to]</stringProp>
-                        <stringProp name="Argument.desc">false</stringProp>
-                      </elementProp>
-                      <elementProp name="product[custom_layout_update]" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value"/>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">product[custom_layout_update]</stringProp>
-                        <stringProp name="Argument.desc">false</stringProp>
-                      </elementProp>
-                      <elementProp name="product[page_layout]" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value"/>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">product[page_layout]</stringProp>
-                        <stringProp name="Argument.desc">false</stringProp>
-                      </elementProp>
-                      <elementProp name="product[options_container]" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value">container2</stringProp>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">product[options_container]</stringProp>
-                        <stringProp name="Argument.desc">false</stringProp>
-                      </elementProp>
-                      <elementProp name="product[configurable_variation]" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value">${configurable_attribute_id}</stringProp>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">product[configurable_variation]</stringProp>
-                        <stringProp name="Argument.desc">false</stringProp>
-                      </elementProp>
-                      <elementProp name="product[url_key]" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value">${configurable_product_name}</stringProp>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">product[url_key]</stringProp>
-                      </elementProp>
-                      <elementProp name="product[use_config_gift_message_available]" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value">1</stringProp>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">product[use_config_gift_message_available]</stringProp>
-                      </elementProp>
-                      <elementProp name="product[use_config_gift_wrapping_available]" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value">1</stringProp>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">product[use_config_gift_wrapping_available]</stringProp>
-                      </elementProp>
-                      <elementProp name="product[visibility]" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value">4</stringProp>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">product[visibility]</stringProp>
-                      </elementProp>
-                      <elementProp name="product[product_has_weight]" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value">1</stringProp>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">product[product_has_weight]</stringProp>
-                        <stringProp name="Argument.desc">true</stringProp>
-                      </elementProp>
-                      <elementProp name="product[stock_data][qty]" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value">50</stringProp>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">product[stock_data][qty]</stringProp>
-                        <stringProp name="Argument.desc">false</stringProp>
-                      </elementProp>
-                      <elementProp name="product[stock_data][type_id]" elementType="HTTPArgument">
-                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                        <stringProp name="Argument.value">configurable</stringProp>
-                        <stringProp name="Argument.metadata">=</stringProp>
-                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                        <stringProp name="Argument.name">product[stock_data][type_id]</stringProp>
-                        <stringProp name="Argument.desc">false</stringProp>
-                      </elementProp>
-                    </collectionProp>
-                  </elementProp>
-                  <stringProp name="HTTPSampler.domain"/>
-                  <stringProp name="HTTPSampler.port"/>
-                  <stringProp name="HTTPSampler.connect_timeout"/>
-                  <stringProp name="HTTPSampler.response_timeout"/>
-                  <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
-                  <stringProp name="HTTPSampler.contentEncoding"/>
-                  <stringProp name="HTTPSampler.path">${base_path}${admin_path}/catalog/product/save/id/${configurable_product_id}/back/edit/active_tab/product-details/</stringProp>
-                  <stringProp name="HTTPSampler.method">POST</stringProp>
-                  <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
-                  <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
-                  <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
-                  <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
-                  <boolProp name="HTTPSampler.monitor">false</boolProp>
-                  <stringProp name="HTTPSampler.embedded_url_re"/>
-                </HTTPSamplerProxy>
-                <hashTree>
-                  <BeanShellPreProcessor guiclass="TestBeanGUI" testclass="BeanShellPreProcessor" testname="Configure product options" enabled="true">
-                    <boolProp name="resetInterpreter">false</boolProp>
-                    <stringProp name="parameters"/>
-                    <stringProp name="filename"/>
-                    <stringProp name="script">try {
-    	int attributesCount = Integer.parseInt(vars.get("configurable_attribute_ids_matchNr"));
-    	for (int i = 1; i &lt;= attributesCount; i++) {
-    		attributeId = vars.get("configurable_attribute_ids_" + i.toString());
-    		attributeCode = vars.get("configurable_attribute_codes_" + i.toString());
-    		attributeLabel = vars.get("configurable_attribute_labels_" + i.toString());
-    		ctx.getCurrentSampler().addArgument("attributes[" + (i - 1).toString() + "]", attributeId);
-    		ctx.getCurrentSampler().addArgument("attribute_codes[" + (i - 1).toString() + "]", attributeCode);
-    		ctx.getCurrentSampler().addArgument("product[" + attributeCode + "]", attributeId);
-    		ctx.getCurrentSampler().addArgument("product[configurable_attributes_data][" + attributeId + "][attribute_id]", attributeId);
-    		ctx.getCurrentSampler().addArgument("product[configurable_attributes_data][" + attributeId + "][position]", (i - 1).toString());
-    		ctx.getCurrentSampler().addArgument("product[configurable_attributes_data][" + attributeId + "][code]", attributeCode);
-    		ctx.getCurrentSampler().addArgument("product[configurable_attributes_data][" + attributeId + "][label]", attributeLabel);
-
-    		int valuesCount = Integer.parseInt(vars.get("attribute_" + attributeId + "_values_matchNr"));
-    		for (int j = 1; j &lt;= valuesCount; j++) {
-    			attributeValue = vars.get("attribute_" + attributeId + "_values_" + j.toString());
-    			ctx.getCurrentSampler().addArgument(
-    				"product[configurable_attributes_data][" + attributeId + "][values][" + attributeValue + "][include]",
-    				"1"
-    			);
-    			ctx.getCurrentSampler().addArgument(
-    				"product[configurable_attributes_data][" + attributeId + "][values][" + attributeValue + "][value_index]",
-    				attributeValue
-    			);
-    		}
-    	}
-    	ctx.getCurrentSampler().addArgument("associated_product_ids_serialized", vars.get("associated_products_ids").toString());
-    } catch (Exception e) {
-        log.error("error???", e);
-    }</stringProp>
-                  </BeanShellPreProcessor>
-                  <hashTree/>
-                  <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Response Assertion" enabled="true">
-                    <collectionProp name="Asserion.test_strings">
-                      <stringProp name="-583471546">You saved the product</stringProp>
-                    </collectionProp>
-                    <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
-                    <boolProp name="Assertion.assume_success">false</boolProp>
-                    <intProp name="Assertion.test_type">2</intProp>
-                    <stringProp name="TestPlan.comments"> if have trouble see messages-message-error </stringProp>
-                  </ResponseAssertion>
-        <hashTree/>
-      </hashTree>
-    </hashTree>
-  </hashTree>
-  </hashTree>
-
-  
-    <ThroughputController guiclass="ThroughputControllerGui" testclass="ThroughputController" testname="Admin Create Product" enabled="true">
-      <intProp name="ThroughputController.style">1</intProp>
-      <boolProp name="ThroughputController.perThread">false</boolProp>
-      <intProp name="ThroughputController.maxThroughput">1</intProp>
-      <stringProp name="ThroughputController.percentThroughput">${adminProductCreationPercentage}</stringProp>
-    <stringProp name="TestPlan.comments">mpaf/tool/fragments/_system/scenario_controller_tmpl.jmx</stringProp></ThroughputController>
-    <hashTree>
-        <JSR223PreProcessor guiclass="TestBeanGUI" testclass="JSR223PreProcessor" testname="Set Test Label" enabled="true">
-            <stringProp name="script">
-var testLabel = "${testLabel}" ? " (${testLabel})" : "";
-if (testLabel
-    &amp;&amp; sampler.getClass().getName() == 'org.apache.jmeter.protocol.http.sampler.HTTPSamplerProxy'
-) {
-    if (sampler.getName().indexOf(testLabel) == -1) {
-       sampler.setName(sampler.getName() + testLabel);
-    }
-} else if (sampler.getName().indexOf("SetUp - ") == -1) {
-    sampler.setName("SetUp - " + sampler.getName());
-}
-            </stringProp>
-            <stringProp name="scriptLanguage">javascript</stringProp>
-        <stringProp name="TestPlan.comments">mpaf/tool/fragments/_system/setup_label.jmx</stringProp></JSR223PreProcessor>
-        <hashTree/>
-        <BeanShellSampler guiclass="BeanShellSamplerGui" testclass="BeanShellSampler" testname="SetUp - Set Label" enabled="true">
-            <stringProp name="BeanShellSampler.query">
-                vars.put("testLabel", "Admin Create Product");
-            </stringProp>
-            <boolProp name="BeanShellSampler.resetInterpreter">true</boolProp>
-        </BeanShellSampler>
-        <hashTree/>
-    
-        <JSR223PostProcessor guiclass="TestBeanGUI" testclass="JSR223PostProcessor" testname="Get admin form key PostProcessor" enabled="true">
-        <stringProp name="script">
-        function getFormKeyFromResponse()
-        {
-            var url = prev.getUrlAsString(),
-            responseCode =  prev.getResponseCode(),
-            formKey = null;
-            searchPattern = /var FORM_KEY = '(.+)'/;
-            if (responseCode == "200" &amp;&amp; url) {
-                response = prev.getResponseDataAsString();
-                formKey = response  &amp;&amp; response.match(searchPattern) ? response.match(searchPattern)[1] : null;
-            }
-            return formKey;
-        }
-
-        formKey = vars.get("form_key_storage");
-
-	   currentFormKey = getFormKeyFromResponse();
-
-	   if (currentFormKey != null &amp;&amp; currentFormKey != formKey) {
-		  vars.put("form_key_storage", currentFormKey);
-	   }
-        </stringProp>
-        <stringProp name="scriptLanguage">javascript</stringProp>
-        <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin/handle_admin_form_key.jmx</stringProp></JSR223PostProcessor>
-        <hashTree/>
-        <JSR223PreProcessor guiclass="TestBeanGUI" testclass="JSR223PreProcessor" testname="Set admin form key PreProcessor" enabled="true">
-            <stringProp name="script">
-                formKey =  vars.get("form_key_storage");
-                if (formKey
-                    &amp;&amp; sampler.getClass().getName() == 'org.apache.jmeter.protocol.http.sampler.HTTPSamplerProxy'
-                    &amp;&amp; sampler.getMethod() == "POST")
-                    {
-                        arguments = sampler.getArguments();
-                        for (i=0; i&lt;arguments.getArgumentCount(); i++)
-                        {
-                            argument = arguments.getArgument(i);
-                            if (argument.getName() == 'form_key' &amp;&amp; argument.getValue() != formKey) {
-                            log.info("admin form key updated: " + argument.getValue() + " =&gt; " + formKey);
-                            argument.setValue(formKey);
-                        }
-                    }
-                }
-            </stringProp>
-            <stringProp name="scriptLanguage">javascript</stringProp>
-        </JSR223PreProcessor>
-        <hashTree/>
-    
-    <CookieManager guiclass="CookiePanel" testclass="CookieManager" testname="HTTP Cookie Manager" enabled="true">
-      <collectionProp name="CookieManager.cookies"/>
-      <boolProp name="CookieManager.clearEachIteration">false</boolProp>
-    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/http_cookie_manager_without_clear_each_iteration.jmx</stringProp></CookieManager>
-    <hashTree/>
-  
-    <OnceOnlyController guiclass="OnceOnlyControllerGui" testclass="OnceOnlyController" testname="Once Only Controller" enabled="true">
-  <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/once_only_controller.jmx</stringProp>
-</OnceOnlyController>
-    <hashTree>
-    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="SetUp - Login" enabled="true">
-      <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
-        <collectionProp name="Arguments.arguments"/>
-      </elementProp>
-      <stringProp name="HTTPSampler.domain"/>
-      <stringProp name="HTTPSampler.port"/>
-      <stringProp name="HTTPSampler.connect_timeout"/>
-      <stringProp name="HTTPSampler.response_timeout"/>
-      <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
-      <stringProp name="HTTPSampler.contentEncoding"/>
-      <stringProp name="HTTPSampler.path">${base_path}${admin_path}</stringProp>
-      <stringProp name="HTTPSampler.method">GET</stringProp>
-      <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
-      <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
-      <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
-      <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
-      <boolProp name="HTTPSampler.monitor">false</boolProp>
-      <stringProp name="HTTPSampler.embedded_url_re"/>
-    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_login/admin_login.jmx</stringProp></HTTPSamplerProxy>
-    <hashTree>
-      <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert login form shown" enabled="true">
-        <collectionProp name="Asserion.test_strings">
-          <stringProp name="-1397214398">Welcome</stringProp>
-          <stringProp name="-515240035">&lt;title&gt;Magento Admin&lt;/title&gt;</stringProp>
-        </collectionProp>
-        <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
-        <boolProp name="Assertion.assume_success">false</boolProp>
-        <intProp name="Assertion.test_type">2</intProp>
-      </ResponseAssertion>
-      <hashTree/>
-      <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract form key" enabled="true">
-        <stringProp name="RegexExtractor.useHeaders">false</stringProp>
-        <stringProp name="RegexExtractor.refname">admin_form_key</stringProp>
-        <stringProp name="RegexExtractor.regex">&lt;input name="form_key" type="hidden" value="([^'"]+)" /&gt;</stringProp>
-        <stringProp name="RegexExtractor.template">$1$</stringProp>
-        <stringProp name="RegexExtractor.default"/>
-        <stringProp name="RegexExtractor.match_number">1</stringProp>
-      </RegexExtractor>
-      <hashTree/>
-      <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert form_key extracted" enabled="true">
-        <collectionProp name="Asserion.test_strings">
-          <stringProp name="2845929">^.+$</stringProp>
-        </collectionProp>
-        <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
-        <boolProp name="Assertion.assume_success">false</boolProp>
-        <intProp name="Assertion.test_type">1</intProp>
-        <stringProp name="Assertion.scope">variable</stringProp>
-        <stringProp name="Scope.variable">admin_form_key</stringProp>
-      </ResponseAssertion>
-      <hashTree/>
-    </hashTree>
-  
-    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="SetUp - Login Submit Form" enabled="true">
-      <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
-        <collectionProp name="Arguments.arguments">
-          <elementProp name="dummy" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value"/>
-            <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">dummy</stringProp>
-          </elementProp>
-          <elementProp name="form_key" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">${admin_form_key}</stringProp>
-            <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">form_key</stringProp>
-          </elementProp>
-          <elementProp name="login[password]" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">${admin_password}</stringProp>
-            <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">login[password]</stringProp>
-          </elementProp>
-          <elementProp name="login[username]" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">${admin_user}</stringProp>
-            <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">login[username]</stringProp>
-          </elementProp>
-        </collectionProp>
-      </elementProp>
-      <stringProp name="HTTPSampler.domain"/>
-      <stringProp name="HTTPSampler.port"/>
-      <stringProp name="HTTPSampler.connect_timeout"/>
-      <stringProp name="HTTPSampler.response_timeout"/>
-      <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
-      <stringProp name="HTTPSampler.contentEncoding"/>
-      <stringProp name="HTTPSampler.path">${base_path}${admin_path}/admin/dashboard/</stringProp>
-      <stringProp name="HTTPSampler.method">POST</stringProp>
-      <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
-      <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
-      <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
-      <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
-      <stringProp name="HTTPSampler.implementation">Java</stringProp>
-      <boolProp name="HTTPSampler.monitor">false</boolProp>
-      <stringProp name="HTTPSampler.embedded_url_re"/>
-      <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_login/admin_login_submit_form.jmx</stringProp>
-    </HTTPSamplerProxy>
-    <hashTree>
-        <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract form key" enabled="true">
-            <stringProp name="RegexExtractor.useHeaders">false</stringProp>
-            <stringProp name="RegexExtractor.refname">admin_form_key</stringProp>
-            <stringProp name="RegexExtractor.regex">&lt;input name="form_key" type="hidden" value="([^'"]+)" /&gt;</stringProp>
-            <stringProp name="RegexExtractor.template">$1$</stringProp>
-            <stringProp name="RegexExtractor.default"/>
-            <stringProp name="RegexExtractor.match_number">1</stringProp>
-        <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_login/admin_retrieve_form_key.jmx</stringProp></RegexExtractor>
-        <hashTree/>
-    </hashTree>
-  
-    <BeanShellSampler guiclass="BeanShellSamplerGui" testclass="BeanShellSampler" testname="SetUp - Get Related Product Id" enabled="true">
-      <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_create_product/get_related_product_id.jmx</stringProp>
-      <stringProp name="BeanShellSampler.query">import org.apache.jmeter.samplers.SampleResult;
-import java.util.Random;
-Random random = new Random();
-if (${seedForRandom} &gt; 0) {
-    random.setSeed(${seedForRandom});
-}
-relatedIndex = random.nextInt(props.get("simple_products_list").size());
-vars.put("related_product_id", props.get("simple_products_list").get(relatedIndex).get("id"));</stringProp>
-      <stringProp name="BeanShellSampler.filename"/>
-      <stringProp name="BeanShellSampler.parameters"/>
-      <boolProp name="BeanShellSampler.resetInterpreter">true</boolProp>
-    </BeanShellSampler>
-    <hashTree/>
-  
-    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="SetUp - Get Color Attribute Id" enabled="true">
-      <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
-        <collectionProp name="Arguments.arguments"/>
-      </elementProp>
-      <stringProp name="HTTPSampler.domain"/>
-      <stringProp name="HTTPSampler.port"/>
-      <stringProp name="HTTPSampler.connect_timeout"/>
-      <stringProp name="HTTPSampler.response_timeout"/>
-      <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
-      <stringProp name="HTTPSampler.contentEncoding"/>
-      <!-- add filter by base64 encoded value of "attribute_code=color" -->
-      <stringProp name="HTTPSampler.path">${base_path}${admin_path}/catalog/product_attribute/index/filter/YXR0cmlidXRlX2NvZGU9Y29sb3I</stringProp>
-      <stringProp name="HTTPSampler.method">GET</stringProp>
-      <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
-      <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
-      <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
-      <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
-      <boolProp name="HTTPSampler.monitor">false</boolProp>
-      <stringProp name="HTTPSampler.embedded_url_re"/>
-    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_create_product/get_color_attribute_id.jmx</stringProp></HTTPSamplerProxy>
-    <hashTree>
-      <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Regular Expression Extractor" enabled="true">
-        <stringProp name="RegexExtractor.useHeaders">false</stringProp>
-        <stringProp name="RegexExtractor.refname">color_id</stringProp>
-        <stringProp name="RegexExtractor.regex">product_attribute\/edit\/attribute_id\/([\d]+)\/" &gt;.*\s*(color).*</stringProp>
-        <stringProp name="RegexExtractor.template">$1$</stringProp>
-        <stringProp name="RegexExtractor.default"/>
-        <stringProp name="RegexExtractor.match_number">1</stringProp>
-      </RegexExtractor>
-      <hashTree/>
-    </hashTree>
-  </hashTree>
-  
-    <GenericController guiclass="LogicControllerGui" testclass="GenericController" testname="Simple Controller" enabled="true">
-  <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/simple_controller.jmx</stringProp>
-</GenericController>
-    <hashTree>
-    <BeanShellSampler guiclass="BeanShellSamplerGui" testclass="BeanShellSampler" testname="SetUp - Set Arguments" enabled="true">
-      <stringProp name="BeanShellSampler.query">import org.apache.jmeter.samplers.SampleResult;
-import java.util.Random;
-Random random = new Random();
-if (${seedForRandom} &gt; 0) {
-    random.setSeed(${seedForRandom});
-}
-number = random.nextInt(props.get("simple_products_list").size());
-simpleList = props.get("simple_products_list").get(number);
-vars.put("simple_product_1_id", simpleList.get("id"));
-
-do {
-    number1 = random.nextInt(props.get("simple_products_list").size());
-} while(number == number1);
-simpleList = props.get("simple_products_list").get(number1);
-vars.put("simple_product_2_id", simpleList.get("id"));
-
-number2 = random.nextInt(props.get("configurable_products_list").size());
-configurableList = props.get("configurable_products_list").get(number2);
-vars.put("configurable_product_1_id", configurableList.get("id"));
-vars.put("configurable_product_1_url_key", configurableList.get("url_key"));
-vars.put("configurable_product_1_name", configurableList.get("title"));
-
-//Additional category to be added
-//int categoryId = Integer.parseInt(vars.get("simple_product_category_id"));
-//vars.put("category_additional", (categoryId+1).toString());
-//New price
-vars.put("price_new", "9999");
-//New special price
-vars.put("special_price_new", "8888");
-//New quantity
-vars.put("quantity_new", "100600");</stringProp>
-      <stringProp name="BeanShellSampler.filename"/>
-      <stringProp name="BeanShellSampler.parameters"/>
-      <boolProp name="BeanShellSampler.resetInterpreter">true</boolProp>
-    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_create_product/setup.jmx</stringProp></BeanShellSampler>
-    <hashTree/>
-  
-    <TestFragmentController guiclass="TestFragmentControllerGui" testclass="TestFragmentController" testname="Admin Create Bundle Product" enabled="true">
-  <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_create_product/create_bundle_product.jmx</stringProp>
-</TestFragmentController>
-    <hashTree>
-      <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Catalog Product" enabled="true">
-        <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
-          <collectionProp name="Arguments.arguments"/>
-        </elementProp>
-        <stringProp name="HTTPSampler.domain"/>
-        <stringProp name="HTTPSampler.port"/>
-        <stringProp name="HTTPSampler.connect_timeout"/>
-        <stringProp name="HTTPSampler.response_timeout"/>
-        <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
-        <stringProp name="HTTPSampler.contentEncoding"/>
-        <stringProp name="HTTPSampler.path">${base_path}${admin_path}/catalog/product/</stringProp>
-        <stringProp name="HTTPSampler.method">GET</stringProp>
-        <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
-        <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
-        <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
-        <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
-        <boolProp name="HTTPSampler.monitor">false</boolProp>
-        <stringProp name="HTTPSampler.embedded_url_re"/>
-      </HTTPSamplerProxy>
-      <hashTree>
-        <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Response Assertion" enabled="true">
-          <collectionProp name="Asserion.test_strings">
-            <stringProp name="1509986340">records found</stringProp>
-          </collectionProp>
-          <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
-          <boolProp name="Assertion.assume_success">false</boolProp>
-          <intProp name="Assertion.test_type">2</intProp>
-        </ResponseAssertion>
-        <hashTree/>
-      </hashTree>
-      <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="New Bundle Product" enabled="true">
-        <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
-          <collectionProp name="Arguments.arguments"/>
-        </elementProp>
-        <stringProp name="HTTPSampler.domain"/>
-        <stringProp name="HTTPSampler.port"/>
-        <stringProp name="HTTPSampler.connect_timeout"/>
-        <stringProp name="HTTPSampler.response_timeout"/>
-        <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
-        <stringProp name="HTTPSampler.contentEncoding"/>
-        <stringProp name="HTTPSampler.path">${base_path}${admin_path}/catalog/product/new/set/4/type/bundle/</stringProp>
-        <stringProp name="HTTPSampler.method">GET</stringProp>
-        <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
-        <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
-        <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
-        <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
-        <boolProp name="HTTPSampler.monitor">false</boolProp>
-        <stringProp name="HTTPSampler.embedded_url_re"/>
-      </HTTPSamplerProxy>
-      <hashTree>
-        <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Response Assertion" enabled="true">
-          <collectionProp name="Asserion.test_strings">
-            <stringProp name="-144461265">New Product</stringProp>
-          </collectionProp>
-          <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
-          <boolProp name="Assertion.assume_success">false</boolProp>
-          <intProp name="Assertion.test_type">2</intProp>
-        </ResponseAssertion>
-        <hashTree/>
-      </hashTree>
-      <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="New Bundle Product Validate" enabled="true">
-        <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
-          <collectionProp name="Arguments.arguments">
-            <elementProp name="ajax" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">true</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">ajax</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="isAjax" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">true</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">isAjax</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="form_key" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">${admin_form_key}</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">form_key</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="product[name]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">Bundle Product ${__time(YMDHMS)}-${__threadNum}-${__Random(1,1000000)}</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[name]</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="product[sku]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">SKU ${__time(YMDHMS)}-${__threadNum}-${__Random(1,1000000)}</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[sku]</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="product[price]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">123</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[price]</stringProp>
-            </elementProp>
-            <elementProp name="product[tax_class_id]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">2</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[tax_class_id]</stringProp>
-            </elementProp>
-            <elementProp name="product[quantity_and_stock_status][qty]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">111</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[quantity_and_stock_status][qty]</stringProp>
-            </elementProp>
-            <elementProp name="product[quantity_and_stock_status][is_in_stock]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[quantity_and_stock_status][is_in_stock]</stringProp>
-            </elementProp>
-            <elementProp name="product[weight]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1.0000</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[weight]</stringProp>
-            </elementProp>
-            <elementProp name="product[product_has_weight]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[product_has_weight]</stringProp>
-              <stringProp name="Argument.desc">true</stringProp>
-            </elementProp>
-            <elementProp name="product[category_ids][]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">2</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[category_ids][]</stringProp>
-            </elementProp>
-            <elementProp name="product[description]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">&lt;p&gt;Full bundle product description ${__time(YMDHMS)}-${__threadNum}-${__Random(1,1000000)}&lt;/p&gt;</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[description]</stringProp>
-            </elementProp>
-            <elementProp name="product[short_description]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">&lt;p&gt;Short bundle product description ${__time(YMDHMS)}-${__threadNum}-${__Random(1,1000000)}&lt;/p&gt;</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[short_description]</stringProp>
-            </elementProp>
-            <elementProp name="product[status]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[status]</stringProp>
-            </elementProp>
-            <elementProp name="product[configurable_variations]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[configurable_variations]</stringProp>
-            </elementProp>
-            <elementProp name="affect_configurable_product_attributes" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">affect_configurable_product_attributes</stringProp>
-            </elementProp>
-            <elementProp name="product[image]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[image]</stringProp>
-            </elementProp>
-            <elementProp name="product[small_image]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[small_image]</stringProp>
-            </elementProp>
-            <elementProp name="product[thumbnail]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[thumbnail]</stringProp>
-            </elementProp>
-            <elementProp name="product[url_key]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">bundle-product-${__time(YMDHMS)}-${__threadNum}-${__Random(1,1000000)}</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[url_key]</stringProp>
-            </elementProp>
-            <elementProp name="product[meta_title]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">Bundle Product ${__time(YMDHMS)}-${__threadNum}-${__Random(1,1000000)} Meta Title</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[meta_title]</stringProp>
-            </elementProp>
-            <elementProp name="product[meta_keyword]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">Bundle Product ${__time(YMDHMS)}-${__threadNum}-${__Random(1,1000000)} Meta Keyword</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[meta_keyword]</stringProp>
-            </elementProp>
-            <elementProp name="product[meta_description]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">Bundle Product ${__time(YMDHMS)}-${__threadNum}-${__Random(1,1000000)} Meta Description</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[meta_description]</stringProp>
-            </elementProp>
-            <elementProp name="product[website_ids][]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[website_ids][]</stringProp>
-            </elementProp>
-            <elementProp name="product[special_price]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">99</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[special_price]</stringProp>
-            </elementProp>
-            <elementProp name="product[stock_data][notify_stock_qty]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[stock_data][notify_stock_qty]</stringProp>
-            </elementProp>
-            <elementProp name="product[special_from_date]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[special_from_date]</stringProp>
-            </elementProp>
-            <elementProp name="product[special_to_date]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[special_to_date]</stringProp>
-            </elementProp>
-            <elementProp name="product[cost]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[cost]</stringProp>
-            </elementProp>
-            <elementProp name="product[tier_price][0][website_id]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">0</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[tier_price][0][website_id]</stringProp>
-            </elementProp>
-            <elementProp name="product[tier_price][0][cust_group]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">32000</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[tier_price][0][cust_group]</stringProp>
-            </elementProp>
-            <elementProp name="product[tier_price][0][price_qty]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">100</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[tier_price][0][price_qty]</stringProp>
-            </elementProp>
-            <elementProp name="product[tier_price][0][price]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">90</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[tier_price][0][price]</stringProp>
-            </elementProp>
-            <elementProp name="product[tier_price][0][delete]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[tier_price][0][delete]</stringProp>
-            </elementProp>
-            <elementProp name="product[tier_price][1][website_id]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">0</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[tier_price][1][website_id]</stringProp>
-            </elementProp>
-            <elementProp name="product[tier_price][1][cust_group]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[tier_price][1][cust_group]</stringProp>
-            </elementProp>
-            <elementProp name="product[tier_price][1][price_qty]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">101</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[tier_price][1][price_qty]</stringProp>
-            </elementProp>
-            <elementProp name="product[tier_price][1][price]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">99</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[tier_price][1][price]</stringProp>
-            </elementProp>
-            <elementProp name="product[tier_price][1][delete]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[tier_price][1][delete]</stringProp>
-            </elementProp>
-            <elementProp name="product[stock_data][use_config_manage_stock]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[stock_data][use_config_manage_stock]</stringProp>
-            </elementProp>
-            <elementProp name="product[stock_data][original_inventory_qty]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">100500</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[stock_data][original_inventory_qty]</stringProp>
-            </elementProp>
-            <elementProp name="product[stock_data][qty]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">100500</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[stock_data][qty]</stringProp>
-            </elementProp>
-            <elementProp name="product[stock_data][min_qty]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">0</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[stock_data][min_qty]</stringProp>
-            </elementProp>
-            <elementProp name="product[stock_data][use_config_min_qty]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[stock_data][use_config_min_qty]</stringProp>
-            </elementProp>
-            <elementProp name="product[stock_data][min_sale_qty]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[stock_data][min_sale_qty]</stringProp>
-            </elementProp>
-            <elementProp name="product[stock_data][use_config_min_sale_qty]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[stock_data][use_config_min_sale_qty]</stringProp>
-            </elementProp>
-            <elementProp name="product[stock_data][max_sale_qty]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">10000</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[stock_data][max_sale_qty]</stringProp>
-            </elementProp>
-            <elementProp name="product[stock_data][use_config_max_sale_qty]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[stock_data][use_config_max_sale_qty]</stringProp>
-            </elementProp>
-            <elementProp name="product[stock_data][is_qty_decimal]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">0</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[stock_data][is_qty_decimal]</stringProp>
-            </elementProp>
-            <elementProp name="product[stock_data][is_decimal_divided]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">0</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[stock_data][is_decimal_divided]</stringProp>
-            </elementProp>
-            <elementProp name="product[stock_data][backorders]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">0</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[stock_data][backorders]</stringProp>
-            </elementProp>
-            <elementProp name="product[stock_data][use_config_backorders]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[stock_data][use_config_backorders]</stringProp>
-            </elementProp>
-            <elementProp name="product[stock_data][use_config_notify_stock_qty]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[stock_data][use_config_notify_stock_qty]</stringProp>
-            </elementProp>
-            <elementProp name="product[stock_data][enable_qty_increments]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">0</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[stock_data][enable_qty_increments]</stringProp>
-            </elementProp>
-            <elementProp name="product[stock_data][qty_increments]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">0</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[stock_data][qty_increments]</stringProp>
-            </elementProp>
-            <elementProp name="product[stock_data][use_config_qty_increments]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[stock_data][use_config_qty_increments]</stringProp>
-            </elementProp>
-            <elementProp name="product[stock_data][is_in_stock]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[stock_data][is_in_stock]</stringProp>
-            </elementProp>
-            <elementProp name="product[custom_design]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[custom_design]</stringProp>
-            </elementProp>
-            <elementProp name="product[custom_design_from]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[custom_design_from]</stringProp>
-            </elementProp>
-            <elementProp name="product[custom_design_to]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[custom_design_to]</stringProp>
-            </elementProp>
-            <elementProp name="product[custom_layout_update]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[custom_layout_update]</stringProp>
-            </elementProp>
-            <elementProp name="product[page_layout]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[page_layout]</stringProp>
-            </elementProp>
-            <elementProp name="product[options_container]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">container2</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[options_container]</stringProp>
-            </elementProp>
-            <elementProp name="new-variations-attribute-set-id" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">new-variations-attribute-set-id</stringProp>
-            </elementProp>
-            <elementProp name="product[shipment_type]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">0</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[shipment_type]</stringProp>
-            </elementProp>
-            <elementProp name="bundle_options[0][title]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">option title one</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">bundle_options[0][title]</stringProp>
-            </elementProp>
-            <elementProp name="bundle_options[0][option_id]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">bundle_options[0][option_id]</stringProp>
-            </elementProp>
-            <elementProp name="bundle_options[0][delete]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">bundle_options[0][delete]</stringProp>
-            </elementProp>
-            <elementProp name="bundle_options[0][type]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">select</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">bundle_options[0][type]</stringProp>
-            </elementProp>
-            <elementProp name="bundle_options[0][required]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">bundle_options[0][required]</stringProp>
-            </elementProp>
-            <elementProp name="bundle_options[0][position]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">0</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">bundle_options[0][position]</stringProp>
-            </elementProp>
-            <elementProp name="bundle_selections[0][0][selection_id]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">bundle_selections[0][0][selection_id]</stringProp>
-            </elementProp>
-            <elementProp name="bundle_selections[0][0][option_id]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">bundle_selections[0][0][option_id]</stringProp>
-            </elementProp>
-            <elementProp name="bundle_selections[0][0][product_id]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">${simple_product_1_id}</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">bundle_selections[0][0][product_id]</stringProp>
-            </elementProp>
-            <elementProp name="bundle_selections[0][0][delete]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">bundle_selections[0][0][delete]</stringProp>
-            </elementProp>
-            <elementProp name="bundle_selections[0][0][selection_price_value]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">0.00</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">bundle_selections[0][0][selection_price_value]</stringProp>
-            </elementProp>
-            <elementProp name="bundle_selections[0][0][selection_price_type]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">0</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">bundle_selections[0][0][selection_price_type]</stringProp>
-            </elementProp>
-            <elementProp name="bundle_selections[0][0][selection_qty]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">bundle_selections[0][0][selection_qty]</stringProp>
-            </elementProp>
-            <elementProp name="bundle_selections[0][0][selection_can_change_qty]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">bundle_selections[0][0][selection_can_change_qty]</stringProp>
-            </elementProp>
-            <elementProp name="bundle_selections[0][0][position]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">0</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">bundle_selections[0][0][position]</stringProp>
-            </elementProp>
-            <elementProp name="bundle_selections[0][1][selection_id]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">bundle_selections[0][1][selection_id]</stringProp>
-            </elementProp>
-            <elementProp name="bundle_selections[0][1][option_id]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">bundle_selections[0][1][option_id]</stringProp>
-            </elementProp>
-            <elementProp name="bundle_selections[0][1][product_id]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">${simple_product_2_id}</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">bundle_selections[0][1][product_id]</stringProp>
-            </elementProp>
-            <elementProp name="bundle_selections[0][1][delete]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">bundle_selections[0][1][delete]</stringProp>
-            </elementProp>
-            <elementProp name="bundle_selections[0][1][selection_price_value]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">0.00</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">bundle_selections[0][1][selection_price_value]</stringProp>
-            </elementProp>
-            <elementProp name="bundle_selections[0][1][selection_price_type]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">0</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">bundle_selections[0][1][selection_price_type]</stringProp>
-            </elementProp>
-            <elementProp name="bundle_selections[0][1][selection_qty]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">bundle_selections[0][1][selection_qty]</stringProp>
-            </elementProp>
-            <elementProp name="bundle_selections[0][1][selection_can_change_qty]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">bundle_selections[0][1][selection_can_change_qty]</stringProp>
-            </elementProp>
-            <elementProp name="bundle_selections[0][1][position]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">bundle_selections[0][1][position]</stringProp>
-            </elementProp>
-            <elementProp name="bundle_options[1][title]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">option title two</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">bundle_options[1][title]</stringProp>
-            </elementProp>
-            <elementProp name="bundle_options[1][option_id]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">bundle_options[1][option_id]</stringProp>
-            </elementProp>
-            <elementProp name="bundle_options[1][delete]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">bundle_options[1][delete]</stringProp>
-            </elementProp>
-            <elementProp name="bundle_options[1][type]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">select</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">bundle_options[1][type]</stringProp>
-            </elementProp>
-            <elementProp name="bundle_options[1][required]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">bundle_options[1][required]</stringProp>
-            </elementProp>
-            <elementProp name="bundle_options[1][position]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">bundle_options[1][position]</stringProp>
-            </elementProp>
-            <elementProp name="bundle_selections[1][0][selection_id]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">bundle_selections[1][0][selection_id]</stringProp>
-              <stringProp name="Argument.desc">true</stringProp>
-            </elementProp>
-            <elementProp name="bundle_selections[1][0][option_id]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">bundle_selections[1][0][option_id]</stringProp>
-              <stringProp name="Argument.desc">true</stringProp>
-            </elementProp>
-            <elementProp name="bundle_selections[1][0][product_id]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">${simple_product_1_id}</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">bundle_selections[1][0][product_id]</stringProp>
-              <stringProp name="Argument.desc">true</stringProp>
-            </elementProp>
-            <elementProp name="bundle_selections[1][0][delete]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">bundle_selections[1][0][delete]</stringProp>
-              <stringProp name="Argument.desc">true</stringProp>
-            </elementProp>
-            <elementProp name="bundle_selections[1][0][selection_price_value]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">0.00</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">bundle_selections[1][0][selection_price_value]</stringProp>
-              <stringProp name="Argument.desc">true</stringProp>
-            </elementProp>
-            <elementProp name="bundle_selections[1][0][selection_price_type]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">0</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">bundle_selections[1][0][selection_price_type]</stringProp>
-              <stringProp name="Argument.desc">true</stringProp>
-            </elementProp>
-            <elementProp name="bundle_selections[1][0][selection_qty]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">bundle_selections[1][0][selection_qty]</stringProp>
-              <stringProp name="Argument.desc">true</stringProp>
-            </elementProp>
-            <elementProp name="bundle_selections[1][0][selection_can_change_qty]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">bundle_selections[1][0][selection_can_change_qty]</stringProp>
-              <stringProp name="Argument.desc">true</stringProp>
-            </elementProp>
-            <elementProp name="bundle_selections[1][0][position]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">0</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">bundle_selections[1][0][position]</stringProp>
-              <stringProp name="Argument.desc">true</stringProp>
-            </elementProp>
-            <elementProp name="bundle_selections[1][1][selection_id]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">bundle_selections[1][1][selection_id]</stringProp>
-              <stringProp name="Argument.desc">true</stringProp>
-            </elementProp>
-            <elementProp name="bundle_selections[1][1][option_id]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">bundle_selections[1][1][option_id]</stringProp>
-              <stringProp name="Argument.desc">true</stringProp>
-            </elementProp>
-            <elementProp name="bundle_selections[1][1][product_id]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">${simple_product_2_id}</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">bundle_selections[1][1][product_id]</stringProp>
-              <stringProp name="Argument.desc">true</stringProp>
-            </elementProp>
-            <elementProp name="bundle_selections[1][1][delete]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">bundle_selections[1][1][delete]</stringProp>
-              <stringProp name="Argument.desc">true</stringProp>
-            </elementProp>
-            <elementProp name="bundle_selections[1][1][selection_price_value]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">0.00</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">bundle_selections[1][1][selection_price_value]</stringProp>
-              <stringProp name="Argument.desc">true</stringProp>
-            </elementProp>
-            <elementProp name="bundle_selections[1][1][selection_price_type]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">0</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">bundle_selections[1][1][selection_price_type]</stringProp>
-              <stringProp name="Argument.desc">true</stringProp>
-            </elementProp>
-            <elementProp name="bundle_selections[1][1][selection_qty]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">bundle_selections[1][1][selection_qty]</stringProp>
-              <stringProp name="Argument.desc">true</stringProp>
-            </elementProp>
-            <elementProp name="bundle_selections[1][1][selection_can_change_qty]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">bundle_selections[1][1][selection_can_change_qty]</stringProp>
-              <stringProp name="Argument.desc">true</stringProp>
-            </elementProp>
-            <elementProp name="bundle_selections[1][1][position]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">bundle_selections[1][1][position]</stringProp>
-              <stringProp name="Argument.desc">true</stringProp>
-            </elementProp>
-            <elementProp name="affect_bundle_product_selections" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">2</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">affect_bundle_product_selections</stringProp>
-              <stringProp name="Argument.desc">true</stringProp>
-            </elementProp>
-            <elementProp name="links[related][0][id]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">${related_product_id}</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">links[related][0][id]</stringProp>
-            </elementProp>
-            <elementProp name="links[related][0][position]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">links[related][0][position]</stringProp>
-            </elementProp>
-            <elementProp name="links[upsell][0][id]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">${related_product_id}</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">links[upsell][0][id]</stringProp>
-            </elementProp>
-            <elementProp name="links[upsell][0][position]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">links[upsell][0][position]</stringProp>
-            </elementProp>
-            <elementProp name="links[crosssell][0][id]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">${related_product_id}</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">links[crosssell][0][id]</stringProp>
-            </elementProp>
-            <elementProp name="links[crosssell][0][position]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">links[crosssell][0][position]</stringProp>
-            </elementProp>
-          </collectionProp>
-        </elementProp>
-        <stringProp name="HTTPSampler.domain"/>
-        <stringProp name="HTTPSampler.port"/>
-        <stringProp name="HTTPSampler.connect_timeout"/>
-        <stringProp name="HTTPSampler.response_timeout"/>
-        <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
-        <stringProp name="HTTPSampler.contentEncoding"/>
-        <stringProp name="HTTPSampler.path">${base_path}${admin_path}/catalog/product/validate/set/4/</stringProp>
-        <stringProp name="HTTPSampler.method">POST</stringProp>
-        <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
-        <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
-        <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
-        <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
-        <boolProp name="HTTPSampler.monitor">false</boolProp>
-        <stringProp name="HTTPSampler.embedded_url_re"/>
-      </HTTPSamplerProxy>
-      <hashTree>
-        <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Response Assertion" enabled="true">
-          <collectionProp name="Asserion.test_strings">
-            <stringProp name="1853918323">{"error":false}</stringProp>
-          </collectionProp>
-          <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
-          <boolProp name="Assertion.assume_success">false</boolProp>
-          <intProp name="Assertion.test_type">2</intProp>
-        </ResponseAssertion>
-        <hashTree/>
-      </hashTree>
-      <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="New Bundle Product Save" enabled="true">
-        <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
-          <collectionProp name="Arguments.arguments">
-            <elementProp name="ajax" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">true</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">ajax</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="isAjax" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">true</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">isAjax</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="form_key" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">${admin_form_key}</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">form_key</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="product[name]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">Bundle Product ${__time(YMDHMS)}-${__threadNum}-${__Random(1,1000000)}</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[name]</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="product[sku]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">SKU ${__time(YMDHMS)}-${__threadNum}-${__Random(1,1000000)}</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[sku]</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="product[price]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">123</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[price]</stringProp>
-            </elementProp>
-            <elementProp name="product[tax_class_id]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">2</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[tax_class_id]</stringProp>
-            </elementProp>
-            <elementProp name="product[quantity_and_stock_status][qty]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">111</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[quantity_and_stock_status][qty]</stringProp>
-            </elementProp>
-            <elementProp name="product[quantity_and_stock_status][is_in_stock]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[quantity_and_stock_status][is_in_stock]</stringProp>
-            </elementProp>
-            <elementProp name="product[weight]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1.0000</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[weight]</stringProp>
-            </elementProp>
-            <elementProp name="product[product_has_weight]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[product_has_weight]</stringProp>
-              <stringProp name="Argument.desc">true</stringProp>
-            </elementProp>
-            <elementProp name="product[category_ids][]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">2</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[category_ids][]</stringProp>
-            </elementProp>
-            <elementProp name="product[description]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">&lt;p&gt;Full bundle product Description ${__time(YMDHMS)}-${__threadNum}-${__Random(1,1000000)}&lt;/p&gt;</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[description]</stringProp>
-            </elementProp>
-            <elementProp name="product[short_description]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">&lt;p&gt;Short bundle product description ${__time(YMDHMS)}-${__threadNum}-${__Random(1,1000000)}&lt;/p&gt;</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[short_description]</stringProp>
-            </elementProp>
-            <elementProp name="product[status]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[status]</stringProp>
-            </elementProp>
-            <elementProp name="product[configurable_variations]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[configurable_variations]</stringProp>
-            </elementProp>
-            <elementProp name="affect_configurable_product_attributes" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">affect_configurable_product_attributes</stringProp>
-            </elementProp>
-            <elementProp name="product[image]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[image]</stringProp>
-            </elementProp>
-            <elementProp name="product[small_image]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[small_image]</stringProp>
-            </elementProp>
-            <elementProp name="product[thumbnail]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[thumbnail]</stringProp>
-            </elementProp>
-            <elementProp name="product[url_key]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">bundle-product-${__time(YMDHMS)}-${__threadNum}-${__Random(1,1000000)}</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[url_key]</stringProp>
-            </elementProp>
-            <elementProp name="product[meta_title]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">Bundle Product ${__time(YMDHMS)}-${__threadNum}-${__Random(1,1000000)} Meta Title</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[meta_title]</stringProp>
-            </elementProp>
-            <elementProp name="product[meta_keyword]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">Bundle Product ${__time(YMDHMS)}-${__threadNum}-${__Random(1,1000000)} Meta Keyword</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[meta_keyword]</stringProp>
-            </elementProp>
-            <elementProp name="product[meta_description]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">Bundle Product ${__time(YMDHMS)}-${__threadNum}-${__Random(1,1000000)} Meta Description</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[meta_description]</stringProp>
-            </elementProp>
-            <elementProp name="product[website_ids][]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[website_ids][]</stringProp>
-            </elementProp>
-            <elementProp name="product[special_price]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">99</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[special_price]</stringProp>
-            </elementProp>
-            <elementProp name="product[special_from_date]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[special_from_date]</stringProp>
-            </elementProp>
-            <elementProp name="product[special_to_date]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[special_to_date]</stringProp>
-            </elementProp>
-            <elementProp name="product[cost]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[cost]</stringProp>
-            </elementProp>
-            <elementProp name="product[tier_price][0][website_id]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">0</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[tier_price][0][website_id]</stringProp>
-            </elementProp>
-            <elementProp name="product[tier_price][0][cust_group]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">32000</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[tier_price][0][cust_group]</stringProp>
-            </elementProp>
-            <elementProp name="product[tier_price][0][price_qty]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">100</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[tier_price][0][price_qty]</stringProp>
-            </elementProp>
-            <elementProp name="product[tier_price][0][price]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">90</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[tier_price][0][price]</stringProp>
-            </elementProp>
-            <elementProp name="product[tier_price][0][delete]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[tier_price][0][delete]</stringProp>
-            </elementProp>
-            <elementProp name="product[tier_price][1][website_id]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">0</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[tier_price][1][website_id]</stringProp>
-            </elementProp>
-            <elementProp name="product[tier_price][1][cust_group]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[tier_price][1][cust_group]</stringProp>
-            </elementProp>
-            <elementProp name="product[tier_price][1][price_qty]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">101</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[tier_price][1][price_qty]</stringProp>
-            </elementProp>
-            <elementProp name="product[tier_price][1][price]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">99</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[tier_price][1][price]</stringProp>
-            </elementProp>
-            <elementProp name="product[tier_price][1][delete]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[tier_price][1][delete]</stringProp>
-            </elementProp>
-            <elementProp name="product[stock_data][use_config_manage_stock]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[stock_data][use_config_manage_stock]</stringProp>
-            </elementProp>
-            <elementProp name="product[stock_data][original_inventory_qty]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">100500</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[stock_data][original_inventory_qty]</stringProp>
-            </elementProp>
-            <elementProp name="product[stock_data][qty]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">100500</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[stock_data][qty]</stringProp>
-            </elementProp>
-            <elementProp name="product[stock_data][min_qty]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">0</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[stock_data][min_qty]</stringProp>
-            </elementProp>
-            <elementProp name="product[stock_data][use_config_min_qty]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[stock_data][use_config_min_qty]</stringProp>
-            </elementProp>
-            <elementProp name="product[stock_data][min_sale_qty]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[stock_data][min_sale_qty]</stringProp>
-            </elementProp>
-            <elementProp name="product[stock_data][use_config_min_sale_qty]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[stock_data][use_config_min_sale_qty]</stringProp>
-            </elementProp>
-            <elementProp name="product[stock_data][max_sale_qty]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">10000</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[stock_data][max_sale_qty]</stringProp>
-            </elementProp>
-            <elementProp name="product[stock_data][use_config_max_sale_qty]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[stock_data][use_config_max_sale_qty]</stringProp>
-            </elementProp>
-            <elementProp name="product[stock_data][is_qty_decimal]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">0</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[stock_data][is_qty_decimal]</stringProp>
-            </elementProp>
-            <elementProp name="product[stock_data][is_decimal_divided]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">0</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[stock_data][is_decimal_divided]</stringProp>
-            </elementProp>
-            <elementProp name="product[stock_data][backorders]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">0</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[stock_data][backorders]</stringProp>
-            </elementProp>
-            <elementProp name="product[stock_data][use_config_backorders]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[stock_data][use_config_backorders]</stringProp>
-            </elementProp>
-            <elementProp name="product[stock_data][notify_stock_qty]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[stock_data][notify_stock_qty]</stringProp>
-            </elementProp>
-            <elementProp name="product[stock_data][use_config_notify_stock_qty]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[stock_data][use_config_notify_stock_qty]</stringProp>
-            </elementProp>
-            <elementProp name="product[stock_data][enable_qty_increments]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">0</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[stock_data][enable_qty_increments]</stringProp>
-            </elementProp>
-            <elementProp name="product[stock_data][qty_increments]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">0</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[stock_data][qty_increments]</stringProp>
-            </elementProp>
-            <elementProp name="product[stock_data][use_config_qty_increments]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[stock_data][use_config_qty_increments]</stringProp>
-            </elementProp>
-            <elementProp name="product[stock_data][is_in_stock]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[stock_data][is_in_stock]</stringProp>
-            </elementProp>
-            <elementProp name="product[custom_design]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[custom_design]</stringProp>
-            </elementProp>
-            <elementProp name="product[custom_design_from]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[custom_design_from]</stringProp>
-            </elementProp>
-            <elementProp name="product[custom_design_to]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[custom_design_to]</stringProp>
-            </elementProp>
-            <elementProp name="product[custom_layout_update]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[custom_layout_update]</stringProp>
-            </elementProp>
-            <elementProp name="product[page_layout]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[page_layout]</stringProp>
-            </elementProp>
-            <elementProp name="product[options_container]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">container2</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[options_container]</stringProp>
-            </elementProp>
-            <elementProp name="new-variations-attribute-set-id" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">new-variations-attribute-set-id</stringProp>
-            </elementProp>
-            <elementProp name="product[shipment_type]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">0</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[shipment_type]</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="bundle_options[0][title]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">option title one</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">bundle_options[0][title]</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="bundle_options[0][option_id]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">bundle_options[0][option_id]</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="bundle_options[0][delete]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">bundle_options[0][delete]</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="bundle_options[0][type]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">select</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">bundle_options[0][type]</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="bundle_options[0][required]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">bundle_options[0][required]</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="bundle_options[0][position]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">0</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">bundle_options[0][position]</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="bundle_selections[0][0][selection_id]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">bundle_selections[0][0][selection_id]</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="bundle_selections[0][0][option_id]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">bundle_selections[0][0][option_id]</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="bundle_selections[0][0][product_id]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">${simple_product_1_id}</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">bundle_selections[0][0][product_id]</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="bundle_selections[0][0][delete]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">bundle_selections[0][0][delete]</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="bundle_selections[0][0][selection_price_value]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">0.00</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">bundle_selections[0][0][selection_price_value]</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="bundle_selections[0][0][selection_price_type]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">0</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">bundle_selections[0][0][selection_price_type]</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="bundle_selections[0][0][selection_qty]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">bundle_selections[0][0][selection_qty]</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="bundle_selections[0][0][selection_can_change_qty]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">bundle_selections[0][0][selection_can_change_qty]</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="bundle_selections[0][0][position]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">0</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">bundle_selections[0][0][position]</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="bundle_selections[0][1][selection_id]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">bundle_selections[0][1][selection_id]</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="bundle_selections[0][1][option_id]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">bundle_selections[0][1][option_id]</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="bundle_selections[0][1][product_id]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">${simple_product_2_id}</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">bundle_selections[0][1][product_id]</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="bundle_selections[0][1][delete]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">bundle_selections[0][1][delete]</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="bundle_selections[0][1][selection_price_value]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">0.00</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">bundle_selections[0][1][selection_price_value]</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="bundle_selections[0][1][selection_price_type]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">0</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">bundle_selections[0][1][selection_price_type]</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="bundle_selections[0][1][selection_qty]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">bundle_selections[0][1][selection_qty]</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="bundle_selections[0][1][selection_can_change_qty]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">bundle_selections[0][1][selection_can_change_qty]</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="bundle_selections[0][1][position]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">bundle_selections[0][1][position]</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="bundle_options[1][title]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">option title two</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">bundle_options[1][title]</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="bundle_options[1][option_id]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">bundle_options[1][option_id]</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="bundle_options[1][delete]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">bundle_options[1][delete]</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="bundle_options[1][type]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">select</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">bundle_options[1][type]</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="bundle_options[1][required]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">bundle_options[1][required]</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="bundle_options[1][position]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">bundle_options[1][position]</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="bundle_selections[1][0][selection_id]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">bundle_selections[1][0][selection_id]</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="bundle_selections[1][0][option_id]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">bundle_selections[1][0][option_id]</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="bundle_selections[1][0][product_id]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">${simple_product_1_id}</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">bundle_selections[1][0][product_id]</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="bundle_selections[1][0][delete]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">bundle_selections[1][0][delete]</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="bundle_selections[1][0][selection_price_value]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">0.00</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">bundle_selections[1][0][selection_price_value]</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="bundle_selections[1][0][selection_price_type]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">0</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">bundle_selections[1][0][selection_price_type]</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="bundle_selections[1][0][selection_qty]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">bundle_selections[1][0][selection_qty]</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="bundle_selections[1][0][selection_can_change_qty]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">bundle_selections[1][0][selection_can_change_qty]</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="bundle_selections[1][0][position]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">0</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">bundle_selections[1][0][position]</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="bundle_selections[1][1][selection_id]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">bundle_selections[1][1][selection_id]</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="bundle_selections[1][1][option_id]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">bundle_selections[1][1][option_id]</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="bundle_selections[1][1][product_id]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">${simple_product_2_id}</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">bundle_selections[1][1][product_id]</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="bundle_selections[1][1][delete]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">bundle_selections[1][1][delete]</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="bundle_selections[1][1][selection_price_value]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">0.00</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">bundle_selections[1][1][selection_price_value]</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="bundle_selections[1][1][selection_price_type]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">0</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">bundle_selections[1][1][selection_price_type]</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="bundle_selections[1][1][selection_qty]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">bundle_selections[1][1][selection_qty]</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="bundle_selections[1][1][selection_can_change_qty]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">bundle_selections[1][1][selection_can_change_qty]</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="bundle_selections[1][1][position]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">bundle_selections[1][1][position]</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="affect_bundle_product_selections" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">2</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">affect_bundle_product_selections</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="links[related][0][id]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">${related_product_id}</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">links[related][0][id]</stringProp>
-            </elementProp>
-            <elementProp name="links[related][0][position]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">links[related][0][position]</stringProp>
-            </elementProp>
-            <elementProp name="links[upsell][0][id]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">${related_product_id}</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">links[upsell][0][id]</stringProp>
-            </elementProp>
-            <elementProp name="links[upsell][0][position]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">links[upsell][0][position]</stringProp>
-            </elementProp>
-            <elementProp name="links[crosssell][0][id]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">${related_product_id}</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">links[crosssell][0][id]</stringProp>
-            </elementProp>
-            <elementProp name="links[crosssell][0][position]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">links[crosssell][0][position]</stringProp>
-            </elementProp>
-          </collectionProp>
-        </elementProp>
-        <stringProp name="HTTPSampler.domain"/>
-        <stringProp name="HTTPSampler.port"/>
-        <stringProp name="HTTPSampler.connect_timeout"/>
-        <stringProp name="HTTPSampler.response_timeout"/>
-        <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
-        <stringProp name="HTTPSampler.contentEncoding"/>
-        <stringProp name="HTTPSampler.path">${base_path}${admin_path}/catalog/product/save/set/4/type/bundle/back/edit/active_tab/product-details/</stringProp>
-        <stringProp name="HTTPSampler.method">POST</stringProp>
-        <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
-        <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
-        <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
-        <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
-        <boolProp name="HTTPSampler.monitor">false</boolProp>
-        <stringProp name="HTTPSampler.embedded_url_re"/>
-      </HTTPSamplerProxy>
-      <hashTree>
-        <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Response Assertion" enabled="true">
-          <collectionProp name="Asserion.test_strings">
-            <stringProp name="-583471546">You saved the product</stringProp>
-          </collectionProp>
-          <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
-          <boolProp name="Assertion.assume_success">false</boolProp>
-          <intProp name="Assertion.test_type">2</intProp>
-        </ResponseAssertion>
-        <hashTree/>
-        <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Response Assertion" enabled="true">
-          <collectionProp name="Asserion.test_strings">
-            <stringProp name="-1600986843">violation</stringProp>
-          </collectionProp>
-          <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
-          <boolProp name="Assertion.assume_success">false</boolProp>
-          <intProp name="Assertion.test_type">6</intProp>
-        </ResponseAssertion>
-        <hashTree/>
-      </hashTree>
-    </hashTree>
-  
-    <TestFragmentController guiclass="TestFragmentControllerGui" testclass="TestFragmentController" testname="Admin Create Configurable Product" enabled="true">
-  <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_create_product/create_configurable_product.jmx</stringProp>
-</TestFragmentController>
-    <hashTree>
-      <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Catalog Product" enabled="true">
-        <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
-          <collectionProp name="Arguments.arguments"/>
-        </elementProp>
-        <stringProp name="HTTPSampler.domain"/>
-        <stringProp name="HTTPSampler.port"/>
-        <stringProp name="HTTPSampler.connect_timeout"/>
-        <stringProp name="HTTPSampler.response_timeout"/>
-        <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
-        <stringProp name="HTTPSampler.contentEncoding"/>
-        <stringProp name="HTTPSampler.path">${base_path}${admin_path}/catalog/product/</stringProp>
-        <stringProp name="HTTPSampler.method">GET</stringProp>
-        <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
-        <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
-        <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
-        <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
-        <boolProp name="HTTPSampler.monitor">false</boolProp>
-        <stringProp name="HTTPSampler.embedded_url_re"/>
-      </HTTPSamplerProxy>
-      <hashTree>
-        <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Response Assertion" enabled="true">
-          <collectionProp name="Asserion.test_strings">
-            <stringProp name="1509986340">records found</stringProp>
-          </collectionProp>
-          <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
-          <boolProp name="Assertion.assume_success">false</boolProp>
-          <intProp name="Assertion.test_type">2</intProp>
-        </ResponseAssertion>
-        <hashTree/>
-      </hashTree>
-      <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="New Configurable Product" enabled="true">
-        <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
-          <collectionProp name="Arguments.arguments"/>
-        </elementProp>
-        <stringProp name="HTTPSampler.domain"/>
-        <stringProp name="HTTPSampler.port"/>
-        <stringProp name="HTTPSampler.connect_timeout"/>
-        <stringProp name="HTTPSampler.response_timeout"/>
-        <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
-        <stringProp name="HTTPSampler.contentEncoding"/>
-        <stringProp name="HTTPSampler.path">${base_path}${admin_path}/catalog/product/new/set/4/type/configurable/</stringProp>
-        <stringProp name="HTTPSampler.method">GET</stringProp>
-        <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
-        <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
-        <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
-        <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
-        <boolProp name="HTTPSampler.monitor">false</boolProp>
-        <stringProp name="HTTPSampler.embedded_url_re"/>
-      </HTTPSamplerProxy>
-      <hashTree>
-        <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Response Assertion" enabled="true">
-          <collectionProp name="Asserion.test_strings">
-            <stringProp name="-144461265">New Product</stringProp>
-          </collectionProp>
-          <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
-          <boolProp name="Assertion.assume_success">false</boolProp>
-          <intProp name="Assertion.test_type">2</intProp>
-        </ResponseAssertion>
-        <hashTree/>
-      </hashTree>
-      <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Create Options" enabled="true">
-        <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
-          <collectionProp name="Arguments.arguments">
-            <elementProp name="form_key" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.name">form_key</stringProp>
-              <stringProp name="Argument.value">${admin_form_key}</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            </elementProp>
-            <elementProp name="options[0][attribute_id]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.name">options[0][attribute_id]</stringProp>
-              <stringProp name="Argument.value">${color_id}</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            </elementProp>
-            <elementProp name="options[0][id]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.name">options[0][id]</stringProp>
-              <stringProp name="Argument.value">PQFYFAT</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            </elementProp>
-            <elementProp name="options[0][is_new]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.name">options[0][is_new]</stringProp>
-              <stringProp name="Argument.value">true</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            </elementProp>
-            <elementProp name="options[0][label]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.name">options[0][label]</stringProp>
-              <stringProp name="Argument.value">green-${__time(YMDHMS)}-${__threadNum}-${__Random(1,1000000)}</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            </elementProp>
-            <elementProp name="options[0][value]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.name">options[0][value]</stringProp>
-              <stringProp name="Argument.value">0</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            </elementProp>
-            <elementProp name="options[1][attribute_id]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">${color_id}</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">options[1][attribute_id]</stringProp>
-              <stringProp name="Argument.desc">true</stringProp>
-            </elementProp>
-            <elementProp name="options[1][id]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">PQFYFAT1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">options[1][id]</stringProp>
-              <stringProp name="Argument.desc">true</stringProp>
-            </elementProp>
-            <elementProp name="options[1][is_new]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">true</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">options[1][is_new]</stringProp>
-              <stringProp name="Argument.desc">true</stringProp>
-            </elementProp>
-            <elementProp name="options[1][label]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">red-${__time(YMDHMS)}-${__threadNum}-${__Random(1,1000000)}</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">options[1][label]</stringProp>
-              <stringProp name="Argument.desc">true</stringProp>
-            </elementProp>
-            <elementProp name="options[1][value]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">0</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">options[1][value]</stringProp>
-              <stringProp name="Argument.desc">true</stringProp>
-            </elementProp>
-          </collectionProp>
-        </elementProp>
-        <stringProp name="HTTPSampler.domain"/>
-        <stringProp name="HTTPSampler.port"/>
-        <stringProp name="HTTPSampler.connect_timeout"/>
-        <stringProp name="HTTPSampler.response_timeout"/>
-        <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
-        <stringProp name="HTTPSampler.contentEncoding"/>
-        <stringProp name="HTTPSampler.path">${base_path}${admin_path}/catalog/product_attribute/createOptions/?isAjax=true</stringProp>
-        <stringProp name="HTTPSampler.method">POST</stringProp>
-        <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
-        <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
-        <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
-        <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
-        <boolProp name="HTTPSampler.monitor">false</boolProp>
-        <stringProp name="HTTPSampler.embedded_url_re"/>
-      </HTTPSamplerProxy>
-      <hashTree>
-        <com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor guiclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.gui.JSONPathExtractorGui" testclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor" testname="Extract first option" enabled="true">
-          <stringProp name="VAR">first_option</stringProp>
-          <stringProp name="JSONPATH">$.PQFYFAT</stringProp>
-          <stringProp name="DEFAULT"/>
-          <stringProp name="VARIABLE"/>
-          <stringProp name="SUBJECT">BODY</stringProp>
-        </com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor>
-        <hashTree/>
-        <com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor guiclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.gui.JSONPathExtractorGui" testclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor" testname="Extract second option" enabled="true">
-          <stringProp name="VAR">second_option</stringProp>
-          <stringProp name="JSONPATH">$.PQFYFAT1</stringProp>
-          <stringProp name="DEFAULT"/>
-          <stringProp name="VARIABLE"/>
-          <stringProp name="SUBJECT">BODY</stringProp>
-        </com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor>
-        <hashTree/>
-      </hashTree>
-      <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="New Configurable Product Validate" enabled="true">
-        <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
-          <collectionProp name="Arguments.arguments">
-            <elementProp name="ajax" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">true</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">ajax</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="isAjax" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">true</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">isAjax</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="affect_configurable_product_attributes" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">affect_configurable_product_attributes</stringProp>
-              <stringProp name="Argument.desc">true</stringProp>
-            </elementProp>
-            <elementProp name="attribute_codes[0]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">color</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">attribute_codes[0]</stringProp>
-              <stringProp name="Argument.desc">true</stringProp>
-            </elementProp>
-            <elementProp name="attributes[0]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">${color_id}</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">attributes[0]</stringProp>
-              <stringProp name="Argument.desc">true</stringProp>
-            </elementProp>
-            <elementProp name="configurable-matrix[0][attributes]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">Color:green ${__time(YMDHMS)}-${__threadNum}-${__Random(1,1000000)}</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">configurable-matrix[0][attributes]</stringProp>
-              <stringProp name="Argument.desc">true</stringProp>
-            </elementProp>
-            <elementProp name="configurable-matrix[0][canEdit]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">configurable-matrix[0][canEdit]</stringProp>
-              <stringProp name="Argument.desc">true</stringProp>
-            </elementProp>
-            <elementProp name="configurable-matrix[0][configurable_attribute]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">false</boolProp>
-              <stringProp name="Argument.value">{"color":"${first_option}"}</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">configurable-matrix[0][configurable_attribute]</stringProp>
-              <stringProp name="Argument.desc">true</stringProp>
-            </elementProp>
-            <elementProp name="configurable-matrix[0][name]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">green ${__time(YMDHMS)}-${__threadNum}-${__Random(1,1000000)}</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">configurable-matrix[0][name]</stringProp>
-              <stringProp name="Argument.desc">true</stringProp>
-            </elementProp>
-            <elementProp name="configurable-matrix[0][newProduct]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">configurable-matrix[0][newProduct]</stringProp>
-              <stringProp name="Argument.desc">true</stringProp>
-            </elementProp>
-            <elementProp name="configurable-matrix[0][price]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">100</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">configurable-matrix[0][price]</stringProp>
-              <stringProp name="Argument.desc">true</stringProp>
-            </elementProp>
-            <elementProp name="configurable-matrix[0][price_currency]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">$</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">configurable-matrix[0][price_currency]</stringProp>
-              <stringProp name="Argument.desc">true</stringProp>
-            </elementProp>
-            <elementProp name="configurable-matrix[0][price_string]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">$100</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">configurable-matrix[0][price_string]</stringProp>
-              <stringProp name="Argument.desc">true</stringProp>
-            </elementProp>
-            <elementProp name="configurable-matrix[0][qty]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">150</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">configurable-matrix[0][qty]</stringProp>
-              <stringProp name="Argument.desc">true</stringProp>
-            </elementProp>
-            <elementProp name="configurable-matrix[0][record_id]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">0</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">configurable-matrix[0][record_id]</stringProp>
-              <stringProp name="Argument.desc">true</stringProp>
-            </elementProp>
-            <elementProp name="configurable-matrix[0][sku]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">green-${__time(YMDHMS)}-${__threadNum}-${__Random(1,1000000)}</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">configurable-matrix[0][sku]</stringProp>
-              <stringProp name="Argument.desc">true</stringProp>
-            </elementProp>
-            <elementProp name="configurable-matrix[0][small_image]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">configurable-matrix[0][small_image]</stringProp>
-              <stringProp name="Argument.desc">true</stringProp>
-            </elementProp>
-            <elementProp name="configurable-matrix[0][status]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">configurable-matrix[0][status]</stringProp>
-              <stringProp name="Argument.desc">true</stringProp>
-            </elementProp>
-            <elementProp name="configurable-matrix[0][swatch_image]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">configurable-matrix[0][swatch_image]</stringProp>
-              <stringProp name="Argument.desc">true</stringProp>
-            </elementProp>
-            <elementProp name="configurable-matrix[0][thumbnail]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">configurable-matrix[0][thumbnail]</stringProp>
-              <stringProp name="Argument.desc">true</stringProp>
-            </elementProp>
-            <elementProp name="configurable-matrix[0][variationKey]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">${first_option}</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">configurable-matrix[0][variationKey]</stringProp>
-              <stringProp name="Argument.desc">true</stringProp>
-            </elementProp>
-            <elementProp name="configurable-matrix[0][weight]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">6</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">configurable-matrix[0][weight]</stringProp>
-              <stringProp name="Argument.desc">true</stringProp>
-            </elementProp>
-            <elementProp name="configurable-matrix[1][attributes]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">Color:red ${__time(YMDHMS)}-${__threadNum}-${__Random(1,1000000)}</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">configurable-matrix[1][attributes]</stringProp>
-              <stringProp name="Argument.desc">true</stringProp>
-            </elementProp>
-            <elementProp name="configurable-matrix[1][canEdit]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">configurable-matrix[1][canEdit]</stringProp>
-              <stringProp name="Argument.desc">true</stringProp>
-            </elementProp>
-            <elementProp name="configurable-matrix[1][configurable_attribute]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">false</boolProp>
-              <stringProp name="Argument.value">{"color":"${second_option}"}</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">configurable-matrix[1][configurable_attribute]</stringProp>
-              <stringProp name="Argument.desc">true</stringProp>
-            </elementProp>
-            <elementProp name="configurable-matrix[1][name]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">red ${__time(YMDHMS)}-${__threadNum}-${__Random(1,1000000)}</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">configurable-matrix[1][name]</stringProp>
-              <stringProp name="Argument.desc">true</stringProp>
-            </elementProp>
-            <elementProp name="configurable-matrix[1][newProduct]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">configurable-matrix[1][newProduct]</stringProp>
-              <stringProp name="Argument.desc">true</stringProp>
-            </elementProp>
-            <elementProp name="configurable-matrix[1][price]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">100</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">configurable-matrix[1][price]</stringProp>
-              <stringProp name="Argument.desc">true</stringProp>
-            </elementProp>
-            <elementProp name="configurable-matrix[1][price_currency]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">$</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">configurable-matrix[1][price_currency]</stringProp>
-              <stringProp name="Argument.desc">true</stringProp>
-            </elementProp>
-            <elementProp name="configurable-matrix[1][price_string]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">$100</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">configurable-matrix[1][price_string]</stringProp>
-              <stringProp name="Argument.desc">true</stringProp>
-            </elementProp>
-            <elementProp name="configurable-matrix[1][qty]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">50</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">configurable-matrix[1][qty]</stringProp>
-              <stringProp name="Argument.desc">true</stringProp>
-            </elementProp>
-            <elementProp name="configurable-matrix[1][record_id]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">configurable-matrix[1][record_id]</stringProp>
-              <stringProp name="Argument.desc">true</stringProp>
-            </elementProp>
-            <elementProp name="configurable-matrix[1][sku]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">red ${__time(YMDHMS)}-${__threadNum}-${__Random(1,1000000)}</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">configurable-matrix[1][sku]</stringProp>
-              <stringProp name="Argument.desc">true</stringProp>
-            </elementProp>
-            <elementProp name="configurable-matrix[1][small_image]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">configurable-matrix[1][small_image]</stringProp>
-              <stringProp name="Argument.desc">true</stringProp>
-            </elementProp>
-            <elementProp name="configurable-matrix[1][status]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">configurable-matrix[1][status]</stringProp>
-              <stringProp name="Argument.desc">true</stringProp>
-            </elementProp>
-            <elementProp name="configurable-matrix[1][swatch_image]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">configurable-matrix[1][swatch_image]</stringProp>
-              <stringProp name="Argument.desc">true</stringProp>
-            </elementProp>
-            <elementProp name="configurable-matrix[1][thumbnail]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">configurable-matrix[1][thumbnail]</stringProp>
-              <stringProp name="Argument.desc">true</stringProp>
-            </elementProp>
-            <elementProp name="configurable-matrix[1][variationKey]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">${second_option}</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">configurable-matrix[1][variationKey]</stringProp>
-              <stringProp name="Argument.desc">true</stringProp>
-            </elementProp>
-            <elementProp name="configurable-matrix[1][weight]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">6</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">configurable-matrix[1][weight]</stringProp>
-              <stringProp name="Argument.desc">true</stringProp>
-            </elementProp>
-            <elementProp name="form_key" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">${admin_form_key}</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">form_key</stringProp>
-              <stringProp name="Argument.desc">true</stringProp>
-            </elementProp>
-            <elementProp name="new-variations-attribute-set-id" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">4</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">new-variations-attribute-set-id</stringProp>
-              <stringProp name="Argument.desc">true</stringProp>
-            </elementProp>
-            <elementProp name="product[affect_product_custom_options]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[affect_product_custom_options]</stringProp>
-              <stringProp name="Argument.desc">true</stringProp>
-            </elementProp>
-            <elementProp name="product[attribute_set_id]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">4</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[attribute_set_id]</stringProp>
-              <stringProp name="Argument.desc">true</stringProp>
-            </elementProp>
-            <elementProp name="product[category_ids][0]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">4</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[category_ids][0]</stringProp>
-              <stringProp name="Argument.desc">true</stringProp>
-            </elementProp>
-            <elementProp name="product[configurable_attributes_data][${color_id}][attribute_id]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">${color_id}</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[configurable_attributes_data][${color_id}][attribute_id]</stringProp>
-              <stringProp name="Argument.desc">true</stringProp>
-            </elementProp>
-            <elementProp name="product[configurable_attributes_data][${color_id}][code]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">color</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[configurable_attributes_data][${color_id}][code]</stringProp>
-              <stringProp name="Argument.desc">true</stringProp>
-            </elementProp>
-            <elementProp name="product[configurable_attributes_data][${color_id}][label]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">Color</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[configurable_attributes_data][${color_id}][label]</stringProp>
-              <stringProp name="Argument.desc">true</stringProp>
-            </elementProp>
-            <elementProp name="product[configurable_attributes_data][${color_id}][position]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">0</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[configurable_attributes_data][${color_id}][position]</stringProp>
-              <stringProp name="Argument.desc">true</stringProp>
-            </elementProp>
-            <elementProp name="product[configurable_attributes_data][${color_id}][values][${first_option}][include]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[configurable_attributes_data][${color_id}][values][${first_option}][include]</stringProp>
-              <stringProp name="Argument.desc">true</stringProp>
-            </elementProp>
-            <elementProp name="product[configurable_attributes_data][${color_id}][values][${first_option}][value_index]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">${first_option}</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[configurable_attributes_data][${color_id}][values][${first_option}][value_index]</stringProp>
-              <stringProp name="Argument.desc">true</stringProp>
-            </elementProp>
-            <elementProp name="product[configurable_attributes_data][${color_id}][values][${second_option}][include]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[configurable_attributes_data][${color_id}][values][${second_option}][include]</stringProp>
-              <stringProp name="Argument.desc">true</stringProp>
-            </elementProp>
-            <elementProp name="product[configurable_attributes_data][${color_id}][values][${second_option}][value_index]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">${second_option}</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[configurable_attributes_data][${color_id}][values][${second_option}][value_index]</stringProp>
-              <stringProp name="Argument.desc">true</stringProp>
-            </elementProp>
-            <elementProp name="product[custom_layout_update]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[custom_layout_update]</stringProp>
-              <stringProp name="Argument.desc">true</stringProp>
-            </elementProp>
-            <elementProp name="product[description]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[description]</stringProp>
-              <stringProp name="Argument.desc">true</stringProp>
-            </elementProp>
-            <elementProp name="product[gift_message_available]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">0</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[gift_message_available]</stringProp>
-              <stringProp name="Argument.desc">true</stringProp>
-            </elementProp>
-            <elementProp name="product[gift_wrapping_available]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[gift_wrapping_available]</stringProp>
-              <stringProp name="Argument.desc">true</stringProp>
-            </elementProp>
-            <elementProp name="product[gift_wrapping_price]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[gift_wrapping_price]</stringProp>
-              <stringProp name="Argument.desc">true</stringProp>
-            </elementProp>
-            <elementProp name="product[image]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[image]</stringProp>
-              <stringProp name="Argument.desc">true</stringProp>
-            </elementProp>
-            <elementProp name="product[is_returnable]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">2</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[is_returnable]</stringProp>
-              <stringProp name="Argument.desc">true</stringProp>
-            </elementProp>
-            <elementProp name="product[meta_description]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">Configurable Product ${__time(YMDHMS)}-${__threadNum}-${__Random(1,1000000)} Meta Description</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[meta_description]</stringProp>
-              <stringProp name="Argument.desc">true</stringProp>
-            </elementProp>
-            <elementProp name="product[meta_keyword]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">Configurable Product ${__time(YMDHMS)}-${__threadNum}-${__Random(1,1000000)} Meta Keyword</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[meta_keyword]</stringProp>
-              <stringProp name="Argument.desc">true</stringProp>
-            </elementProp>
-            <elementProp name="product[meta_title]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">Configurable Product ${__time(YMDHMS)}-${__threadNum}-${__Random(1,1000000)} Meta Title</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[meta_title]</stringProp>
-              <stringProp name="Argument.desc">true</stringProp>
-            </elementProp>
-            <elementProp name="product[name]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">Configurable Product ${__time(YMDHMS)}-${__threadNum}-${__Random(1,1000000)}</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[name]</stringProp>
-              <stringProp name="Argument.desc">true</stringProp>
-            </elementProp>
-            <elementProp name="product[options_container]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">container2</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[options_container]</stringProp>
-              <stringProp name="Argument.desc">true</stringProp>
-            </elementProp>
-            <elementProp name="product[price]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">${price_new}</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[price]</stringProp>
-              <stringProp name="Argument.desc">true</stringProp>
-            </elementProp>
-            <elementProp name="product[product_has_weight]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[product_has_weight]</stringProp>
-              <stringProp name="Argument.desc">true</stringProp>
-            </elementProp>
-            <elementProp name="product[quantity_and_stock_status][is_in_stock]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[quantity_and_stock_status][is_in_stock]</stringProp>
-              <stringProp name="Argument.desc">true</stringProp>
-            </elementProp>
-            <elementProp name="product[quantity_and_stock_status][qty]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1000</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[quantity_and_stock_status][qty]</stringProp>
-              <stringProp name="Argument.desc">true</stringProp>
-            </elementProp>
-            <elementProp name="product[short_description]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[short_description]</stringProp>
-              <stringProp name="Argument.desc">true</stringProp>
-            </elementProp>
-            <elementProp name="product[sku]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">SKU ${__time(YMDHMS)}-${__threadNum}-${__Random(1,1000000)}</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[sku]</stringProp>
-              <stringProp name="Argument.desc">true</stringProp>
-            </elementProp>
-            <elementProp name="product[small_image]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[small_image]</stringProp>
-              <stringProp name="Argument.desc">true</stringProp>
-            </elementProp>
-            <elementProp name="product[special_price]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">${special_price_new}</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[special_price]</stringProp>
-              <stringProp name="Argument.desc">true</stringProp>
-            </elementProp>
-            <elementProp name="product[status]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[status]</stringProp>
-              <stringProp name="Argument.desc">true</stringProp>
-            </elementProp>
-            <elementProp name="product[stock_data][backorders]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">0</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[stock_data][backorders]</stringProp>
-              <stringProp name="Argument.desc">true</stringProp>
-            </elementProp>
-            <elementProp name="product[stock_data][deferred_stock_update]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[stock_data][deferred_stock_update]</stringProp>
-              <stringProp name="Argument.desc">true</stringProp>
-            </elementProp>
-            <elementProp name="product[stock_data][enable_qty_increments]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">0</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[stock_data][enable_qty_increments]</stringProp>
-              <stringProp name="Argument.desc">true</stringProp>
-            </elementProp>
-            <elementProp name="product[stock_data][is_decimal_divided]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">0</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[stock_data][is_decimal_divided]</stringProp>
-              <stringProp name="Argument.desc">true</stringProp>
-            </elementProp>
-            <elementProp name="product[stock_data][is_qty_decimal]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">0</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[stock_data][is_qty_decimal]</stringProp>
-              <stringProp name="Argument.desc">true</stringProp>
-            </elementProp>
-            <elementProp name="product[stock_data][manage_stock]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[stock_data][manage_stock]</stringProp>
-              <stringProp name="Argument.desc">true</stringProp>
-            </elementProp>
-            <elementProp name="product[stock_data][max_sale_qty]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">10000</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[stock_data][max_sale_qty]</stringProp>
-              <stringProp name="Argument.desc">true</stringProp>
-            </elementProp>
-            <elementProp name="product[stock_data][min_qty]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">0</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[stock_data][min_qty]</stringProp>
-              <stringProp name="Argument.desc">true</stringProp>
-            </elementProp>
-            <elementProp name="product[stock_data][min_sale_qty]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[stock_data][min_sale_qty]</stringProp>
-              <stringProp name="Argument.desc">true</stringProp>
-            </elementProp>
-            <elementProp name="product[stock_data][notify_stock_qty]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[stock_data][notify_stock_qty]</stringProp>
-              <stringProp name="Argument.desc">true</stringProp>
-            </elementProp>
-            <elementProp name="product[stock_data][qty_increments]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[stock_data][qty_increments]</stringProp>
-              <stringProp name="Argument.desc">true</stringProp>
-            </elementProp>
-            <elementProp name="product[stock_data][use_config_backorders]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[stock_data][use_config_backorders]</stringProp>
-              <stringProp name="Argument.desc">true</stringProp>
-            </elementProp>
-            <elementProp name="product[stock_data][use_config_deferred_stock_update]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[stock_data][use_config_deferred_stock_update]</stringProp>
-              <stringProp name="Argument.desc">true</stringProp>
-            </elementProp>
-            <elementProp name="product[stock_data][use_config_enable_qty_increments]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[stock_data][use_config_enable_qty_increments]</stringProp>
-              <stringProp name="Argument.desc">true</stringProp>
-            </elementProp>
-            <elementProp name="product[stock_data][use_config_manage_stock]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[stock_data][use_config_manage_stock]</stringProp>
-              <stringProp name="Argument.desc">true</stringProp>
-            </elementProp>
-            <elementProp name="product[stock_data][use_config_max_sale_qty]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[stock_data][use_config_max_sale_qty]</stringProp>
-              <stringProp name="Argument.desc">true</stringProp>
-            </elementProp>
-            <elementProp name="product[stock_data][use_config_min_qty]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[stock_data][use_config_min_qty]</stringProp>
-              <stringProp name="Argument.desc">true</stringProp>
-            </elementProp>
-            <elementProp name="product[stock_data][use_config_min_sale_qty]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[stock_data][use_config_min_sale_qty]</stringProp>
-              <stringProp name="Argument.desc">true</stringProp>
-            </elementProp>
-            <elementProp name="product[stock_data][use_config_notify_stock_qty]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[stock_data][use_config_notify_stock_qty]</stringProp>
-              <stringProp name="Argument.desc">true</stringProp>
-            </elementProp>
-            <elementProp name="product[stock_data][use_config_qty_increments]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[stock_data][use_config_qty_increments]</stringProp>
-              <stringProp name="Argument.desc">true</stringProp>
-            </elementProp>
-            <elementProp name="product[tax_class_id]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">2</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[tax_class_id]</stringProp>
-              <stringProp name="Argument.desc">true</stringProp>
-            </elementProp>
-            <elementProp name="product[thumbnail]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[thumbnail]</stringProp>
-              <stringProp name="Argument.desc">true</stringProp>
-            </elementProp>
-            <elementProp name="product[url_key]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[url_key]</stringProp>
-              <stringProp name="Argument.desc">true</stringProp>
-            </elementProp>
-            <elementProp name="product[use_config_gift_message_available]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[use_config_gift_message_available]</stringProp>
-              <stringProp name="Argument.desc">true</stringProp>
-            </elementProp>
-            <elementProp name="product[use_config_gift_wrapping_available]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[use_config_gift_wrapping_available]</stringProp>
-              <stringProp name="Argument.desc">true</stringProp>
-            </elementProp>
-            <elementProp name="product[use_config_is_returnable]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[use_config_is_returnable]</stringProp>
-              <stringProp name="Argument.desc">true</stringProp>
-            </elementProp>
-            <elementProp name="product[visibility]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">4</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[visibility]</stringProp>
-              <stringProp name="Argument.desc">true</stringProp>
-            </elementProp>
-            <elementProp name="product[website_ids][1]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[website_ids][1]</stringProp>
-              <stringProp name="Argument.desc">true</stringProp>
-            </elementProp>
-            <elementProp name="links[related][0][id]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">${related_product_id}</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">links[related][0][id]</stringProp>
-            </elementProp>
-            <elementProp name="links[related][0][position]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">links[related][0][position]</stringProp>
-            </elementProp>
-            <elementProp name="links[upsell][0][id]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">${related_product_id}</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">links[upsell][0][id]</stringProp>
-            </elementProp>
-            <elementProp name="links[upsell][0][position]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">links[upsell][0][position]</stringProp>
-            </elementProp>
-            <elementProp name="links[crosssell][0][id]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">${related_product_id}</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">links[crosssell][0][id]</stringProp>
-            </elementProp>
-            <elementProp name="links[crosssell][0][position]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">links[crosssell][0][position]</stringProp>
-            </elementProp>
-          </collectionProp>
-        </elementProp>
-        <stringProp name="HTTPSampler.domain"/>
-        <stringProp name="HTTPSampler.port"/>
-        <stringProp name="HTTPSampler.connect_timeout"/>
-        <stringProp name="HTTPSampler.response_timeout"/>
-        <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
-        <stringProp name="HTTPSampler.contentEncoding"/>
-        <stringProp name="HTTPSampler.path">${base_path}${admin_path}/catalog/product/validate/set/4/</stringProp>
-        <stringProp name="HTTPSampler.method">POST</stringProp>
-        <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
-        <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
-        <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
-        <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
-        <boolProp name="HTTPSampler.monitor">false</boolProp>
-        <stringProp name="HTTPSampler.embedded_url_re"/>
-      </HTTPSamplerProxy>
-      <hashTree>
-        <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Response Assertion" enabled="true">
-          <collectionProp name="Asserion.test_strings">
-            <stringProp name="1853918323">{"error":false}</stringProp>
-          </collectionProp>
-          <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
-          <boolProp name="Assertion.assume_success">false</boolProp>
-          <intProp name="Assertion.test_type">2</intProp>
-        </ResponseAssertion>
-        <hashTree/>
-      </hashTree>
-      <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="New Configurable Product Save" enabled="true">
-        <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
-          <collectionProp name="Arguments.arguments">
-            <elementProp name="ajax" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">true</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">ajax</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="isAjax" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">true</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">isAjax</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="affect_configurable_product_attributes" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">affect_configurable_product_attributes</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="attribute_codes[0]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">color</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">attribute_codes[0]</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="attributes[0]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">${color_id}</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">attributes[0]</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="configurable-matrix[0][attributes]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">Color:green ${__time(YMDHMS)}-${__threadNum}-${__Random(1,1000000)}</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">configurable-matrix[0][attributes]</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="configurable-matrix[0][canEdit]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">configurable-matrix[0][canEdit]</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="configurable-matrix[0][configurable_attribute]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">false</boolProp>
-              <stringProp name="Argument.value">{"color":"${first_option}"}</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">configurable-matrix[0][configurable_attribute]</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="configurable-matrix[0][name]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">green ${__time(YMDHMS)}-${__threadNum}-${__Random(1,1000000)}</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">configurable-matrix[0][name]</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="configurable-matrix[0][newProduct]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">configurable-matrix[0][newProduct]</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="configurable-matrix[0][price]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">100</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">configurable-matrix[0][price]</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="configurable-matrix[0][price_currency]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">$</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">configurable-matrix[0][price_currency]</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="configurable-matrix[0][price_string]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">$100</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">configurable-matrix[0][price_string]</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="configurable-matrix[0][qty]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">150</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">configurable-matrix[0][qty]</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="configurable-matrix[0][record_id]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">0</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">configurable-matrix[0][record_id]</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="configurable-matrix[0][sku]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">green-${__time(YMDHMS)}-${__threadNum}-${__Random(1,1000000)}</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">configurable-matrix[0][sku]</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="configurable-matrix[0][small_image]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">configurable-matrix[0][small_image]</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="configurable-matrix[0][status]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">configurable-matrix[0][status]</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="configurable-matrix[0][swatch_image]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">configurable-matrix[0][swatch_image]</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="configurable-matrix[0][thumbnail]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">configurable-matrix[0][thumbnail]</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="configurable-matrix[0][variationKey]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">${first_option}</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">configurable-matrix[0][variationKey]</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="configurable-matrix[0][weight]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">6</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">configurable-matrix[0][weight]</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="configurable-matrix[1][attributes]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">Color:red ${__time(YMDHMS)}-${__threadNum}-${__Random(1,1000000)}</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">configurable-matrix[1][attributes]</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="configurable-matrix[1][canEdit]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">configurable-matrix[1][canEdit]</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="configurable-matrix[1][configurable_attribute]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">false</boolProp>
-              <stringProp name="Argument.value">{"color":"${second_option}"}</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">configurable-matrix[1][configurable_attribute]</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="configurable-matrix[1][name]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">red ${__time(YMDHMS)}-${__threadNum}-${__Random(1,1000000)}</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">configurable-matrix[1][name]</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="configurable-matrix[1][newProduct]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">configurable-matrix[1][newProduct]</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="configurable-matrix[1][price]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">100</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">configurable-matrix[1][price]</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="configurable-matrix[1][price_currency]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">$</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">configurable-matrix[1][price_currency]</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="configurable-matrix[1][price_string]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">$100</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">configurable-matrix[1][price_string]</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="configurable-matrix[1][qty]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">50</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">configurable-matrix[1][qty]</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="configurable-matrix[1][record_id]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">configurable-matrix[1][record_id]</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="configurable-matrix[1][sku]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">red ${__time(YMDHMS)}-${__threadNum}-${__Random(1,1000000)}</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">configurable-matrix[1][sku]</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="configurable-matrix[1][small_image]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">configurable-matrix[1][small_image]</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="configurable-matrix[1][status]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">configurable-matrix[1][status]</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="configurable-matrix[1][swatch_image]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">configurable-matrix[1][swatch_image]</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="configurable-matrix[1][thumbnail]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">configurable-matrix[1][thumbnail]</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="configurable-matrix[1][variationKey]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">${second_option}</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">configurable-matrix[1][variationKey]</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="configurable-matrix[1][weight]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">6</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">configurable-matrix[1][weight]</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="form_key" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">${admin_form_key}</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">form_key</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="new-variations-attribute-set-id" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">4</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">new-variations-attribute-set-id</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="product[affect_product_custom_options]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[affect_product_custom_options]</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="product[attribute_set_id]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">4</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[attribute_set_id]</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="product[category_ids][0]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">4</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[category_ids][0]</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="product[configurable_attributes_data][${color_id}][attribute_id]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">${color_id}</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[configurable_attributes_data][${color_id}][attribute_id]</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="product[configurable_attributes_data][${color_id}][code]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">color</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[configurable_attributes_data][${color_id}][code]</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="product[configurable_attributes_data][${color_id}][label]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">Color</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[configurable_attributes_data][${color_id}][label]</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="product[configurable_attributes_data][${color_id}][position]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">0</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[configurable_attributes_data][${color_id}][position]</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="product[configurable_attributes_data][${color_id}][values][${first_option}][include]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[configurable_attributes_data][${color_id}][values][${first_option}][include]</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="product[configurable_attributes_data][${color_id}][values][${first_option}][value_index]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">${first_option}</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[configurable_attributes_data][${color_id}][values][${first_option}][value_index]</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="product[configurable_attributes_data][${color_id}][values][${second_option}][include]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[configurable_attributes_data][${color_id}][values][${second_option}][include]</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="product[configurable_attributes_data][${color_id}][values][${second_option}][value_index]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">${second_option}</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[configurable_attributes_data][${color_id}][values][${second_option}][value_index]</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="product[custom_layout_update]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[custom_layout_update]</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="product[description]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[description]</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="product[gift_message_available]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">0</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[gift_message_available]</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="product[gift_wrapping_available]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[gift_wrapping_available]</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="product[gift_wrapping_price]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[gift_wrapping_price]</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="product[image]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[image]</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="product[is_returnable]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">2</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[is_returnable]</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="product[meta_description]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">Configurable Product ${__time(YMDHMS)}-${__threadNum}-${__Random(1,1000000)} Meta Description</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[meta_description]</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="product[meta_keyword]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">Configurable Product ${__time(YMDHMS)}-${__threadNum}-${__Random(1,1000000)} Meta Keyword</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[meta_keyword]</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="product[meta_title]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">Configurable Product ${__time(YMDHMS)}-${__threadNum}-${__Random(1,1000000)} Meta Title</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[meta_title]</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="product[name]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">Configurable Product ${__time(YMDHMS)}-${__threadNum}-${__Random(1,1000000)}</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[name]</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="product[options_container]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">container2</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[options_container]</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="product[price]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">${price_new}</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[price]</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="product[product_has_weight]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[product_has_weight]</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="product[quantity_and_stock_status][is_in_stock]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[quantity_and_stock_status][is_in_stock]</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="product[quantity_and_stock_status][qty]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1000</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[quantity_and_stock_status][qty]</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="product[short_description]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[short_description]</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="product[sku]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">SKU ${__time(YMDHMS)}-${__threadNum}-${__Random(1,1000000)}</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[sku]</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="product[small_image]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[small_image]</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="product[special_price]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">${special_price_new}</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[special_price]</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="product[status]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[status]</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="product[stock_data][backorders]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">0</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[stock_data][backorders]</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="product[stock_data][deferred_stock_update]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[stock_data][deferred_stock_update]</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="product[stock_data][enable_qty_increments]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">0</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[stock_data][enable_qty_increments]</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="product[stock_data][is_decimal_divided]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">0</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[stock_data][is_decimal_divided]</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="product[stock_data][is_qty_decimal]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">0</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[stock_data][is_qty_decimal]</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="product[stock_data][manage_stock]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[stock_data][manage_stock]</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="product[stock_data][max_sale_qty]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">10000</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[stock_data][max_sale_qty]</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="product[stock_data][min_qty]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">0</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[stock_data][min_qty]</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="product[stock_data][min_sale_qty]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[stock_data][min_sale_qty]</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="product[stock_data][notify_stock_qty]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[stock_data][notify_stock_qty]</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="product[stock_data][qty_increments]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[stock_data][qty_increments]</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="product[stock_data][use_config_backorders]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[stock_data][use_config_backorders]</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="product[stock_data][use_config_deferred_stock_update]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[stock_data][use_config_deferred_stock_update]</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="product[stock_data][use_config_enable_qty_increments]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[stock_data][use_config_enable_qty_increments]</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="product[stock_data][use_config_manage_stock]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[stock_data][use_config_manage_stock]</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="product[stock_data][use_config_max_sale_qty]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[stock_data][use_config_max_sale_qty]</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="product[stock_data][use_config_min_qty]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[stock_data][use_config_min_qty]</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="product[stock_data][use_config_min_sale_qty]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[stock_data][use_config_min_sale_qty]</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="product[stock_data][use_config_notify_stock_qty]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[stock_data][use_config_notify_stock_qty]</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="product[stock_data][use_config_qty_increments]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[stock_data][use_config_qty_increments]</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="product[tax_class_id]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">2</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[tax_class_id]</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="product[thumbnail]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[thumbnail]</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="product[url_key]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[url_key]</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="product[use_config_gift_message_available]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[use_config_gift_message_available]</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="product[use_config_gift_wrapping_available]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[use_config_gift_wrapping_available]</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="product[use_config_is_returnable]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[use_config_is_returnable]</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="product[visibility]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">4</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[visibility]</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="product[website_ids][1]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[website_ids][1]</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="links[related][0][id]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">${related_product_id}</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">links[related][0][id]</stringProp>
-            </elementProp>
-            <elementProp name="links[related][0][position]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">links[related][0][position]</stringProp>
-            </elementProp>
-            <elementProp name="links[upsell][0][id]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">${related_product_id}</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">links[upsell][0][id]</stringProp>
-            </elementProp>
-            <elementProp name="links[upsell][0][position]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">links[upsell][0][position]</stringProp>
-            </elementProp>
-            <elementProp name="links[crosssell][0][id]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">${related_product_id}</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">links[crosssell][0][id]</stringProp>
-            </elementProp>
-            <elementProp name="links[crosssell][0][position]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">links[crosssell][0][position]</stringProp>
-            </elementProp>
-          </collectionProp>
-        </elementProp>
-        <stringProp name="HTTPSampler.domain"/>
-        <stringProp name="HTTPSampler.port"/>
-        <stringProp name="HTTPSampler.connect_timeout"/>
-        <stringProp name="HTTPSampler.response_timeout"/>
-        <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
-        <stringProp name="HTTPSampler.contentEncoding"/>
-        <stringProp name="HTTPSampler.path">${base_path}${admin_path}/catalog/product/save/set/4/type/configurable/back/edit/active_tab/product-details/</stringProp>
-        <stringProp name="HTTPSampler.method">POST</stringProp>
-        <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
-        <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
-        <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
-        <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
-        <boolProp name="HTTPSampler.monitor">false</boolProp>
-        <stringProp name="HTTPSampler.embedded_url_re"/>
-      </HTTPSamplerProxy>
-      <hashTree>
-        <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Response Assertion" enabled="true">
-          <collectionProp name="Asserion.test_strings">
-            <stringProp name="-583471546">You saved the product</stringProp>
-          </collectionProp>
-          <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
-          <boolProp name="Assertion.assume_success">false</boolProp>
-          <intProp name="Assertion.test_type">2</intProp>
-        </ResponseAssertion>
-        <hashTree/>
-        <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Response Assertion" enabled="true">
-          <collectionProp name="Asserion.test_strings">
-            <stringProp name="-1600986843">violation</stringProp>
-          </collectionProp>
-          <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
-          <boolProp name="Assertion.assume_success">false</boolProp>
-          <intProp name="Assertion.test_type">6</intProp>
-        </ResponseAssertion>
-        <hashTree/>
-      </hashTree>
-    </hashTree>
-  
-    <TestFragmentController guiclass="TestFragmentControllerGui" testclass="TestFragmentController" testname="Admin Create Downloadable Product" enabled="true">
-  <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_create_product/create_downloadable_product.jmx</stringProp>
-</TestFragmentController>
-    <hashTree>
-      <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Catalog Product" enabled="true">
-        <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
-          <collectionProp name="Arguments.arguments"/>
-        </elementProp>
-        <stringProp name="HTTPSampler.domain"/>
-        <stringProp name="HTTPSampler.port"/>
-        <stringProp name="HTTPSampler.connect_timeout"/>
-        <stringProp name="HTTPSampler.response_timeout"/>
-        <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
-        <stringProp name="HTTPSampler.contentEncoding"/>
-        <stringProp name="HTTPSampler.path">${base_path}${admin_path}/catalog/product/</stringProp>
-        <stringProp name="HTTPSampler.method">GET</stringProp>
-        <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
-        <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
-        <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
-        <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
-        <boolProp name="HTTPSampler.monitor">false</boolProp>
-        <stringProp name="HTTPSampler.embedded_url_re"/>
-      </HTTPSamplerProxy>
-      <hashTree>
-        <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Response Assertion" enabled="true">
-          <collectionProp name="Asserion.test_strings">
-            <stringProp name="1509986340">records found</stringProp>
-          </collectionProp>
-          <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
-          <boolProp name="Assertion.assume_success">false</boolProp>
-          <intProp name="Assertion.test_type">2</intProp>
-        </ResponseAssertion>
-        <hashTree/>
-      </hashTree>
-      <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="New Downloadable Product" enabled="true">
-        <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
-          <collectionProp name="Arguments.arguments"/>
-        </elementProp>
-        <stringProp name="HTTPSampler.domain"/>
-        <stringProp name="HTTPSampler.port"/>
-        <stringProp name="HTTPSampler.connect_timeout"/>
-        <stringProp name="HTTPSampler.response_timeout"/>
-        <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
-        <stringProp name="HTTPSampler.contentEncoding"/>
-        <stringProp name="HTTPSampler.path">${base_path}${admin_path}/catalog/product/new/set/4/type/downloadable/</stringProp>
-        <stringProp name="HTTPSampler.method">GET</stringProp>
-        <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
-        <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
-        <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
-        <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
-        <boolProp name="HTTPSampler.monitor">false</boolProp>
-        <stringProp name="HTTPSampler.embedded_url_re"/>
-      </HTTPSamplerProxy>
-      <hashTree>
-        <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Response Assertion" enabled="true">
-          <collectionProp name="Asserion.test_strings">
-            <stringProp name="-144461265">New Product</stringProp>
-          </collectionProp>
-          <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
-          <boolProp name="Assertion.assume_success">false</boolProp>
-          <intProp name="Assertion.test_type">2</intProp>
-        </ResponseAssertion>
-        <hashTree/>
-      </hashTree>
-      <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="New Downloadable Upload Original File" enabled="true">
-        <elementProp name="HTTPsampler.Files" elementType="HTTPFileArgs">
-          <collectionProp name="HTTPFileArgs.files">
-            <elementProp name="${files_folder}downloadable_original.txt" elementType="HTTPFileArg">
-              <stringProp name="File.path">${files_folder}downloadable_original.txt</stringProp>
-              <stringProp name="File.paramname">links</stringProp>
-              <stringProp name="File.mimetype">text/plain</stringProp>
-            </elementProp>
-          </collectionProp>
-        </elementProp>
-        <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
-          <collectionProp name="Arguments.arguments">
-            <elementProp name="form_key" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">${admin_form_key}</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">form_key</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-          </collectionProp>
-        </elementProp>
-        <stringProp name="HTTPSampler.domain"/>
-        <stringProp name="HTTPSampler.port"/>
-        <stringProp name="HTTPSampler.connect_timeout"/>
-        <stringProp name="HTTPSampler.response_timeout"/>
-        <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
-        <stringProp name="HTTPSampler.contentEncoding"/>
-        <stringProp name="HTTPSampler.path">${base_path}${admin_path}/admin/downloadable_file/upload/type/links/?isAjax=true</stringProp>
-        <stringProp name="HTTPSampler.method">POST</stringProp>
-        <boolProp name="HTTPSampler.follow_redirects">false</boolProp>
-        <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
-        <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
-        <boolProp name="HTTPSampler.DO_MULTIPART_POST">true</boolProp>
-        <boolProp name="HTTPSampler.monitor">false</boolProp>
-        <stringProp name="HTTPSampler.embedded_url_re"/>
-      </HTTPSamplerProxy>
-      <hashTree>
-        <com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor guiclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.gui.JSONPathExtractorGui" testclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor" testname="Extract original file" enabled="true">
-          <stringProp name="VAR">original_file</stringProp>
-          <stringProp name="JSONPATH">$.file</stringProp>
-          <stringProp name="DEFAULT"/>
-          <stringProp name="VARIABLE"/>
-          <stringProp name="SUBJECT">BODY</stringProp>
-        </com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor>
-        <hashTree/>
-      </hashTree>
-      <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="New Downloadable Upload Sample File" enabled="true">
-        <elementProp name="HTTPsampler.Files" elementType="HTTPFileArgs">
-          <collectionProp name="HTTPFileArgs.files">
-            <elementProp name="${files_folder}downloadable_sample.txt" elementType="HTTPFileArg">
-              <stringProp name="File.path">${files_folder}downloadable_sample.txt</stringProp>
-              <stringProp name="File.paramname">samples</stringProp>
-              <stringProp name="File.mimetype">text/plain</stringProp>
-            </elementProp>
-          </collectionProp>
-        </elementProp>
-        <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
-          <collectionProp name="Arguments.arguments">
-            <elementProp name="form_key" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">${admin_form_key}</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">form_key</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-          </collectionProp>
-        </elementProp>
-        <stringProp name="HTTPSampler.domain"/>
-        <stringProp name="HTTPSampler.port"/>
-        <stringProp name="HTTPSampler.connect_timeout"/>
-        <stringProp name="HTTPSampler.response_timeout"/>
-        <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
-        <stringProp name="HTTPSampler.contentEncoding"/>
-        <stringProp name="HTTPSampler.path">${base_path}${admin_path}/admin/downloadable_file/upload/type/samples/?isAjax=true</stringProp>
-        <stringProp name="HTTPSampler.method">POST</stringProp>
-        <boolProp name="HTTPSampler.follow_redirects">false</boolProp>
-        <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
-        <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
-        <boolProp name="HTTPSampler.DO_MULTIPART_POST">true</boolProp>
-        <boolProp name="HTTPSampler.monitor">false</boolProp>
-        <stringProp name="HTTPSampler.embedded_url_re"/>
-      </HTTPSamplerProxy>
-      <hashTree>
-        <com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor guiclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.gui.JSONPathExtractorGui" testclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor" testname="Extract sample file" enabled="true">
-          <stringProp name="VAR">sample_file</stringProp>
-          <stringProp name="JSONPATH">$.file</stringProp>
-          <stringProp name="DEFAULT"/>
-          <stringProp name="VARIABLE"/>
-          <stringProp name="SUBJECT">BODY</stringProp>
-        </com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor>
-        <hashTree/>
-      </hashTree>
-      <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="New Downloadable Product Validate" enabled="true">
-        <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
-          <collectionProp name="Arguments.arguments">
-            <elementProp name="ajax" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">true</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">ajax</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="isAjax" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">true</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">isAjax</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="form_key" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">${admin_form_key}</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">form_key</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="product[name]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">Downloadable Product ${__time(YMDHMS)}-${__threadNum}-${__Random(1,1000000)}</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[name]</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="product[sku]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">SKU ${__time(YMDHMS)}-${__threadNum}-${__Random(1,1000000)}</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[sku]</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="product[price]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">123</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[price]</stringProp>
-            </elementProp>
-            <elementProp name="product[tax_class_id]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">2</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[tax_class_id]</stringProp>
-            </elementProp>
-            <elementProp name="product[quantity_and_stock_status][qty]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">111</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[quantity_and_stock_status][qty]</stringProp>
-            </elementProp>
-            <elementProp name="product[quantity_and_stock_status][is_in_stock]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[quantity_and_stock_status][is_in_stock]</stringProp>
-            </elementProp>
-            <elementProp name="product[weight]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1.0000</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[weight]</stringProp>
-            </elementProp>
-            <elementProp name="product[category_ids][]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">2</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[category_ids][]</stringProp>
-            </elementProp>
-            <elementProp name="product[description]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">&lt;p&gt;Full downloadable product description ${__time(YMDHMS)}-${__threadNum}-${__Random(1,1000000)}&lt;/p&gt;</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[description]</stringProp>
-            </elementProp>
-            <elementProp name="product[short_description]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">&lt;p&gt;Short downloadable product description ${__time(YMDHMS)}-${__threadNum}-${__Random(1,1000000)}&lt;/p&gt;</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[short_description]</stringProp>
-            </elementProp>
-            <elementProp name="product[status]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[status]</stringProp>
-            </elementProp>
-            <elementProp name="product[image]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[image]</stringProp>
-            </elementProp>
-            <elementProp name="product[small_image]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[small_image]</stringProp>
-            </elementProp>
-            <elementProp name="product[thumbnail]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[thumbnail]</stringProp>
-            </elementProp>
-            <elementProp name="product[url_key]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">downloadable-product-${__time(YMDHMS)}-${__threadNum}-${__Random(1,1000000)}</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[url_key]</stringProp>
-            </elementProp>
-            <elementProp name="product[meta_title]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">Downloadable Product ${__time(YMDHMS)}-${__threadNum}-${__Random(1,1000000)} Meta Title</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[meta_title]</stringProp>
-            </elementProp>
-            <elementProp name="product[meta_keyword]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">Downloadable Product ${__time(YMDHMS)}-${__threadNum}-${__Random(1,1000000)} Meta Keyword</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[meta_keyword]</stringProp>
-            </elementProp>
-            <elementProp name="product[meta_description]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">Downloadable Product ${__time(YMDHMS)}-${__threadNum}-${__Random(1,1000000)} Meta Description</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[meta_description]</stringProp>
-            </elementProp>
-            <elementProp name="product[website_ids][]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[website_ids][]</stringProp>
-            </elementProp>
-            <elementProp name="product[special_price]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">99</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[special_price]</stringProp>
-            </elementProp>
-            <elementProp name="product[stock_data][notify_stock_qty]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[stock_data][notify_stock_qty]</stringProp>
-            </elementProp>
-            <elementProp name="product[special_from_date]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[special_from_date]</stringProp>
-            </elementProp>
-            <elementProp name="product[special_to_date]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[special_to_date]</stringProp>
-            </elementProp>
-            <elementProp name="product[cost]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[cost]</stringProp>
-            </elementProp>
-            <elementProp name="product[tier_price][0][website_id]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">0</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[tier_price][0][website_id]</stringProp>
-            </elementProp>
-            <elementProp name="product[tier_price][0][cust_group]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">32000</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[tier_price][0][cust_group]</stringProp>
-            </elementProp>
-            <elementProp name="product[tier_price][0][price_qty]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">100</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[tier_price][0][price_qty]</stringProp>
-            </elementProp>
-            <elementProp name="product[tier_price][0][price]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">90</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[tier_price][0][price]</stringProp>
-            </elementProp>
-            <elementProp name="product[tier_price][0][delete]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[tier_price][0][delete]</stringProp>
-            </elementProp>
-            <elementProp name="product[tier_price][1][website_id]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">0</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[tier_price][1][website_id]</stringProp>
-            </elementProp>
-            <elementProp name="product[tier_price][1][cust_group]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[tier_price][1][cust_group]</stringProp>
-            </elementProp>
-            <elementProp name="product[tier_price][1][price_qty]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">101</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[tier_price][1][price_qty]</stringProp>
-            </elementProp>
-            <elementProp name="product[tier_price][1][price]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">99</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[tier_price][1][price]</stringProp>
-            </elementProp>
-            <elementProp name="product[tier_price][1][delete]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[tier_price][1][delete]</stringProp>
-            </elementProp>
-            <elementProp name="product[stock_data][use_config_manage_stock]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[stock_data][use_config_manage_stock]</stringProp>
-            </elementProp>
-            <elementProp name="product[stock_data][original_inventory_qty]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">100500</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[stock_data][original_inventory_qty]</stringProp>
-            </elementProp>
-            <elementProp name="product[stock_data][qty]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">100500</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[stock_data][qty]</stringProp>
-            </elementProp>
-            <elementProp name="product[stock_data][min_qty]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">0</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[stock_data][min_qty]</stringProp>
-            </elementProp>
-            <elementProp name="product[stock_data][use_config_min_qty]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[stock_data][use_config_min_qty]</stringProp>
-            </elementProp>
-            <elementProp name="product[stock_data][min_sale_qty]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[stock_data][min_sale_qty]</stringProp>
-            </elementProp>
-            <elementProp name="product[stock_data][use_config_min_sale_qty]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[stock_data][use_config_min_sale_qty]</stringProp>
-            </elementProp>
-            <elementProp name="product[stock_data][max_sale_qty]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">10000</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[stock_data][max_sale_qty]</stringProp>
-            </elementProp>
-            <elementProp name="product[stock_data][use_config_max_sale_qty]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[stock_data][use_config_max_sale_qty]</stringProp>
-            </elementProp>
-            <elementProp name="product[stock_data][is_qty_decimal]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">0</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[stock_data][is_qty_decimal]</stringProp>
-            </elementProp>
-            <elementProp name="product[stock_data][is_decimal_divided]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">0</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[stock_data][is_decimal_divided]</stringProp>
-            </elementProp>
-            <elementProp name="product[stock_data][backorders]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">0</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[stock_data][backorders]</stringProp>
-            </elementProp>
-            <elementProp name="product[stock_data][use_config_backorders]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[stock_data][use_config_backorders]</stringProp>
-            </elementProp>
-            <elementProp name="product[stock_data][use_config_notify_stock_qty]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[stock_data][use_config_notify_stock_qty]</stringProp>
-            </elementProp>
-            <elementProp name="product[stock_data][enable_qty_increments]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">0</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[stock_data][enable_qty_increments]</stringProp>
-            </elementProp>
-            <elementProp name="product[stock_data][qty_increments]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">0</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[stock_data][qty_increments]</stringProp>
-            </elementProp>
-            <elementProp name="product[stock_data][use_config_qty_increments]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[stock_data][use_config_qty_increments]</stringProp>
-            </elementProp>
-            <elementProp name="product[stock_data][is_in_stock]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[stock_data][is_in_stock]</stringProp>
-            </elementProp>
-            <elementProp name="product[custom_design]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[custom_design]</stringProp>
-            </elementProp>
-            <elementProp name="product[custom_design_from]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[custom_design_from]</stringProp>
-            </elementProp>
-            <elementProp name="product[custom_design_to]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[custom_design_to]</stringProp>
-            </elementProp>
-            <elementProp name="product[custom_layout_update]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[custom_layout_update]</stringProp>
-            </elementProp>
-            <elementProp name="product[page_layout]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[page_layout]</stringProp>
-            </elementProp>
-            <elementProp name="product[options_container]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">container2</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[options_container]</stringProp>
-            </elementProp>
-            <elementProp name="is_downloadable" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">on</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">is_downloadable</stringProp>
-            </elementProp>
-            <elementProp name="product[links_title]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">Links</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[links_title]</stringProp>
-            </elementProp>
-            <elementProp name="product[links_purchased_separately]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">0</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[links_purchased_separately]</stringProp>
-            </elementProp>
-            <elementProp name="downloadable[link][0][file][0][file]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">${original_file}</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">downloadable[link][0][file][0][file]</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="downloadable[link][0][file][0][name]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">downloadable_original.txt</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">downloadable[link][0][file][0][name]</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="downloadable[link][0][file][0][size]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">13</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">downloadable[link][0][file][0][size]</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="downloadable[link][0][file][0][status]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">new</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">downloadable[link][0][file][0][status]</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="downloadable[link][0][is_shareable]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">downloadable[link][0][is_shareable]</stringProp>
-            </elementProp>
-            <elementProp name="downloadable[link][0][is_unlimited]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">0</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">downloadable[link][0][is_unlimited]</stringProp>
-            </elementProp>
-            <elementProp name="downloadable[link][0][link_url]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">downloadable[link][0][link_url]</stringProp>
-            </elementProp>
-            <elementProp name="downloadable[link][0][number_of_downloads]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">0</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">downloadable[link][0][number_of_downloads]</stringProp>
-              <stringProp name="Argument.desc">true</stringProp>
-            </elementProp>
-            <elementProp name="downloadable[link][0][price]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">120</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">downloadable[link][0][price]</stringProp>
-              <stringProp name="Argument.desc">true</stringProp>
-            </elementProp>
-            <elementProp name="downloadable[link][0][record_id]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">0</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">downloadable[link][0][record_id]</stringProp>
-              <stringProp name="Argument.desc">true</stringProp>
-            </elementProp>
-            <elementProp name="downloadable[link][0][sample][type]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">file</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">downloadable[link][0][sample][type]</stringProp>
-            </elementProp>
-            <elementProp name="downloadable[link][0][sample][url]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">downloadable[link][0][sample][url]</stringProp>
-            </elementProp>
-            <elementProp name="downloadable[link][0][sort_order]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">downloadable[link][0][sort_order]</stringProp>
-            </elementProp>
-            <elementProp name="downloadable[link][0][title]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">Original Link</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">downloadable[link][0][title]</stringProp>
-            </elementProp>
-            <elementProp name="downloadable[link][0][type]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">file</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">downloadable[link][0][type]</stringProp>
-            </elementProp>
-            <elementProp name="downloadable[sample][0][file][0][file]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">${sample_file}</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">downloadable[sample][0][file][0][file]</stringProp>
-              <stringProp name="Argument.desc">true</stringProp>
-            </elementProp>
-            <elementProp name="downloadable[sample][0][file][0][name]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">downloadable_sample.txt</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">downloadable[sample][0][file][0][name]</stringProp>
-              <stringProp name="Argument.desc">true</stringProp>
-            </elementProp>
-            <elementProp name="downloadable[sample][0][file][0][size]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">14</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">downloadable[sample][0][file][0][size]</stringProp>
-              <stringProp name="Argument.desc">true</stringProp>
-            </elementProp>
-            <elementProp name="downloadable[sample][0][file][0][status]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">new</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">downloadable[sample][0][file][0][status]</stringProp>
-              <stringProp name="Argument.desc">true</stringProp>
-            </elementProp>
-            <elementProp name="downloadable[sample][0][record_id]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">0</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">downloadable[sample][0][record_id]</stringProp>
-              <stringProp name="Argument.desc">true</stringProp>
-            </elementProp>
-            <elementProp name="downloadable[sample][0][sample_url]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">downloadable[sample][0][sample_url]</stringProp>
-              <stringProp name="Argument.desc">true</stringProp>
-            </elementProp>
-            <elementProp name="downloadable[sample][0][sort_order]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">downloadable[sample][0][sort_order]</stringProp>
-              <stringProp name="Argument.desc">true</stringProp>
-            </elementProp>
-            <elementProp name="downloadable[sample][0][title]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">Sample Link</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">downloadable[sample][0][title]</stringProp>
-              <stringProp name="Argument.desc">true</stringProp>
-            </elementProp>
-            <elementProp name="downloadable[sample][0][type]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">file</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">downloadable[sample][0][type]</stringProp>
-              <stringProp name="Argument.desc">true</stringProp>
-            </elementProp>
-            <elementProp name="affect_configurable_product_attributes" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">affect_configurable_product_attributes</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="new-variations-attribute-set-id" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">4</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">new-variations-attribute-set-id</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="product[configurable_variation]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[configurable_variation]</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="links[related][0][id]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">${related_product_id}</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">links[related][0][id]</stringProp>
-            </elementProp>
-            <elementProp name="links[related][0][position]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">links[related][0][position]</stringProp>
-            </elementProp>
-            <elementProp name="links[upsell][0][id]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">${related_product_id}</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">links[upsell][0][id]</stringProp>
-            </elementProp>
-            <elementProp name="links[upsell][0][position]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">links[upsell][0][position]</stringProp>
-            </elementProp>
-            <elementProp name="links[crosssell][0][id]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">${related_product_id}</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">links[crosssell][0][id]</stringProp>
-            </elementProp>
-            <elementProp name="links[crosssell][0][position]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">links[crosssell][0][position]</stringProp>
-            </elementProp>
-          </collectionProp>
-        </elementProp>
-        <stringProp name="HTTPSampler.domain"/>
-        <stringProp name="HTTPSampler.port"/>
-        <stringProp name="HTTPSampler.connect_timeout"/>
-        <stringProp name="HTTPSampler.response_timeout"/>
-        <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
-        <stringProp name="HTTPSampler.contentEncoding"/>
-        <stringProp name="HTTPSampler.path">${base_path}${admin_path}/catalog/product/validate/set/4/type/downloadable/</stringProp>
-        <stringProp name="HTTPSampler.method">POST</stringProp>
-        <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
-        <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
-        <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
-        <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
-        <boolProp name="HTTPSampler.monitor">false</boolProp>
-        <stringProp name="HTTPSampler.embedded_url_re"/>
-      </HTTPSamplerProxy>
-      <hashTree>
-        <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Response Assertion" enabled="true">
-          <collectionProp name="Asserion.test_strings">
-            <stringProp name="1853918323">{"error":false}</stringProp>
-          </collectionProp>
-          <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
-          <boolProp name="Assertion.assume_success">false</boolProp>
-          <intProp name="Assertion.test_type">2</intProp>
-        </ResponseAssertion>
-        <hashTree/>
-      </hashTree>
-      <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="New Downloadable Product Save" enabled="true">
-        <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
-          <collectionProp name="Arguments.arguments">
-            <elementProp name="ajax" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">true</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">ajax</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="isAjax" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">true</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">isAjax</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="form_key" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">${admin_form_key}</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">form_key</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="product[name]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">Downloadable Product ${__time(YMDHMS)}-${__threadNum}-${__Random(1,1000000)}</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[name]</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="product[sku]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">SKU ${__time(YMDHMS)}-${__threadNum}-${__Random(1,1000000)}</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[sku]</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="product[price]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">123</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[price]</stringProp>
-            </elementProp>
-            <elementProp name="product[tax_class_id]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">2</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[tax_class_id]</stringProp>
-            </elementProp>
-            <elementProp name="product[quantity_and_stock_status][qty]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">111</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[quantity_and_stock_status][qty]</stringProp>
-            </elementProp>
-            <elementProp name="product[quantity_and_stock_status][is_in_stock]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[quantity_and_stock_status][is_in_stock]</stringProp>
-            </elementProp>
-            <elementProp name="product[weight]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1.0000</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[weight]</stringProp>
-            </elementProp>
-            <elementProp name="product[category_ids][]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">2</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[category_ids][]</stringProp>
-            </elementProp>
-            <elementProp name="product[description]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">&lt;p&gt;Full downloadable product description ${__time(YMDHMS)}-${__threadNum}-${__Random(1,1000000)}&lt;/p&gt;</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[description]</stringProp>
-            </elementProp>
-            <elementProp name="product[short_description]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">&lt;p&gt;Short downloadable product description ${__time(YMDHMS)}-${__threadNum}-${__Random(1,1000000)}&lt;/p&gt;</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[short_description]</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="product[status]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[status]</stringProp>
-            </elementProp>
-            <elementProp name="product[image]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[image]</stringProp>
-            </elementProp>
-            <elementProp name="product[small_image]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[small_image]</stringProp>
-            </elementProp>
-            <elementProp name="product[thumbnail]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[thumbnail]</stringProp>
-            </elementProp>
-            <elementProp name="product[url_key]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">downloadable-product-${__time(YMDHMS)}-${__threadNum}-${__Random(1,1000000)}</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[url_key]</stringProp>
-            </elementProp>
-            <elementProp name="product[meta_title]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">Downloadable Product ${__time(YMDHMS)}-${__threadNum}-${__Random(1,1000000)} Meta Title</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[meta_title]</stringProp>
-            </elementProp>
-            <elementProp name="product[meta_keyword]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">Downloadable Product ${__time(YMDHMS)}-${__threadNum}-${__Random(1,1000000)} Meta Keyword</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[meta_keyword]</stringProp>
-            </elementProp>
-            <elementProp name="product[meta_description]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">Downloadable Product ${__time(YMDHMS)}-${__threadNum}-${__Random(1,1000000)} Meta Description</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[meta_description]</stringProp>
-            </elementProp>
-            <elementProp name="product[website_ids][]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[website_ids][]</stringProp>
-            </elementProp>
-            <elementProp name="product[special_price]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">99</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[special_price]</stringProp>
-            </elementProp>
-            <elementProp name="product[special_from_date]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[special_from_date]</stringProp>
-            </elementProp>
-            <elementProp name="product[special_to_date]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[special_to_date]</stringProp>
-            </elementProp>
-            <elementProp name="product[cost]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[cost]</stringProp>
-            </elementProp>
-            <elementProp name="product[tier_price][0][website_id]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">0</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[tier_price][0][website_id]</stringProp>
-            </elementProp>
-            <elementProp name="product[tier_price][0][cust_group]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">32000</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[tier_price][0][cust_group]</stringProp>
-            </elementProp>
-            <elementProp name="product[tier_price][0][price_qty]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">100</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[tier_price][0][price_qty]</stringProp>
-            </elementProp>
-            <elementProp name="product[tier_price][0][price]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">90</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[tier_price][0][price]</stringProp>
-            </elementProp>
-            <elementProp name="product[tier_price][0][delete]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[tier_price][0][delete]</stringProp>
-            </elementProp>
-            <elementProp name="product[tier_price][1][website_id]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">0</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[tier_price][1][website_id]</stringProp>
-            </elementProp>
-            <elementProp name="product[tier_price][1][cust_group]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[tier_price][1][cust_group]</stringProp>
-            </elementProp>
-            <elementProp name="product[tier_price][1][price_qty]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">101</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[tier_price][1][price_qty]</stringProp>
-            </elementProp>
-            <elementProp name="product[tier_price][1][price]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">99</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[tier_price][1][price]</stringProp>
-            </elementProp>
-            <elementProp name="product[tier_price][1][delete]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[tier_price][1][delete]</stringProp>
-            </elementProp>
-            <elementProp name="product[stock_data][use_config_manage_stock]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[stock_data][use_config_manage_stock]</stringProp>
-            </elementProp>
-            <elementProp name="product[stock_data][original_inventory_qty]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">100500</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[stock_data][original_inventory_qty]</stringProp>
-            </elementProp>
-            <elementProp name="product[stock_data][qty]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">100500</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[stock_data][qty]</stringProp>
-            </elementProp>
-            <elementProp name="product[stock_data][min_qty]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">0</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[stock_data][min_qty]</stringProp>
-            </elementProp>
-            <elementProp name="product[stock_data][use_config_min_qty]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[stock_data][use_config_min_qty]</stringProp>
-            </elementProp>
-            <elementProp name="product[stock_data][min_sale_qty]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[stock_data][min_sale_qty]</stringProp>
-            </elementProp>
-            <elementProp name="product[stock_data][use_config_min_sale_qty]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[stock_data][use_config_min_sale_qty]</stringProp>
-            </elementProp>
-            <elementProp name="product[stock_data][max_sale_qty]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">10000</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[stock_data][max_sale_qty]</stringProp>
-            </elementProp>
-            <elementProp name="product[stock_data][use_config_max_sale_qty]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[stock_data][use_config_max_sale_qty]</stringProp>
-            </elementProp>
-            <elementProp name="product[stock_data][is_qty_decimal]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">0</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[stock_data][is_qty_decimal]</stringProp>
-            </elementProp>
-            <elementProp name="product[stock_data][is_decimal_divided]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">0</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[stock_data][is_decimal_divided]</stringProp>
-            </elementProp>
-            <elementProp name="product[stock_data][backorders]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">0</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[stock_data][backorders]</stringProp>
-            </elementProp>
-            <elementProp name="product[stock_data][use_config_backorders]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[stock_data][use_config_backorders]</stringProp>
-            </elementProp>
-            <elementProp name="product[stock_data][notify_stock_qty]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[stock_data][notify_stock_qty]</stringProp>
-            </elementProp>
-            <elementProp name="product[stock_data][use_config_notify_stock_qty]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[stock_data][use_config_notify_stock_qty]</stringProp>
-            </elementProp>
-            <elementProp name="product[stock_data][enable_qty_increments]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">0</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[stock_data][enable_qty_increments]</stringProp>
-            </elementProp>
-            <elementProp name="product[stock_data][qty_increments]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">0</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[stock_data][qty_increments]</stringProp>
-            </elementProp>
-            <elementProp name="product[stock_data][use_config_qty_increments]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[stock_data][use_config_qty_increments]</stringProp>
-            </elementProp>
-            <elementProp name="product[stock_data][is_in_stock]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[stock_data][is_in_stock]</stringProp>
-            </elementProp>
-            <elementProp name="product[custom_design]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[custom_design]</stringProp>
-            </elementProp>
-            <elementProp name="product[custom_design_from]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[custom_design_from]</stringProp>
-            </elementProp>
-            <elementProp name="product[custom_design_to]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[custom_design_to]</stringProp>
-            </elementProp>
-            <elementProp name="product[custom_layout_update]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[custom_layout_update]</stringProp>
-            </elementProp>
-            <elementProp name="product[page_layout]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[page_layout]</stringProp>
-            </elementProp>
-            <elementProp name="product[options_container]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">container2</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[options_container]</stringProp>
-            </elementProp>
-            <elementProp name="downloadable[link][0][file][0][file]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">${original_file}</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">downloadable[link][0][file][0][file]</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="downloadable[link][0][file][0][name]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">downloadable_original.txt</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">downloadable[link][0][file][0][name]</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="downloadable[link][0][file][0][size]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">13</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">downloadable[link][0][file][0][size]</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="downloadable[link][0][file][0][status]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">new</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">downloadable[link][0][file][0][status]</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="downloadable[link][0][is_shareable]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">downloadable[link][0][is_shareable]</stringProp>
-              <stringProp name="Argument.desc">true</stringProp>
-            </elementProp>
-            <elementProp name="downloadable[link][0][is_unlimited]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">0</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">downloadable[link][0][is_unlimited]</stringProp>
-              <stringProp name="Argument.desc">true</stringProp>
-            </elementProp>
-            <elementProp name="downloadable[link][0][link_url]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">downloadable[link][0][link_url]</stringProp>
-              <stringProp name="Argument.desc">true</stringProp>
-            </elementProp>
-            <elementProp name="downloadable[link][0][number_of_downloads]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">0</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">downloadable[link][0][number_of_downloads]</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="downloadable[link][0][price]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">120</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">downloadable[link][0][price]</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="downloadable[link][0][record_id]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">0</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">downloadable[link][0][record_id]</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="downloadable[link][0][sample][type]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">file</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">downloadable[link][0][sample][type]</stringProp>
-              <stringProp name="Argument.desc">true</stringProp>
-            </elementProp>
-            <elementProp name="downloadable[link][0][sample][url]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">downloadable[link][0][sample][url]</stringProp>
-              <stringProp name="Argument.desc">true</stringProp>
-            </elementProp>
-            <elementProp name="downloadable[link][0][sort_order]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">downloadable[link][0][sort_order]</stringProp>
-              <stringProp name="Argument.desc">true</stringProp>
-            </elementProp>
-            <elementProp name="downloadable[link][0][title]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">Original Link</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">downloadable[link][0][title]</stringProp>
-              <stringProp name="Argument.desc">true</stringProp>
-            </elementProp>
-            <elementProp name="downloadable[link][0][type]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">file</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">downloadable[link][0][type]</stringProp>
-              <stringProp name="Argument.desc">true</stringProp>
-            </elementProp>
-            <elementProp name="downloadable[sample][0][file][0][file]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">${sample_file}</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">downloadable[sample][0][file][0][file]</stringProp>
-              <stringProp name="Argument.desc">true</stringProp>
-            </elementProp>
-            <elementProp name="downloadable[sample][0][file][0][name]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">downloadable_sample.txt</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">downloadable[sample][0][file][0][name]</stringProp>
-              <stringProp name="Argument.desc">true</stringProp>
-            </elementProp>
-            <elementProp name="downloadable[sample][0][file][0][size]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">14</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">downloadable[sample][0][file][0][size]</stringProp>
-              <stringProp name="Argument.desc">true</stringProp>
-            </elementProp>
-            <elementProp name="downloadable[sample][0][file][0][status]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">new</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">downloadable[sample][0][file][0][status]</stringProp>
-              <stringProp name="Argument.desc">true</stringProp>
-            </elementProp>
-            <elementProp name="downloadable[sample][0][record_id]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">0</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">downloadable[sample][0][record_id]</stringProp>
-              <stringProp name="Argument.desc">true</stringProp>
-            </elementProp>
-            <elementProp name="downloadable[sample][0][sample_url]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">downloadable[sample][0][sample_url]</stringProp>
-              <stringProp name="Argument.desc">true</stringProp>
-            </elementProp>
-            <elementProp name="downloadable[sample][0][sort_order]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">downloadable[sample][0][sort_order]</stringProp>
-              <stringProp name="Argument.desc">true</stringProp>
-            </elementProp>
-            <elementProp name="downloadable[sample][0][title]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">Sample Link</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">downloadable[sample][0][title]</stringProp>
-              <stringProp name="Argument.desc">true</stringProp>
-            </elementProp>
-            <elementProp name="downloadable[sample][0][type]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">file</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">downloadable[sample][0][type]</stringProp>
-              <stringProp name="Argument.desc">true</stringProp>
-            </elementProp>
-            <elementProp name="affect_configurable_product_attributes" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">affect_configurable_product_attributes</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="new-variations-attribute-set-id" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">4</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">new-variations-attribute-set-id</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="product[configurable_variation]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[configurable_variation]</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="links[related][0][id]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">${related_product_id}</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">links[related][0][id]</stringProp>
-            </elementProp>
-            <elementProp name="links[related][0][position]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">links[related][0][position]</stringProp>
-            </elementProp>
-            <elementProp name="links[upsell][0][id]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">${related_product_id}</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">links[upsell][0][id]</stringProp>
-            </elementProp>
-            <elementProp name="links[upsell][0][position]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">links[upsell][0][position]</stringProp>
-            </elementProp>
-            <elementProp name="links[crosssell][0][id]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">${related_product_id}</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">links[crosssell][0][id]</stringProp>
-            </elementProp>
-            <elementProp name="links[crosssell][0][position]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">links[crosssell][0][position]</stringProp>
-            </elementProp>
-          </collectionProp>
-        </elementProp>
-        <stringProp name="HTTPSampler.domain"/>
-        <stringProp name="HTTPSampler.port"/>
-        <stringProp name="HTTPSampler.connect_timeout"/>
-        <stringProp name="HTTPSampler.response_timeout"/>
-        <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
-        <stringProp name="HTTPSampler.contentEncoding"/>
-        <stringProp name="HTTPSampler.path">${base_path}${admin_path}/catalog/product/save/set/4/type/downloadable/back/edit/active_tab/product-details/</stringProp>
-        <stringProp name="HTTPSampler.method">POST</stringProp>
-        <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
-        <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
-        <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
-        <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
-        <boolProp name="HTTPSampler.monitor">false</boolProp>
-        <stringProp name="HTTPSampler.embedded_url_re"/>
-      </HTTPSamplerProxy>
-      <hashTree>
-        <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Response Assertion" enabled="true">
-          <collectionProp name="Asserion.test_strings">
-            <stringProp name="-583471546">You saved the product</stringProp>
-          </collectionProp>
-          <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
-          <boolProp name="Assertion.assume_success">false</boolProp>
-          <intProp name="Assertion.test_type">2</intProp>
-        </ResponseAssertion>
-        <hashTree/>
-        <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Response Assertion" enabled="true">
-          <collectionProp name="Asserion.test_strings">
-            <stringProp name="-1600986843">violation</stringProp>
-          </collectionProp>
-          <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
-          <boolProp name="Assertion.assume_success">false</boolProp>
-          <intProp name="Assertion.test_type">6</intProp>
-        </ResponseAssertion>
-        <hashTree/>
-      </hashTree>
-    </hashTree>
-  
-    <TestFragmentController guiclass="TestFragmentControllerGui" testclass="TestFragmentController" testname="Admin Create Simple Product" enabled="true">
-  <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_create_product/create_simple_product.jmx</stringProp>
-</TestFragmentController>
-    <hashTree>
-      <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Catalog Product" enabled="true">
-        <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
-          <collectionProp name="Arguments.arguments"/>
-        </elementProp>
-        <stringProp name="HTTPSampler.domain"/>
-        <stringProp name="HTTPSampler.port"/>
-        <stringProp name="HTTPSampler.connect_timeout"/>
-        <stringProp name="HTTPSampler.response_timeout"/>
-        <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
-        <stringProp name="HTTPSampler.contentEncoding"/>
-        <stringProp name="HTTPSampler.path">${base_path}${admin_path}/catalog/product/</stringProp>
-        <stringProp name="HTTPSampler.method">GET</stringProp>
-        <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
-        <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
-        <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
-        <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
-        <boolProp name="HTTPSampler.monitor">false</boolProp>
-        <stringProp name="HTTPSampler.embedded_url_re"/>
-      </HTTPSamplerProxy>
-      <hashTree>
-        <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Response Assertion" enabled="true">
-          <collectionProp name="Asserion.test_strings">
-            <stringProp name="1509986340">records found</stringProp>
-          </collectionProp>
-          <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
-          <boolProp name="Assertion.assume_success">false</boolProp>
-          <intProp name="Assertion.test_type">2</intProp>
-        </ResponseAssertion>
-        <hashTree/>
-      </hashTree>
-      <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="New Simple Product" enabled="true">
-        <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
-          <collectionProp name="Arguments.arguments"/>
-        </elementProp>
-        <stringProp name="HTTPSampler.domain"/>
-        <stringProp name="HTTPSampler.port"/>
-        <stringProp name="HTTPSampler.connect_timeout"/>
-        <stringProp name="HTTPSampler.response_timeout"/>
-        <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
-        <stringProp name="HTTPSampler.contentEncoding"/>
-        <stringProp name="HTTPSampler.path">${base_path}${admin_path}/catalog/product/new/set/4/type/simple/</stringProp>
-        <stringProp name="HTTPSampler.method">GET</stringProp>
-        <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
-        <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
-        <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
-        <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
-        <boolProp name="HTTPSampler.monitor">false</boolProp>
-        <stringProp name="HTTPSampler.embedded_url_re"/>
-      </HTTPSamplerProxy>
-      <hashTree>
-        <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Response Assertion" enabled="true">
-          <collectionProp name="Asserion.test_strings">
-            <stringProp name="-144461265">New Product</stringProp>
-          </collectionProp>
-          <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
-          <boolProp name="Assertion.assume_success">false</boolProp>
-          <intProp name="Assertion.test_type">2</intProp>
-        </ResponseAssertion>
-        <hashTree/>
-      </hashTree>
-      <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="New Simple Product Validate" enabled="true">
-        <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
-          <collectionProp name="Arguments.arguments">
-            <elementProp name="ajax" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">true</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">ajax</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="isAjax" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">true</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">isAjax</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="form_key" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">${admin_form_key}</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">form_key</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="product[name]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">Simple Product ${__time(YMDHMS)}-${__threadNum}-${__Random(1,1000000)}</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[name]</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="product[sku]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">SKU ${__time(YMDHMS)}-${__threadNum}-${__Random(1,1000000)}</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[sku]</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="product[price]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">123</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[price]</stringProp>
-            </elementProp>
-            <elementProp name="product[tax_class_id]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">2</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[tax_class_id]</stringProp>
-            </elementProp>
-            <elementProp name="product[quantity_and_stock_status][qty]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">111</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[quantity_and_stock_status][qty]</stringProp>
-            </elementProp>
-            <elementProp name="product[quantity_and_stock_status][is_in_stock]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[quantity_and_stock_status][is_in_stock]</stringProp>
-            </elementProp>
-            <elementProp name="product[weight]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1.0000</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[weight]</stringProp>
-            </elementProp>
-            <elementProp name="product[product_has_weight]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[product_has_weight]</stringProp>
-              <stringProp name="Argument.desc">true</stringProp>
-            </elementProp>
-            <elementProp name="product[category_ids][]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">2</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[category_ids][]</stringProp>
-            </elementProp>
-            <elementProp name="product[description]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">&lt;p&gt;Full simple product description ${__time(YMDHMS)}-${__threadNum}-${__Random(1,1000000)}&lt;/p&gt;</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[description]</stringProp>
-            </elementProp>
-            <elementProp name="product[short_description]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">&lt;p&gt;Short simple product description ${__time(YMDHMS)}-${__threadNum}-${__Random(1,1000000)}&lt;/p&gt;</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[short_description]</stringProp>
-            </elementProp>
-            <elementProp name="product[status]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[status]</stringProp>
-            </elementProp>
-            <elementProp name="product[image]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[image]</stringProp>
-            </elementProp>
-            <elementProp name="product[small_image]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[small_image]</stringProp>
-            </elementProp>
-            <elementProp name="product[thumbnail]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[thumbnail]</stringProp>
-            </elementProp>
-            <elementProp name="product[url_key]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">simple-product-${__time(YMDHMS)}-${__threadNum}-${__Random(1,1000000)}</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[url_key]</stringProp>
-            </elementProp>
-            <elementProp name="product[meta_title]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">Simple Product ${__time(YMDHMS)}-${__threadNum}-${__Random(1,1000000)} Meta Title</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[meta_title]</stringProp>
-            </elementProp>
-            <elementProp name="product[meta_keyword]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">Simple Product ${__time(YMDHMS)}-${__threadNum}-${__Random(1,1000000)} Meta Keyword</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[meta_keyword]</stringProp>
-            </elementProp>
-            <elementProp name="product[meta_description]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">Simple Product ${__time(YMDHMS)}-${__threadNum}-${__Random(1,1000000)} Meta Description</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[meta_description]</stringProp>
-            </elementProp>
-            <elementProp name="product[website_ids][]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[website_ids][]</stringProp>
-            </elementProp>
-            <elementProp name="product[special_price]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">99</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[special_price]</stringProp>
-            </elementProp>
-            <elementProp name="product[stock_data][notify_stock_qty]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[stock_data][notify_stock_qty]</stringProp>
-            </elementProp>
-            <elementProp name="product[special_from_date]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[special_from_date]</stringProp>
-            </elementProp>
-            <elementProp name="product[special_to_date]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[special_to_date]</stringProp>
-            </elementProp>
-            <elementProp name="product[cost]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[cost]</stringProp>
-            </elementProp>
-            <elementProp name="product[tier_price][0][website_id]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">0</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[tier_price][0][website_id]</stringProp>
-            </elementProp>
-            <elementProp name="product[tier_price][0][cust_group]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">32000</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[tier_price][0][cust_group]</stringProp>
-            </elementProp>
-            <elementProp name="product[tier_price][0][price_qty]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">100</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[tier_price][0][price_qty]</stringProp>
-            </elementProp>
-            <elementProp name="product[tier_price][0][price]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">90</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[tier_price][0][price]</stringProp>
-            </elementProp>
-            <elementProp name="product[tier_price][0][delete]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[tier_price][0][delete]</stringProp>
-            </elementProp>
-            <elementProp name="product[tier_price][1][website_id]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">0</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[tier_price][1][website_id]</stringProp>
-            </elementProp>
-            <elementProp name="product[tier_price][1][cust_group]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[tier_price][1][cust_group]</stringProp>
-            </elementProp>
-            <elementProp name="product[tier_price][1][price_qty]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">101</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[tier_price][1][price_qty]</stringProp>
-            </elementProp>
-            <elementProp name="product[tier_price][1][price]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">99</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[tier_price][1][price]</stringProp>
-            </elementProp>
-            <elementProp name="product[tier_price][1][delete]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[tier_price][1][delete]</stringProp>
-            </elementProp>
-            <elementProp name="product[stock_data][use_config_manage_stock]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[stock_data][use_config_manage_stock]</stringProp>
-            </elementProp>
-            <elementProp name="product[stock_data][original_inventory_qty]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">100500</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[stock_data][original_inventory_qty]</stringProp>
-            </elementProp>
-            <elementProp name="product[stock_data][qty]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">100500</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[stock_data][qty]</stringProp>
-            </elementProp>
-            <elementProp name="product[stock_data][min_qty]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">0</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[stock_data][min_qty]</stringProp>
-            </elementProp>
-            <elementProp name="product[stock_data][use_config_min_qty]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[stock_data][use_config_min_qty]</stringProp>
-            </elementProp>
-            <elementProp name="product[stock_data][min_sale_qty]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[stock_data][min_sale_qty]</stringProp>
-            </elementProp>
-            <elementProp name="product[stock_data][use_config_min_sale_qty]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[stock_data][use_config_min_sale_qty]</stringProp>
-            </elementProp>
-            <elementProp name="product[stock_data][max_sale_qty]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">10000</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[stock_data][max_sale_qty]</stringProp>
-            </elementProp>
-            <elementProp name="product[stock_data][use_config_max_sale_qty]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[stock_data][use_config_max_sale_qty]</stringProp>
-            </elementProp>
-            <elementProp name="product[stock_data][is_qty_decimal]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">0</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[stock_data][is_qty_decimal]</stringProp>
-            </elementProp>
-            <elementProp name="product[stock_data][is_decimal_divided]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">0</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[stock_data][is_decimal_divided]</stringProp>
-            </elementProp>
-            <elementProp name="product[stock_data][backorders]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">0</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[stock_data][backorders]</stringProp>
-            </elementProp>
-            <elementProp name="product[stock_data][use_config_backorders]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[stock_data][use_config_backorders]</stringProp>
-            </elementProp>
-            <elementProp name="product[stock_data][use_config_notify_stock_qty]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[stock_data][use_config_notify_stock_qty]</stringProp>
-            </elementProp>
-            <elementProp name="product[stock_data][enable_qty_increments]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">0</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[stock_data][enable_qty_increments]</stringProp>
-            </elementProp>
-            <elementProp name="product[stock_data][qty_increments]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">0</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[stock_data][qty_increments]</stringProp>
-            </elementProp>
-            <elementProp name="product[stock_data][use_config_qty_increments]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[stock_data][use_config_qty_increments]</stringProp>
-            </elementProp>
-            <elementProp name="product[stock_data][is_in_stock]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[stock_data][is_in_stock]</stringProp>
-            </elementProp>
-            <elementProp name="product[custom_design]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[custom_design]</stringProp>
-            </elementProp>
-            <elementProp name="product[custom_design_from]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[custom_design_from]</stringProp>
-            </elementProp>
-            <elementProp name="product[custom_design_to]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[custom_design_to]</stringProp>
-            </elementProp>
-            <elementProp name="product[custom_layout_update]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[custom_layout_update]</stringProp>
-            </elementProp>
-            <elementProp name="product[page_layout]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[page_layout]</stringProp>
-            </elementProp>
-            <elementProp name="product[options_container]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">container2</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[options_container]</stringProp>
-            </elementProp>
-            <elementProp name="product[options][1][is_delete]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[options][1][is_delete]</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="product[options][1][is_require]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[options][1][is_require]</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="product[options][1][previous_group]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">select</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[options][1][previous_group]</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="product[options][1][previous_type]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">drop_down</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[options][1][previous_type]</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="product[options][1][sort_order]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">0</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[options][1][sort_order]</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="product[options][1][title]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">Product Option Title One</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[options][1][title]</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="product[options][1][type]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">drop_down</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[options][1][type]</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="product[options][1][values][1][is_delete]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[options][1][values][1][is_delete]</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="product[options][1][values][1][price]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">200</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[options][1][values][1][price]</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="product[options][1][values][1][price_type]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">fixed</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[options][1][values][1][price_type]</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="product[options][1][values][1][sku]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">sku-one</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[options][1][values][1][sku]</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="product[options][1][values][1][sort_order]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">0</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[options][1][values][1][sort_order]</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="product[options][1][values][1][title]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">Row Title</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[options][1][values][1][title]</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="product[options][2][is_delete]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[options][2][is_delete]</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="product[options][2][is_require]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[options][2][is_require]</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="product[options][2][max_characters]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">250</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[options][2][max_characters]</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="product[options][2][previous_group]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">text</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[options][2][previous_group]</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="product[options][2][previous_type]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">field</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[options][2][previous_type]</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="product[options][2][price]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">500</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[options][2][price]</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="product[options][2][price_type]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">fixed</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[options][2][price_type]</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="product[options][2][sku]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">sku-two</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[options][2][sku]</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="product[options][2][sort_order]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[options][2][sort_order]</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="product[options][2][title]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">Field Title</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[options][2][title]</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="product[options][2][type]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">field</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[options][2][type]</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="affect_configurable_product_attributes" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">affect_configurable_product_attributes</stringProp>
-              <stringProp name="Argument.desc">true</stringProp>
-            </elementProp>
-            <elementProp name="new-variations-attribute-set-id" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">4</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">new-variations-attribute-set-id</stringProp>
-              <stringProp name="Argument.desc">true</stringProp>
-            </elementProp>
-            <elementProp name="product[configurable_variation]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[configurable_variation]</stringProp>
-              <stringProp name="Argument.desc">true</stringProp>
-            </elementProp>
-            <elementProp name="links[related][0][id]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">${related_product_id}</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">links[related][0][id]</stringProp>
-            </elementProp>
-            <elementProp name="links[related][0][position]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">links[related][0][position]</stringProp>
-            </elementProp>
-            <elementProp name="links[upsell][0][id]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">${related_product_id}</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">links[upsell][0][id]</stringProp>
-            </elementProp>
-            <elementProp name="links[upsell][0][position]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">links[upsell][0][position]</stringProp>
-            </elementProp>
-            <elementProp name="links[crosssell][0][id]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">${related_product_id}</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">links[crosssell][0][id]</stringProp>
-            </elementProp>
-            <elementProp name="links[crosssell][0][position]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">links[crosssell][0][position]</stringProp>
-            </elementProp>
-          </collectionProp>
-        </elementProp>
-        <stringProp name="HTTPSampler.domain"/>
-        <stringProp name="HTTPSampler.port"/>
-        <stringProp name="HTTPSampler.connect_timeout"/>
-        <stringProp name="HTTPSampler.response_timeout"/>
-        <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
-        <stringProp name="HTTPSampler.contentEncoding"/>
-        <stringProp name="HTTPSampler.path">${base_path}${admin_path}/catalog/product/validate/set/4/</stringProp>
-        <stringProp name="HTTPSampler.method">POST</stringProp>
-        <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
-        <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
-        <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
-        <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
-        <boolProp name="HTTPSampler.monitor">false</boolProp>
-        <stringProp name="HTTPSampler.embedded_url_re"/>
-      </HTTPSamplerProxy>
-      <hashTree>
-        <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Response Assertion" enabled="true">
-          <collectionProp name="Asserion.test_strings">
-            <stringProp name="1853918323">{"error":false}</stringProp>
-          </collectionProp>
-          <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
-          <boolProp name="Assertion.assume_success">false</boolProp>
-          <intProp name="Assertion.test_type">2</intProp>
-        </ResponseAssertion>
-        <hashTree/>
-      </hashTree>
-      <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="New Simple Product Save" enabled="true">
-        <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
-          <collectionProp name="Arguments.arguments">
-            <elementProp name="ajax" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">true</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">ajax</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="isAjax" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">true</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">isAjax</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="form_key" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">${admin_form_key}</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">form_key</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="product[name]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">Simple Product ${__time(YMDHMS)}-${__threadNum}-${__Random(1,1000000)}</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[name]</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="product[sku]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">SKU ${__time(YMDHMS)}-${__threadNum}-${__Random(1,1000000)}</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[sku]</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="product[price]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">123</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[price]</stringProp>
-            </elementProp>
-            <elementProp name="product[tax_class_id]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">2</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[tax_class_id]</stringProp>
-            </elementProp>
-            <elementProp name="product[quantity_and_stock_status][qty]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">111</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[quantity_and_stock_status][qty]</stringProp>
-            </elementProp>
-            <elementProp name="product[quantity_and_stock_status][is_in_stock]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[quantity_and_stock_status][is_in_stock]</stringProp>
-            </elementProp>
-            <elementProp name="product[weight]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1.0000</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[weight]</stringProp>
-            </elementProp>
-            <elementProp name="product[product_has_weight]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[product_has_weight]</stringProp>
-              <stringProp name="Argument.desc">true</stringProp>
-            </elementProp>
-            <elementProp name="product[category_ids][]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">2</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[category_ids][]</stringProp>
-            </elementProp>
-            <elementProp name="product[description]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">&lt;p&gt;Full simple product Description ${__time(YMDHMS)}-${__threadNum}-${__Random(1,1000000)}&lt;/p&gt;</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[description]</stringProp>
-            </elementProp>
-            <elementProp name="product[short_description]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">&lt;p&gt;Short simple product description ${__time(YMDHMS)}-${__threadNum}-${__Random(1,1000000)}&lt;/p&gt;</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[short_description]</stringProp>
-            </elementProp>
-            <elementProp name="product[status]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[status]</stringProp>
-            </elementProp>
-            <elementProp name="product[image]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[image]</stringProp>
-            </elementProp>
-            <elementProp name="product[small_image]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[small_image]</stringProp>
-            </elementProp>
-            <elementProp name="product[thumbnail]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[thumbnail]</stringProp>
-            </elementProp>
-            <elementProp name="product[url_key]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">simple-product-${__time(YMDHMS)}-${__threadNum}-${__Random(1,1000000)}</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[url_key]</stringProp>
-            </elementProp>
-            <elementProp name="product[meta_title]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">Simple Product ${__time(YMDHMS)}-${__threadNum}-${__Random(1,1000000)} Meta Title</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[meta_title]</stringProp>
-            </elementProp>
-            <elementProp name="product[meta_keyword]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">Simple Product ${__time(YMDHMS)}-${__threadNum}-${__Random(1,1000000)} Meta Keyword</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[meta_keyword]</stringProp>
-            </elementProp>
-            <elementProp name="product[meta_description]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">Simple Product ${__time(YMDHMS)}-${__threadNum}-${__Random(1,1000000)} Meta Description</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[meta_description]</stringProp>
-            </elementProp>
-            <elementProp name="product[website_ids][]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[website_ids][]</stringProp>
-            </elementProp>
-            <elementProp name="product[special_price]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">99</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[special_price]</stringProp>
-            </elementProp>
-            <elementProp name="product[special_from_date]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[special_from_date]</stringProp>
-            </elementProp>
-            <elementProp name="product[special_to_date]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[special_to_date]</stringProp>
-            </elementProp>
-            <elementProp name="product[cost]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[cost]</stringProp>
-            </elementProp>
-            <elementProp name="product[tier_price][0][website_id]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">0</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[tier_price][0][website_id]</stringProp>
-            </elementProp>
-            <elementProp name="product[tier_price][0][cust_group]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">32000</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[tier_price][0][cust_group]</stringProp>
-            </elementProp>
-            <elementProp name="product[tier_price][0][price_qty]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">100</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[tier_price][0][price_qty]</stringProp>
-            </elementProp>
-            <elementProp name="product[tier_price][0][price]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">90</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[tier_price][0][price]</stringProp>
-            </elementProp>
-            <elementProp name="product[tier_price][0][delete]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[tier_price][0][delete]</stringProp>
-            </elementProp>
-            <elementProp name="product[tier_price][1][website_id]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">0</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[tier_price][1][website_id]</stringProp>
-            </elementProp>
-            <elementProp name="product[tier_price][1][cust_group]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[tier_price][1][cust_group]</stringProp>
-            </elementProp>
-            <elementProp name="product[tier_price][1][price_qty]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">101</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[tier_price][1][price_qty]</stringProp>
-            </elementProp>
-            <elementProp name="product[tier_price][1][price]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">99</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[tier_price][1][price]</stringProp>
-            </elementProp>
-            <elementProp name="product[tier_price][1][delete]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[tier_price][1][delete]</stringProp>
-            </elementProp>
-            <elementProp name="product[stock_data][use_config_manage_stock]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[stock_data][use_config_manage_stock]</stringProp>
-            </elementProp>
-            <elementProp name="product[stock_data][original_inventory_qty]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">100500</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[stock_data][original_inventory_qty]</stringProp>
-            </elementProp>
-            <elementProp name="product[stock_data][qty]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">100500</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[stock_data][qty]</stringProp>
-            </elementProp>
-            <elementProp name="product[stock_data][min_qty]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">0</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[stock_data][min_qty]</stringProp>
-            </elementProp>
-            <elementProp name="product[stock_data][use_config_min_qty]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[stock_data][use_config_min_qty]</stringProp>
-            </elementProp>
-            <elementProp name="product[stock_data][min_sale_qty]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[stock_data][min_sale_qty]</stringProp>
-            </elementProp>
-            <elementProp name="product[stock_data][use_config_min_sale_qty]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[stock_data][use_config_min_sale_qty]</stringProp>
-            </elementProp>
-            <elementProp name="product[stock_data][max_sale_qty]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">10000</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[stock_data][max_sale_qty]</stringProp>
-            </elementProp>
-            <elementProp name="product[stock_data][use_config_max_sale_qty]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[stock_data][use_config_max_sale_qty]</stringProp>
-            </elementProp>
-            <elementProp name="product[stock_data][is_qty_decimal]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">0</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[stock_data][is_qty_decimal]</stringProp>
-            </elementProp>
-            <elementProp name="product[stock_data][is_decimal_divided]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">0</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[stock_data][is_decimal_divided]</stringProp>
-            </elementProp>
-            <elementProp name="product[stock_data][backorders]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">0</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[stock_data][backorders]</stringProp>
-            </elementProp>
-            <elementProp name="product[stock_data][use_config_backorders]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[stock_data][use_config_backorders]</stringProp>
-            </elementProp>
-            <elementProp name="product[stock_data][notify_stock_qty]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[stock_data][notify_stock_qty]</stringProp>
-            </elementProp>
-            <elementProp name="product[stock_data][use_config_notify_stock_qty]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[stock_data][use_config_notify_stock_qty]</stringProp>
-            </elementProp>
-            <elementProp name="product[stock_data][enable_qty_increments]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">0</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[stock_data][enable_qty_increments]</stringProp>
-            </elementProp>
-            <elementProp name="product[stock_data][qty_increments]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">0</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[stock_data][qty_increments]</stringProp>
-            </elementProp>
-            <elementProp name="product[stock_data][use_config_qty_increments]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[stock_data][use_config_qty_increments]</stringProp>
-            </elementProp>
-            <elementProp name="product[stock_data][is_in_stock]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[stock_data][is_in_stock]</stringProp>
-            </elementProp>
-            <elementProp name="product[custom_design]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[custom_design]</stringProp>
-            </elementProp>
-            <elementProp name="product[custom_design_from]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[custom_design_from]</stringProp>
-            </elementProp>
-            <elementProp name="product[custom_design_to]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[custom_design_to]</stringProp>
-            </elementProp>
-            <elementProp name="product[custom_layout_update]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[custom_layout_update]</stringProp>
-            </elementProp>
-            <elementProp name="product[page_layout]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[page_layout]</stringProp>
-            </elementProp>
-            <elementProp name="product[options_container]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">container2</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[options_container]</stringProp>
-            </elementProp>
-            <elementProp name="product[options][1][is_delete]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[options][1][is_delete]</stringProp>
-              <stringProp name="Argument.desc">true</stringProp>
-            </elementProp>
-            <elementProp name="product[options][1][is_require]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[options][1][is_require]</stringProp>
-            </elementProp>
-            <elementProp name="product[options][1][previous_group]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">select</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[options][1][previous_group]</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="product[options][1][previous_type]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">drop_down</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[options][1][previous_type]</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="product[options][1][sort_order]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">0</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[options][1][sort_order]</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="product[options][1][title]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">Product Option Title One</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[options][1][title]</stringProp>
-            </elementProp>
-            <elementProp name="product[options][1][type]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">drop_down</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[options][1][type]</stringProp>
-            </elementProp>
-            <elementProp name="product[options][1][values][1][is_delete]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[options][1][values][1][is_delete]</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="product[options][1][values][1][price]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">200</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[options][1][values][1][price]</stringProp>
-            </elementProp>
-            <elementProp name="product[options][1][values][1][price_type]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">fixed</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[options][1][values][1][price_type]</stringProp>
-            </elementProp>
-            <elementProp name="product[options][1][values][1][sku]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">sku-one</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[options][1][values][1][sku]</stringProp>
-            </elementProp>
-            <elementProp name="product[options][1][values][1][sort_order]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">0</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[options][1][values][1][sort_order]</stringProp>
-            </elementProp>
-            <elementProp name="product[options][1][values][1][title]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">Row Title</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[options][1][values][1][title]</stringProp>
-            </elementProp>
-            <elementProp name="product[options][2][is_delete]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[options][2][is_delete]</stringProp>
-              <stringProp name="Argument.desc">false</stringProp>
-            </elementProp>
-            <elementProp name="product[options][2][is_require]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[options][2][is_require]</stringProp>
-            </elementProp>
-            <elementProp name="product[options][2][max_characters]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">250</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[options][2][max_characters]</stringProp>
-            </elementProp>
-            <elementProp name="product[options][2][previous_group]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">text</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[options][2][previous_group]</stringProp>
-            </elementProp>
-            <elementProp name="product[options][2][previous_type]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">field</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[options][2][previous_type]</stringProp>
-            </elementProp>
-            <elementProp name="product[options][2][price]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">500</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[options][2][price]</stringProp>
-            </elementProp>
-            <elementProp name="product[options][2][price_type]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">fixed</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[options][2][price_type]</stringProp>
-            </elementProp>
-            <elementProp name="product[options][2][sku]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">sku-two</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[options][2][sku]</stringProp>
-            </elementProp>
-            <elementProp name="product[options][2][sort_order]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[options][2][sort_order]</stringProp>
-            </elementProp>
-            <elementProp name="product[options][2][title]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">Field Title</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[options][2][title]</stringProp>
-            </elementProp>
-            <elementProp name="product[options][2][type]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">field</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[options][2][type]</stringProp>
-            </elementProp>
-            <elementProp name="affect_configurable_product_attributes" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">affect_configurable_product_attributes</stringProp>
-              <stringProp name="Argument.desc">true</stringProp>
-            </elementProp>
-            <elementProp name="new-variations-attribute-set-id" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">4</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">new-variations-attribute-set-id</stringProp>
-              <stringProp name="Argument.desc">true</stringProp>
-            </elementProp>
-            <elementProp name="product[configurable_variation]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">product[configurable_variation]</stringProp>
-              <stringProp name="Argument.desc">true</stringProp>
-            </elementProp>
-            <elementProp name="links[related][0][id]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">${related_product_id}</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">links[related][0][id]</stringProp>
-            </elementProp>
-            <elementProp name="links[related][0][position]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">links[related][0][position]</stringProp>
-            </elementProp>
-            <elementProp name="links[upsell][0][id]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">${related_product_id}</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">links[upsell][0][id]</stringProp>
-            </elementProp>
-            <elementProp name="links[upsell][0][position]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">links[upsell][0][position]</stringProp>
-            </elementProp>
-            <elementProp name="links[crosssell][0][id]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">${related_product_id}</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">links[crosssell][0][id]</stringProp>
-            </elementProp>
-            <elementProp name="links[crosssell][0][position]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">links[crosssell][0][position]</stringProp>
-            </elementProp>
-          </collectionProp>
-        </elementProp>
-        <stringProp name="HTTPSampler.domain"/>
-        <stringProp name="HTTPSampler.port"/>
-        <stringProp name="HTTPSampler.connect_timeout"/>
-        <stringProp name="HTTPSampler.response_timeout"/>
-        <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
-        <stringProp name="HTTPSampler.contentEncoding"/>
-        <stringProp name="HTTPSampler.path">${base_path}${admin_path}/catalog/product/save/set/4/type/simple/back/edit/active_tab/product-details/</stringProp>
-        <stringProp name="HTTPSampler.method">POST</stringProp>
-        <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
-        <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
-        <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
-        <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
-        <boolProp name="HTTPSampler.monitor">false</boolProp>
-        <stringProp name="HTTPSampler.embedded_url_re"/>
-      </HTTPSamplerProxy>
-      <hashTree>
-        <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Response Assertion" enabled="true">
-          <collectionProp name="Asserion.test_strings">
-            <stringProp name="-583471546">You saved the product</stringProp>
-          </collectionProp>
-          <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
-          <boolProp name="Assertion.assume_success">false</boolProp>
-          <intProp name="Assertion.test_type">2</intProp>
-        </ResponseAssertion>
-        <hashTree/>
-        <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Response Assertion" enabled="true">
-          <collectionProp name="Asserion.test_strings">
-            <stringProp name="-1600986843">violation</stringProp>
-          </collectionProp>
-          <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
-          <boolProp name="Assertion.assume_success">false</boolProp>
-          <intProp name="Assertion.test_type">6</intProp>
-        </ResponseAssertion>
-        <hashTree/>
-      </hashTree>
-    </hashTree>
-  </hashTree>
-  </hashTree>
-
-  
-    <ThroughputController guiclass="ThroughputControllerGui" testclass="ThroughputController" testname="Admin Category Management" enabled="true">
-      <intProp name="ThroughputController.style">1</intProp>
-      <boolProp name="ThroughputController.perThread">false</boolProp>
-      <intProp name="ThroughputController.maxThroughput">1</intProp>
-      <stringProp name="ThroughputController.percentThroughput">${adminCategoryManagementPercentage}</stringProp>
-    <stringProp name="TestPlan.comments">mpaf/tool/fragments/_system/scenario_controller_tmpl.jmx</stringProp></ThroughputController>
-    <hashTree>
-        <JSR223PreProcessor guiclass="TestBeanGUI" testclass="JSR223PreProcessor" testname="Set Test Label" enabled="true">
-            <stringProp name="script">
-var testLabel = "${testLabel}" ? " (${testLabel})" : "";
-if (testLabel
-    &amp;&amp; sampler.getClass().getName() == 'org.apache.jmeter.protocol.http.sampler.HTTPSamplerProxy'
-) {
-    if (sampler.getName().indexOf(testLabel) == -1) {
-       sampler.setName(sampler.getName() + testLabel);
-    }
-} else if (sampler.getName().indexOf("SetUp - ") == -1) {
-    sampler.setName("SetUp - " + sampler.getName());
-}
-            </stringProp>
-            <stringProp name="scriptLanguage">javascript</stringProp>
-        <stringProp name="TestPlan.comments">mpaf/tool/fragments/_system/setup_label.jmx</stringProp></JSR223PreProcessor>
-        <hashTree/>
-        <BeanShellSampler guiclass="BeanShellSamplerGui" testclass="BeanShellSampler" testname="SetUp - Set Label" enabled="true">
-            <stringProp name="BeanShellSampler.query">
-                vars.put("testLabel", "Admin Category Management");
-            </stringProp>
-            <boolProp name="BeanShellSampler.resetInterpreter">true</boolProp>
-        </BeanShellSampler>
-        <hashTree/>
-    
-    <CookieManager guiclass="CookiePanel" testclass="CookieManager" testname="HTTP Cookie Manager" enabled="true">
-      <collectionProp name="CookieManager.cookies"/>
-      <boolProp name="CookieManager.clearEachIteration">false</boolProp>
-    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/http_cookie_manager_without_clear_each_iteration.jmx</stringProp></CookieManager>
-    <hashTree/>
-  
-    <OnceOnlyController guiclass="OnceOnlyControllerGui" testclass="OnceOnlyController" testname="Once Only Controller" enabled="true">
-  <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/once_only_controller.jmx</stringProp>
-</OnceOnlyController>
-    <hashTree>
-    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="SetUp - Login" enabled="true">
-      <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
-        <collectionProp name="Arguments.arguments"/>
-      </elementProp>
-      <stringProp name="HTTPSampler.domain"/>
-      <stringProp name="HTTPSampler.port"/>
-      <stringProp name="HTTPSampler.connect_timeout"/>
-      <stringProp name="HTTPSampler.response_timeout"/>
-      <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
-      <stringProp name="HTTPSampler.contentEncoding"/>
-      <stringProp name="HTTPSampler.path">${base_path}${admin_path}</stringProp>
-      <stringProp name="HTTPSampler.method">GET</stringProp>
-      <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
-      <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
-      <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
-      <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
-      <boolProp name="HTTPSampler.monitor">false</boolProp>
-      <stringProp name="HTTPSampler.embedded_url_re"/>
-    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_login/admin_login.jmx</stringProp></HTTPSamplerProxy>
-    <hashTree>
-      <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert login form shown" enabled="true">
-        <collectionProp name="Asserion.test_strings">
-          <stringProp name="-1397214398">Welcome</stringProp>
-          <stringProp name="-515240035">&lt;title&gt;Magento Admin&lt;/title&gt;</stringProp>
-        </collectionProp>
-        <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
-        <boolProp name="Assertion.assume_success">false</boolProp>
-        <intProp name="Assertion.test_type">2</intProp>
-      </ResponseAssertion>
-      <hashTree/>
-      <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract form key" enabled="true">
-        <stringProp name="RegexExtractor.useHeaders">false</stringProp>
-        <stringProp name="RegexExtractor.refname">admin_form_key</stringProp>
-        <stringProp name="RegexExtractor.regex">&lt;input name="form_key" type="hidden" value="([^'"]+)" /&gt;</stringProp>
-        <stringProp name="RegexExtractor.template">$1$</stringProp>
-        <stringProp name="RegexExtractor.default"/>
-        <stringProp name="RegexExtractor.match_number">1</stringProp>
-      </RegexExtractor>
-      <hashTree/>
-      <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert form_key extracted" enabled="true">
-        <collectionProp name="Asserion.test_strings">
-          <stringProp name="2845929">^.+$</stringProp>
-        </collectionProp>
-        <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
-        <boolProp name="Assertion.assume_success">false</boolProp>
-        <intProp name="Assertion.test_type">1</intProp>
-        <stringProp name="Assertion.scope">variable</stringProp>
-        <stringProp name="Scope.variable">admin_form_key</stringProp>
-      </ResponseAssertion>
-      <hashTree/>
-    </hashTree>
-  
-    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="SetUp - Login Submit Form" enabled="true">
-      <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
-        <collectionProp name="Arguments.arguments">
-          <elementProp name="dummy" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value"/>
-            <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">dummy</stringProp>
-          </elementProp>
-          <elementProp name="form_key" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">${admin_form_key}</stringProp>
-            <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">form_key</stringProp>
-          </elementProp>
-          <elementProp name="login[password]" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">${admin_password}</stringProp>
-            <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">login[password]</stringProp>
-          </elementProp>
-          <elementProp name="login[username]" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">${admin_user}</stringProp>
-            <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">login[username]</stringProp>
-          </elementProp>
-        </collectionProp>
-      </elementProp>
-      <stringProp name="HTTPSampler.domain"/>
-      <stringProp name="HTTPSampler.port"/>
-      <stringProp name="HTTPSampler.connect_timeout"/>
-      <stringProp name="HTTPSampler.response_timeout"/>
-      <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
-      <stringProp name="HTTPSampler.contentEncoding"/>
-      <stringProp name="HTTPSampler.path">${base_path}${admin_path}/admin/dashboard/</stringProp>
-      <stringProp name="HTTPSampler.method">POST</stringProp>
-      <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
-      <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
-      <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
-      <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
-      <stringProp name="HTTPSampler.implementation">Java</stringProp>
-      <boolProp name="HTTPSampler.monitor">false</boolProp>
-      <stringProp name="HTTPSampler.embedded_url_re"/>
-      <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_login/admin_login_submit_form.jmx</stringProp>
-    </HTTPSamplerProxy>
-    <hashTree>
-        <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract form key" enabled="true">
-            <stringProp name="RegexExtractor.useHeaders">false</stringProp>
-            <stringProp name="RegexExtractor.refname">admin_form_key</stringProp>
-            <stringProp name="RegexExtractor.regex">&lt;input name="form_key" type="hidden" value="([^'"]+)" /&gt;</stringProp>
-            <stringProp name="RegexExtractor.template">$1$</stringProp>
-            <stringProp name="RegexExtractor.default"/>
-            <stringProp name="RegexExtractor.match_number">1</stringProp>
-        <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_login/admin_retrieve_form_key.jmx</stringProp></RegexExtractor>
-        <hashTree/>
-    </hashTree>
-  
-    <GenericController guiclass="LogicControllerGui" testclass="GenericController" testname="SetUp - Admin Category Management" enabled="true">
-  <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/setup/setup_admin_category_management.jmx</stringProp>
-</GenericController>
-    <hashTree>
-      <BeanShellSampler guiclass="BeanShellSamplerGui" testclass="BeanShellSampler" testname="SetUp - BeanShell Sampler: Clear Admin Category Management properties" enabled="true">
-        <stringProp name="BeanShellSampler.query">props.remove("admin_category_ids_list");</stringProp>
-        <stringProp name="BeanShellSampler.filename"/>
-        <stringProp name="BeanShellSampler.parameters"/>
-        <boolProp name="BeanShellSampler.resetInterpreter">false</boolProp>
-      </BeanShellSampler>
-      <hashTree/>
-      <GenericController guiclass="LogicControllerGui" testclass="GenericController" testname="Get categories of last level" enabled="true"/>
-      <hashTree>
-        <HeaderManager guiclass="HeaderPanel" testclass="HeaderManager" testname="HTTP Header Manager" enabled="true">
-          <collectionProp name="HeaderManager.headers">
-            <elementProp name="" elementType="Header">
-              <stringProp name="Header.name">Content-Type</stringProp>
-              <stringProp name="Header.value">application/json</stringProp>
-            </elementProp>
-            <elementProp name="" elementType="Header">
-              <stringProp name="Header.name">Accept</stringProp>
-              <stringProp name="Header.value">*/*</stringProp>
-            </elementProp>
-          </collectionProp>
-        </HeaderManager>
-        <hashTree/>
-        <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="SetUp - Admin Token Retrieval" enabled="true">
-          <boolProp name="HTTPSampler.postBodyRaw">true</boolProp>
-          <elementProp name="HTTPsampler.Arguments" elementType="Arguments">
-            <collectionProp name="Arguments.arguments">
-              <elementProp name="" elementType="HTTPArgument">
-                <boolProp name="HTTPArgument.always_encode">false</boolProp>
-                <stringProp name="Argument.value">{"username":"${admin_user}","password":"${admin_password}"}</stringProp>
-                <stringProp name="Argument.metadata">=</stringProp>
-              </elementProp>
-            </collectionProp>
-          </elementProp>
-          <stringProp name="HTTPSampler.domain"/>
-          <stringProp name="HTTPSampler.port"/>
-          <stringProp name="HTTPSampler.connect_timeout"/>
-          <stringProp name="HTTPSampler.response_timeout"/>
-          <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
-          <stringProp name="HTTPSampler.contentEncoding"/>
-          <stringProp name="HTTPSampler.path">${base_path}rest/V1/integration/admin/token</stringProp>
-          <stringProp name="HTTPSampler.method">POST</stringProp>
-          <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
-          <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
-          <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
-          <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
-          <boolProp name="HTTPSampler.monitor">false</boolProp>
-          <stringProp name="HTTPSampler.embedded_url_re"/>
-        </HTTPSamplerProxy>
-        <hashTree>
-          <com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor guiclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.gui.JSONPathExtractorGui" testclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor" testname="jp@gc - JSON Path Extractor" enabled="true">
-            <stringProp name="VAR">admin_token</stringProp>
-            <stringProp name="JSONPATH">$</stringProp>
-            <stringProp name="DEFAULT"/>
-            <stringProp name="VARIABLE"/>
-            <stringProp name="SUBJECT">BODY</stringProp>
-          </com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor>
-          <hashTree/>
-          <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert token not null" enabled="true">
-            <collectionProp name="Asserion.test_strings">
-              <stringProp name="484395188">^[a-z0-9-]+$</stringProp>
-            </collectionProp>
-            <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
-            <boolProp name="Assertion.assume_success">false</boolProp>
-            <intProp name="Assertion.test_type">1</intProp>
-            <stringProp name="Assertion.scope">variable</stringProp>
-            <stringProp name="Scope.variable">admin_token</stringProp>
-          </ResponseAssertion>
-          <hashTree/>
-        </hashTree>
-        <HeaderManager guiclass="HeaderPanel" testclass="HeaderManager" testname="HTTP Header Manager" enabled="true">
-          <collectionProp name="HeaderManager.headers">
-            <elementProp name="" elementType="Header">
-              <stringProp name="Header.name">Authorization</stringProp>
-              <stringProp name="Header.value">Bearer ${admin_token}</stringProp>
-            </elementProp>
-          </collectionProp>
-        </HeaderManager>
-        <hashTree/>
-        <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="SetUp - API Get categories" enabled="true">
-          <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
-            <collectionProp name="Arguments.arguments">
-              <elementProp name="searchCriteria[filterGroups][0][filters][0][field]" elementType="HTTPArgument">
-                <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                <stringProp name="Argument.value">children_count</stringProp>
-                <stringProp name="Argument.metadata">=</stringProp>
-                <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                <stringProp name="Argument.name">searchCriteria[filterGroups][0][filters][0][field]</stringProp>
-              </elementProp>
-              <elementProp name="searchCriteria[filterGroups][0][filters][0][value]" elementType="HTTPArgument">
-                <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                <stringProp name="Argument.value">0</stringProp>
-                <stringProp name="Argument.metadata">=</stringProp>
-                <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                <stringProp name="Argument.name">searchCriteria[filterGroups][0][filters][0][value]</stringProp>
-              </elementProp>
-              <elementProp name="searchCriteria[filterGroups][1][filters][0][field]" elementType="HTTPArgument">
-                <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                <stringProp name="Argument.value">level</stringProp>
-                <stringProp name="Argument.metadata">=</stringProp>
-                <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                <stringProp name="Argument.name">searchCriteria[filterGroups][1][filters][0][field]</stringProp>
-              </elementProp>
-              <elementProp name="searchCriteria[filterGroups][1][filters][0][value]" elementType="HTTPArgument">
-                <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                <stringProp name="Argument.value">2</stringProp>
-                <stringProp name="Argument.metadata">=</stringProp>
-                <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                <stringProp name="Argument.name">searchCriteria[filterGroups][1][filters][0][value]</stringProp>
-              </elementProp>
-              <elementProp name="searchCriteria[filterGroups][1][filters][0][conditionType]" elementType="HTTPArgument">
-                <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                <stringProp name="Argument.value">gt</stringProp>
-                <stringProp name="Argument.metadata">=</stringProp>
-                <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                <stringProp name="Argument.name">searchCriteria[filterGroups][1][filters][0][conditionType]</stringProp>
-              </elementProp>
-              <elementProp name="searchCriteria[pageSize]" elementType="HTTPArgument">
-                <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                <stringProp name="Argument.value">${adminCategoryCount}</stringProp>
-                <stringProp name="Argument.metadata">=</stringProp>
-                <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                <stringProp name="Argument.name">searchCriteria[pageSize]</stringProp>
-              </elementProp>
-            </collectionProp>
-          </elementProp>
-          <stringProp name="HTTPSampler.domain"/>
-          <stringProp name="HTTPSampler.port"/>
-          <stringProp name="HTTPSampler.connect_timeout"/>
-          <stringProp name="HTTPSampler.response_timeout"/>
-          <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
-          <stringProp name="HTTPSampler.contentEncoding"/>
-          <stringProp name="HTTPSampler.path">${base_path}rest/default/V1/categories/list</stringProp>
-          <stringProp name="HTTPSampler.method">GET</stringProp>
-          <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
-          <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
-          <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
-          <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
-          <boolProp name="HTTPSampler.monitor">false</boolProp>
-          <stringProp name="HTTPSampler.embedded_url_re"/>
-        </HTTPSamplerProxy>
-        <hashTree>
-          <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Regular Expression Extractor" enabled="true">
-            <stringProp name="RegexExtractor.useHeaders">false</stringProp>
-            <stringProp name="RegexExtractor.refname">category_list_id</stringProp>
-            <stringProp name="RegexExtractor.regex">\{\"id\":(\d+),</stringProp>
-            <stringProp name="RegexExtractor.template">$1$</stringProp>
-            <stringProp name="RegexExtractor.default"/>
-            <stringProp name="RegexExtractor.match_number">-1</stringProp>
-          </RegexExtractor>
-          <hashTree/>
-        </hashTree>
-        <ForeachController guiclass="ForeachControlPanel" testclass="ForeachController" testname="ForEach Category Id" enabled="true">
-          <stringProp name="ForeachController.inputVal">category_list_id</stringProp>
-          <stringProp name="ForeachController.returnVal">category_id</stringProp>
-          <boolProp name="ForeachController.useSeparator">true</boolProp>
-        </ForeachController>
-        <hashTree>
-          <BeanShellSampler guiclass="BeanShellSamplerGui" testclass="BeanShellSampler" testname="Process categories ids" enabled="true">
-            <stringProp name="BeanShellSampler.query">import java.util.ArrayList;
-
-adminCategoryIdsList = props.get("admin_category_ids_list");
-// If it is first iteration of cycle then recreate categories ids list
-if (adminCategoryIdsList == null) {
-    adminCategoryIdsList = new ArrayList();
-    props.put("admin_category_ids_list", adminCategoryIdsList);
-}
-adminCategoryIdsList.add(vars.get("category_id"));</stringProp>
-            <stringProp name="BeanShellSampler.filename"/>
-            <stringProp name="BeanShellSampler.parameters"/>
-            <boolProp name="BeanShellSampler.resetInterpreter">false</boolProp>
-          </BeanShellSampler>
-          <hashTree/>
-        </hashTree>
-      </hashTree>
-    </hashTree>
-  </hashTree>
-  
-    <GenericController guiclass="LogicControllerGui" testclass="GenericController" testname="Simple Controller" enabled="true">
-  <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/simple_controller.jmx</stringProp>
-</GenericController>
-    <hashTree>
-    <TestFragmentController guiclass="TestFragmentControllerGui" testclass="TestFragmentController" testname="Admin Category Management" enabled="true"/>
-    <hashTree>
-      <BeanShellSampler guiclass="BeanShellSamplerGui" testclass="BeanShellSampler" testname="SetUp - Set Arguments" enabled="true">
-        <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_category_management/admin_category_management.jmx</stringProp>
-        <stringProp name="BeanShellSampler.query">import org.apache.jmeter.samplers.SampleResult;
-import java.util.ArrayList;
-import java.util.Random;
-Random random = new Random();
-if (${seedForRandom} &gt; 0) {
-random.setSeed(${seedForRandom});
-}
-number = random.nextInt(props.get("simple_products_list").size());
-simpleList = props.get("simple_products_list").get(number);
-vars.put("simple_product_1_url_key", simpleList.get("url_key"));
-vars.put("simple_product_1_name", simpleList.get("title"));
-vars.put("simple_product_1_id", simpleList.get("id"));
-
-do {
-number1 = random.nextInt(props.get("simple_products_list").size());
-} while(number == number1);
-simpleList = props.get("simple_products_list").get(number1);
-vars.put("simple_product_2_url_key", simpleList.get("url_key"));
-vars.put("simple_product_2_name", simpleList.get("title"));
-vars.put("simple_product_2_id", simpleList.get("id"));
-
-do {
-number2 = random.nextInt(props.get("simple_products_list").size());
-} while(number2 == number1 || number2 == number);
-simpleList = props.get("simple_products_list").get(number2);
-vars.put("simple_product_3_url_key", simpleList.get("url_key"));
-vars.put("simple_product_3_name", simpleList.get("title"));
-vars.put("simple_product_3_id", simpleList.get("id"));
-
-do {
-number3 = random.nextInt(props.get("simple_products_list").size());
-} while(number3 == number2 || number3 == number1 || number3 == number);
-simpleList = props.get("simple_products_list").get(number3);
-vars.put("simple_product_4_url_key", simpleList.get("url_key"));
-vars.put("simple_product_4_name", simpleList.get("title"));
-vars.put("simple_product_4_id", simpleList.get("id"));
-
-do {
-number4 = random.nextInt(props.get("simple_products_list").size());
-} while(number4 == number3 || number4 == number2 || number4 == number1 || number4 == number);
-simpleList = props.get("simple_products_list").get(number4);
-vars.put("simple_product_5_url_key", simpleList.get("url_key"));
-vars.put("simple_product_5_name", simpleList.get("title"));
-vars.put("simple_product_5_id", simpleList.get("id"));
-
-categoryIndex = random.nextInt(props.get("admin_category_ids_list").size());
-vars.put("parent_category_id", props.get("admin_category_ids_list").get(categoryIndex));
-do {
-categoryIndexNew = random.nextInt(props.get("admin_category_ids_list").size());
-} while(categoryIndex == categoryIndexNew);
-vars.put("new_parent_category_id", props.get("admin_category_ids_list").get(categoryIndexNew));</stringProp>
-        <stringProp name="BeanShellSampler.filename"/>
-        <stringProp name="BeanShellSampler.parameters"/>
-        <boolProp name="BeanShellSampler.resetInterpreter">true</boolProp>
-      </BeanShellSampler>
-      <hashTree/>
-      <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Landing Page" enabled="true">
-        <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
-          <collectionProp name="Arguments.arguments"/>
-        </elementProp>
-        <stringProp name="HTTPSampler.domain"/>
-        <stringProp name="HTTPSampler.port"/>
-        <stringProp name="HTTPSampler.connect_timeout"/>
-        <stringProp name="HTTPSampler.response_timeout"/>
-        <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
-        <stringProp name="HTTPSampler.contentEncoding"/>
-        <stringProp name="HTTPSampler.path">${base_path}${admin_path}/catalog/category/</stringProp>
-        <stringProp name="HTTPSampler.method">GET</stringProp>
-        <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
-        <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
-        <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
-        <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
-        <boolProp name="HTTPSampler.monitor">false</boolProp>
-        <stringProp name="HTTPSampler.embedded_url_re"/>
-      </HTTPSamplerProxy>
-      <hashTree>
-        <HeaderManager guiclass="HeaderPanel" testclass="HeaderManager" testname="HTTP Header Manager" enabled="true">
-          <collectionProp name="HeaderManager.headers">
-            <elementProp name="Accept-Language" elementType="Header">
-              <stringProp name="Header.name">Accept-Language</stringProp>
-              <stringProp name="Header.value">en-US,en;q=0.5</stringProp>
-            </elementProp>
-            <elementProp name="Accept" elementType="Header">
-              <stringProp name="Header.name">Accept</stringProp>
-              <stringProp name="Header.value">text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8</stringProp>
-            </elementProp>
-            <elementProp name="User-Agent" elementType="Header">
-              <stringProp name="Header.name">User-Agent</stringProp>
-              <stringProp name="Header.value">Mozilla/5.0 (Windows NT 6.1; WOW64; rv:27.0) Gecko/20100101 Firefox/27.0</stringProp>
-            </elementProp>
-            <elementProp name="Accept-Encoding" elementType="Header">
-              <stringProp name="Header.name">Accept-Encoding</stringProp>
-              <stringProp name="Header.value">gzip, deflate</stringProp>
-            </elementProp>
-          </collectionProp>
-        </HeaderManager>
-        <hashTree/>
-        <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract form key" enabled="true">
-          <stringProp name="RegexExtractor.useHeaders">false</stringProp>
-          <stringProp name="RegexExtractor.refname">admin_form_key</stringProp>
-          <stringProp name="RegexExtractor.regex">&lt;input name="form_key" type="hidden" value="([^'"]+)" /&gt;</stringProp>
-          <stringProp name="RegexExtractor.template">$1$</stringProp>
-          <stringProp name="RegexExtractor.default"/>
-          <stringProp name="RegexExtractor.match_number">1</stringProp>
-        </RegexExtractor>
-        <hashTree/>
-      </hashTree>
-      <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Select parent category" enabled="true">
-        <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
-          <collectionProp name="Arguments.arguments"/>
-        </elementProp>
-        <stringProp name="HTTPSampler.domain"/>
-        <stringProp name="HTTPSampler.port"/>
-        <stringProp name="HTTPSampler.connect_timeout"/>
-        <stringProp name="HTTPSampler.response_timeout"/>
-        <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
-        <stringProp name="HTTPSampler.contentEncoding"/>
-        <stringProp name="HTTPSampler.path">${base_path}${admin_path}/catalog/category/edit/id/${parent_category_id}/</stringProp>
-        <stringProp name="HTTPSampler.method">GET</stringProp>
-        <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
-        <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
-        <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
-        <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
-        <boolProp name="HTTPSampler.monitor">false</boolProp>
-        <stringProp name="HTTPSampler.embedded_url_re"/>
-      </HTTPSamplerProxy>
-      <hashTree>
-        <HeaderManager guiclass="HeaderPanel" testclass="HeaderManager" testname="HTTP Header Manager" enabled="true">
-          <collectionProp name="HeaderManager.headers">
-            <elementProp name="Accept-Language" elementType="Header">
-              <stringProp name="Header.name">Accept-Language</stringProp>
-              <stringProp name="Header.value">en-US,en;q=0.5</stringProp>
-            </elementProp>
-            <elementProp name="Accept" elementType="Header">
-              <stringProp name="Header.name">Accept</stringProp>
-              <stringProp name="Header.value">text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8</stringProp>
-            </elementProp>
-            <elementProp name="User-Agent" elementType="Header">
-              <stringProp name="Header.name">User-Agent</stringProp>
-              <stringProp name="Header.value">Mozilla/5.0 (Windows NT 6.1; WOW64; rv:27.0) Gecko/20100101 Firefox/27.0</stringProp>
-            </elementProp>
-            <elementProp name="Accept-Encoding" elementType="Header">
-              <stringProp name="Header.name">Accept-Encoding</stringProp>
-              <stringProp name="Header.value">gzip, deflate</stringProp>
-            </elementProp>
-          </collectionProp>
-        </HeaderManager>
-        <hashTree/>
-      </hashTree>
-      <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Open new category page" enabled="true">
-        <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
-          <collectionProp name="Arguments.arguments"/>
-        </elementProp>
-        <stringProp name="HTTPSampler.domain"/>
-        <stringProp name="HTTPSampler.port"/>
-        <stringProp name="HTTPSampler.connect_timeout"/>
-        <stringProp name="HTTPSampler.response_timeout"/>
-        <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
-        <stringProp name="HTTPSampler.contentEncoding"/>
-        <stringProp name="HTTPSampler.path">${base_path}${admin_path}/catalog/category/add/store/0/parent/${parent_category_id}</stringProp>
-        <stringProp name="HTTPSampler.method">GET</stringProp>
-        <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
-        <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
-        <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
-        <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
-        <boolProp name="HTTPSampler.monitor">false</boolProp>
-        <stringProp name="HTTPSampler.embedded_url_re"/>
-      </HTTPSamplerProxy>
-      <hashTree>
-        <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Response Assertion" enabled="true">
-          <collectionProp name="Asserion.test_strings">
-            <stringProp name="-1903925024">&lt;title&gt;New Category</stringProp>
-          </collectionProp>
-          <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
-          <boolProp name="Assertion.assume_success">false</boolProp>
-          <intProp name="Assertion.test_type">2</intProp>
-        </ResponseAssertion>
-        <hashTree/>
-      </hashTree>
-      <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Create category" enabled="true">
-        <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
-          <collectionProp name="Arguments.arguments">
-            <elementProp name="id" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">id</stringProp>
-            </elementProp>
-            <elementProp name="parent" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">${parent_category_id}</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">parent</stringProp>
-            </elementProp>
-            <elementProp name="path" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">path</stringProp>
-            </elementProp>
-            <elementProp name="store_id" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">store_id</stringProp>
-            </elementProp>
-            <elementProp name="is_active" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">0</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">is_active</stringProp>
-            </elementProp>
-            <elementProp name="include_in_menu" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">0</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">include_in_menu</stringProp>
-            </elementProp>
-            <elementProp name="is_anchor" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">is_anchor</stringProp>
-            </elementProp>
-            <elementProp name="use_config[available_sort_by]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">true</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">use_config[available_sort_by]</stringProp>
-            </elementProp>
-            <elementProp name="use_config[default_sort_by]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">true</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">use_config[default_sort_by]</stringProp>
-            </elementProp>
-            <elementProp name="use_config[filter_price_range]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">true</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">use_config[filter_price_range]</stringProp>
-            </elementProp>
-            <elementProp name="use_default[url_key]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">false</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">use_default[url_key]</stringProp>
-            </elementProp>
-            <elementProp name="url_key_create_redirect" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">0</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">url_key_create_redirect</stringProp>
-            </elementProp>
-            <elementProp name="custom_use_parent_settings" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">0</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">custom_use_parent_settings</stringProp>
-            </elementProp>
-            <elementProp name="custom_apply_to_products" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">0</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">custom_apply_to_products</stringProp>
-            </elementProp>
-            <elementProp name="name" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">Admin Category Management ${__time(YMDHMS)}-${__threadNum}-${__Random(1,1000000)}</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">name</stringProp>
-            </elementProp>
-            <elementProp name="url_key" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">admin-category-management-${__time(YMDHMS)}-${__threadNum}-${__Random(1,1000000)}</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">url_key</stringProp>
-            </elementProp>
-            <elementProp name="meta_title" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">meta_title</stringProp>
-            </elementProp>
-            <elementProp name="description" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">description</stringProp>
-            </elementProp>
-            <elementProp name="display_mode" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">PRODUCTS</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">display_mode</stringProp>
-            </elementProp>
-            <elementProp name="default_sort_by" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">position</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">default_sort_by</stringProp>
-            </elementProp>
-            <elementProp name="meta_keywords" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">meta_keywords</stringProp>
-            </elementProp>
-            <elementProp name="meta_description" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">meta_description</stringProp>
-            </elementProp>
-            <elementProp name="custom_layout_update" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">custom_layout_update</stringProp>
-            </elementProp>
-            <elementProp name="category_products" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">false</boolProp>
-              <stringProp name="Argument.value">{"${simple_product_1_id}":"","${simple_product_2_id}":"","${simple_product_3_id}":"","${simple_product_4_id}":"","${simple_product_5_id}":""}</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">category_products</stringProp>
-            </elementProp>
-            <elementProp name="form_key" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">${admin_form_key}</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">form_key</stringProp>
-            </elementProp>
-          </collectionProp>
-        </elementProp>
-        <stringProp name="HTTPSampler.domain"/>
-        <stringProp name="HTTPSampler.port"/>
-        <stringProp name="HTTPSampler.connect_timeout"/>
-        <stringProp name="HTTPSampler.response_timeout"/>
-        <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
-        <stringProp name="HTTPSampler.contentEncoding"/>
-        <stringProp name="HTTPSampler.path">${base_path}${admin_path}/catalog/category/save/</stringProp>
-        <stringProp name="HTTPSampler.method">POST</stringProp>
-        <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
-        <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
-        <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
-        <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
-        <boolProp name="HTTPSampler.monitor">false</boolProp>
-        <stringProp name="HTTPSampler.embedded_url_re"/>
-      </HTTPSamplerProxy>
-      <hashTree>
-        <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract category id" enabled="true">
-          <stringProp name="RegexExtractor.useHeaders">URL</stringProp>
-          <stringProp name="RegexExtractor.refname">admin_category_id</stringProp>
-          <stringProp name="RegexExtractor.regex">/catalog/category/edit/id/(\d+)/</stringProp>
-          <stringProp name="RegexExtractor.template">$1$</stringProp>
-          <stringProp name="RegexExtractor.default"/>
-          <stringProp name="RegexExtractor.match_number">1</stringProp>
-        </RegexExtractor>
-        <hashTree/>
-        <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert category id" enabled="true">
-          <collectionProp name="Asserion.test_strings">
-            <stringProp name="89649215">^\d+$</stringProp>
-          </collectionProp>
-          <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
-          <boolProp name="Assertion.assume_success">false</boolProp>
-          <intProp name="Assertion.test_type">1</intProp>
-          <stringProp name="Assertion.scope">variable</stringProp>
-          <stringProp name="Scope.variable">admin_category_id</stringProp>
-        </ResponseAssertion>
-        <hashTree/>
-      </hashTree>
-      <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Select created category" enabled="true">
-        <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
-          <collectionProp name="Arguments.arguments"/>
-        </elementProp>
-        <stringProp name="HTTPSampler.domain"/>
-        <stringProp name="HTTPSampler.port"/>
-        <stringProp name="HTTPSampler.connect_timeout"/>
-        <stringProp name="HTTPSampler.response_timeout"/>
-        <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
-        <stringProp name="HTTPSampler.contentEncoding"/>
-        <stringProp name="HTTPSampler.path">${base_path}${admin_path}/catalog/category/edit/id/${admin_category_id}/</stringProp>
-        <stringProp name="HTTPSampler.method">GET</stringProp>
-        <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
-        <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
-        <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
-        <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
-        <boolProp name="HTTPSampler.monitor">false</boolProp>
-        <stringProp name="HTTPSampler.embedded_url_re"/>
-      </HTTPSamplerProxy>
-      <hashTree>
-        <HeaderManager guiclass="HeaderPanel" testclass="HeaderManager" testname="HTTP Header Manager" enabled="true">
-          <collectionProp name="HeaderManager.headers">
-            <elementProp name="Accept-Language" elementType="Header">
-              <stringProp name="Header.name">Accept-Language</stringProp>
-              <stringProp name="Header.value">en-US,en;q=0.5</stringProp>
-            </elementProp>
-            <elementProp name="Accept" elementType="Header">
-              <stringProp name="Header.name">Accept</stringProp>
-              <stringProp name="Header.value">text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8</stringProp>
-            </elementProp>
-            <elementProp name="User-Agent" elementType="Header">
-              <stringProp name="Header.name">User-Agent</stringProp>
-              <stringProp name="Header.value">Mozilla/5.0 (Windows NT 6.1; WOW64; rv:27.0) Gecko/20100101 Firefox/27.0</stringProp>
-            </elementProp>
-            <elementProp name="Accept-Encoding" elementType="Header">
-              <stringProp name="Header.name">Accept-Encoding</stringProp>
-              <stringProp name="Header.value">gzip, deflate</stringProp>
-            </elementProp>
-          </collectionProp>
-        </HeaderManager>
-        <hashTree/>
-        <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract category row id" enabled="true">
-          <stringProp name="RegexExtractor.useHeaders">false</stringProp>
-          <stringProp name="RegexExtractor.refname">admin_category_entity_id</stringProp>
-          <stringProp name="RegexExtractor.regex">"entity_id":"([^"]+)"</stringProp>
-          <stringProp name="RegexExtractor.template">$1$</stringProp>
-          <stringProp name="RegexExtractor.default"/>
-          <stringProp name="RegexExtractor.match_number">1</stringProp>
-        </RegexExtractor>
-        <hashTree/>
-        <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract category attribute set id" enabled="true">
-          <stringProp name="RegexExtractor.useHeaders">false</stringProp>
-          <stringProp name="RegexExtractor.refname">admin_category_attribute_set_id</stringProp>
-          <stringProp name="RegexExtractor.regex">"attribute_set_id":"([^"]+)"</stringProp>
-          <stringProp name="RegexExtractor.template">$1$</stringProp>
-          <stringProp name="RegexExtractor.default"/>
-          <stringProp name="RegexExtractor.match_number">1</stringProp>
-        </RegexExtractor>
-        <hashTree/>
-        <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract category parent Id" enabled="true">
-          <stringProp name="RegexExtractor.useHeaders">false</stringProp>
-          <stringProp name="RegexExtractor.refname">admin_category_parent_id</stringProp>
-          <stringProp name="RegexExtractor.regex">"parent_id":"([^"]+)"</stringProp>
-          <stringProp name="RegexExtractor.template">$1$</stringProp>
-          <stringProp name="RegexExtractor.default"/>
-          <stringProp name="RegexExtractor.match_number">1</stringProp>
-        </RegexExtractor>
-        <hashTree/>
-        <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract category created at" enabled="true">
-          <stringProp name="RegexExtractor.useHeaders">false</stringProp>
-          <stringProp name="RegexExtractor.refname">admin_category_created_at</stringProp>
-          <stringProp name="RegexExtractor.regex">"created_at":"([^"]+)"</stringProp>
-          <stringProp name="RegexExtractor.template">$1$</stringProp>
-          <stringProp name="RegexExtractor.default"/>
-          <stringProp name="RegexExtractor.match_number">1</stringProp>
-        </RegexExtractor>
-        <hashTree/>
-        <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract category updated at" enabled="true">
-          <stringProp name="RegexExtractor.useHeaders">false</stringProp>
-          <stringProp name="RegexExtractor.refname">admin_category_updated_at</stringProp>
-          <stringProp name="RegexExtractor.regex">"updated_at":"([^"]+)"</stringProp>
-          <stringProp name="RegexExtractor.template">$1$</stringProp>
-          <stringProp name="RegexExtractor.default"/>
-          <stringProp name="RegexExtractor.match_number">1</stringProp>
-        </RegexExtractor>
-        <hashTree/>
-        <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract category path" enabled="true">
-          <stringProp name="RegexExtractor.useHeaders">false</stringProp>
-          <stringProp name="RegexExtractor.refname">admin_category_path</stringProp>
-          <stringProp name="RegexExtractor.regex">"entity_id":(.+)"path":"([^\"]+)"</stringProp>
-          <stringProp name="RegexExtractor.template">$2$</stringProp>
-          <stringProp name="RegexExtractor.default"/>
-          <stringProp name="RegexExtractor.match_number">1</stringProp>
-        </RegexExtractor>
-        <hashTree/>
-        <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract category level" enabled="true">
-          <stringProp name="RegexExtractor.useHeaders">false</stringProp>
-          <stringProp name="RegexExtractor.refname">admin_category_level</stringProp>
-          <stringProp name="RegexExtractor.regex">"level":"([^"]+)"</stringProp>
-          <stringProp name="RegexExtractor.template">$1$</stringProp>
-          <stringProp name="RegexExtractor.default"/>
-          <stringProp name="RegexExtractor.match_number">1</stringProp>
-        </RegexExtractor>
-        <hashTree/>
-        <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract category name" enabled="true">
-          <stringProp name="RegexExtractor.useHeaders">false</stringProp>
-          <stringProp name="RegexExtractor.refname">admin_category_name</stringProp>
-          <stringProp name="RegexExtractor.regex">"entity_id":(.+)"name":"([^"]+)"</stringProp>
-          <stringProp name="RegexExtractor.template">$2$</stringProp>
-          <stringProp name="RegexExtractor.default"/>
-          <stringProp name="RegexExtractor.match_number">1</stringProp>
-        </RegexExtractor>
-        <hashTree/>
-        <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract category url key" enabled="true">
-          <stringProp name="RegexExtractor.useHeaders">false</stringProp>
-          <stringProp name="RegexExtractor.refname">admin_category_url_key</stringProp>
-          <stringProp name="RegexExtractor.regex">"url_key":"([^"]+)"</stringProp>
-          <stringProp name="RegexExtractor.template">$1$</stringProp>
-          <stringProp name="RegexExtractor.default"/>
-          <stringProp name="RegexExtractor.match_number">1</stringProp>
-        </RegexExtractor>
-        <hashTree/>
-        <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract category url path" enabled="true">
-          <stringProp name="RegexExtractor.useHeaders">false</stringProp>
-          <stringProp name="RegexExtractor.refname">admin_category_url_path</stringProp>
-          <stringProp name="RegexExtractor.regex">"url_path":"([^"]+)"</stringProp>
-          <stringProp name="RegexExtractor.template">$1$</stringProp>
-          <stringProp name="RegexExtractor.default"/>
-          <stringProp name="RegexExtractor.match_number">1</stringProp>
-        </RegexExtractor>
-        <hashTree/>
-        <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert category row id" enabled="true">
-          <collectionProp name="Asserion.test_strings">
-            <stringProp name="89649215">^\d+$</stringProp>
-          </collectionProp>
-          <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
-          <boolProp name="Assertion.assume_success">false</boolProp>
-          <intProp name="Assertion.test_type">1</intProp>
-          <stringProp name="Assertion.scope">variable</stringProp>
-          <stringProp name="Scope.variable">admin_category_entity_id</stringProp>
-        </ResponseAssertion>
-        <hashTree/>
-        <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert category attribute set id" enabled="true">
-          <collectionProp name="Asserion.test_strings">
-            <stringProp name="89649215">^\d+$</stringProp>
-          </collectionProp>
-          <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
-          <boolProp name="Assertion.assume_success">false</boolProp>
-          <intProp name="Assertion.test_type">1</intProp>
-          <stringProp name="Assertion.scope">variable</stringProp>
-          <stringProp name="Scope.variable">admin_category_attribute_set_id</stringProp>
-        </ResponseAssertion>
-        <hashTree/>
-        <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert category parent id" enabled="true">
-          <collectionProp name="Asserion.test_strings">
-            <stringProp name="89649215">^\d+$</stringProp>
-          </collectionProp>
-          <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
-          <boolProp name="Assertion.assume_success">false</boolProp>
-          <intProp name="Assertion.test_type">1</intProp>
-          <stringProp name="Assertion.scope">variable</stringProp>
-          <stringProp name="Scope.variable">admin_category_parent_id</stringProp>
-        </ResponseAssertion>
-        <hashTree/>
-        <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert category created at" enabled="true">
-          <collectionProp name="Asserion.test_strings">
-            <stringProp name="2845929">^.+$</stringProp>
-          </collectionProp>
-          <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
-          <boolProp name="Assertion.assume_success">false</boolProp>
-          <intProp name="Assertion.test_type">1</intProp>
-          <stringProp name="Assertion.scope">variable</stringProp>
-          <stringProp name="Scope.variable">admin_category_created_at</stringProp>
-        </ResponseAssertion>
-        <hashTree/>
-        <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert category updated at" enabled="true">
-          <collectionProp name="Asserion.test_strings">
-            <stringProp name="2845929">^.+$</stringProp>
-          </collectionProp>
-          <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
-          <boolProp name="Assertion.assume_success">false</boolProp>
-          <intProp name="Assertion.test_type">1</intProp>
-          <stringProp name="Assertion.scope">variable</stringProp>
-          <stringProp name="Scope.variable">admin_category_updated_at</stringProp>
-        </ResponseAssertion>
-        <hashTree/>
-        <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert category path" enabled="true">
-          <collectionProp name="Asserion.test_strings">
-            <stringProp name="59022110">^[\d\\\/]+$</stringProp>
-          </collectionProp>
-          <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
-          <boolProp name="Assertion.assume_success">false</boolProp>
-          <intProp name="Assertion.test_type">1</intProp>
-          <stringProp name="Assertion.scope">variable</stringProp>
-          <stringProp name="Scope.variable">admin_category_path</stringProp>
-        </ResponseAssertion>
-        <hashTree/>
-        <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert category level" enabled="true">
-          <collectionProp name="Asserion.test_strings">
-            <stringProp name="89649215">^\d+$</stringProp>
-          </collectionProp>
-          <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
-          <boolProp name="Assertion.assume_success">false</boolProp>
-          <intProp name="Assertion.test_type">1</intProp>
-          <stringProp name="Assertion.scope">variable</stringProp>
-          <stringProp name="Scope.variable">admin_category_level</stringProp>
-        </ResponseAssertion>
-        <hashTree/>
-        <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert category name" enabled="true">
-          <collectionProp name="Asserion.test_strings">
-            <stringProp name="2845929">^.+$</stringProp>
-          </collectionProp>
-          <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
-          <boolProp name="Assertion.assume_success">false</boolProp>
-          <intProp name="Assertion.test_type">1</intProp>
-          <stringProp name="Assertion.scope">variable</stringProp>
-          <stringProp name="Scope.variable">admin_category_name</stringProp>
-        </ResponseAssertion>
-        <hashTree/>
-        <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert category url key" enabled="true">
-          <collectionProp name="Asserion.test_strings">
-            <stringProp name="2845929">^.+$</stringProp>
-          </collectionProp>
-          <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
-          <boolProp name="Assertion.assume_success">false</boolProp>
-          <intProp name="Assertion.test_type">1</intProp>
-          <stringProp name="Assertion.scope">variable</stringProp>
-          <stringProp name="Scope.variable">admin_category_url_key</stringProp>
-        </ResponseAssertion>
-        <hashTree/>
-        <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert category url path" enabled="true">
-          <collectionProp name="Asserion.test_strings">
-            <stringProp name="2845929">^.+$</stringProp>
-          </collectionProp>
-          <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
-          <boolProp name="Assertion.assume_success">false</boolProp>
-          <intProp name="Assertion.test_type">1</intProp>
-          <stringProp name="Assertion.scope">variable</stringProp>
-          <stringProp name="Scope.variable">admin_category_url_path</stringProp>
-        </ResponseAssertion>
-        <hashTree/>
-          <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert products added" enabled="true">
-            <collectionProp name="Asserion.test_strings">
-              <stringProp name="417284990">${simple_product_1_name}</stringProp>
-              <stringProp name="1304788671">${simple_product_2_name}</stringProp>
-              <stringProp name="-2102674944">${simple_product_3_name}</stringProp>
-              <stringProp name="-1215171263">${simple_product_4_name}</stringProp>
-              <stringProp name="-327667582">${simple_product_5_name}</stringProp>
-            </collectionProp>
-            <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
-            <boolProp name="Assertion.assume_success">false</boolProp>
-            <intProp name="Assertion.test_type">2</intProp>
-          </ResponseAssertion>
-          <hashTree/>
-      </hashTree>
-      <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Move category" enabled="true">
-        <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
-          <collectionProp name="Arguments.arguments">
-            <elementProp name="id" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">${admin_category_id}</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">id</stringProp>
-            </elementProp>
-            <elementProp name="form_key" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">${admin_form_key}</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">form_key</stringProp>
-            </elementProp>
-            <elementProp name="point" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">append</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">point</stringProp>
-            </elementProp>
-            <elementProp name="pid" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">${new_parent_category_id}</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">pid</stringProp>
-            </elementProp>
-            <elementProp name="paid" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">${parent_category_id}</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">paid</stringProp>
-            </elementProp>
-            <elementProp name="aid" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">0</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">aid</stringProp>
-            </elementProp>
-            <elementProp name="isAjax" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">true</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">isAjax</stringProp>
-            </elementProp>
-          </collectionProp>
-        </elementProp>
-        <stringProp name="HTTPSampler.domain"/>
-        <stringProp name="HTTPSampler.port"/>
-        <stringProp name="HTTPSampler.connect_timeout"/>
-        <stringProp name="HTTPSampler.response_timeout"/>
-        <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
-        <stringProp name="HTTPSampler.contentEncoding"/>
-        <stringProp name="HTTPSampler.path">${base_path}${admin_path}/catalog/category/move/</stringProp>
-        <stringProp name="HTTPSampler.method">POST</stringProp>
-        <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
-        <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
-        <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
-        <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
-        <boolProp name="HTTPSampler.monitor">false</boolProp>
-        <stringProp name="HTTPSampler.embedded_url_re"/>
-      </HTTPSamplerProxy>
-      <hashTree/>
-      <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Delete category" enabled="true">
-        <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
-          <collectionProp name="Arguments.arguments"/>
-        </elementProp>
-        <stringProp name="HTTPSampler.domain"/>
-        <stringProp name="HTTPSampler.port"/>
-        <stringProp name="HTTPSampler.connect_timeout"/>
-        <stringProp name="HTTPSampler.response_timeout"/>
-        <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
-        <stringProp name="HTTPSampler.contentEncoding"/>
-        <stringProp name="HTTPSampler.path">${base_path}${admin_path}/catalog/category/delete/id/${admin_category_id}/</stringProp>
-        <stringProp name="HTTPSampler.method">GET</stringProp>
-        <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
-        <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
-        <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
-        <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
-        <boolProp name="HTTPSampler.monitor">false</boolProp>
-        <stringProp name="HTTPSampler.embedded_url_re"/>
-      </HTTPSamplerProxy>
-      <hashTree>
-        <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert category deleted" enabled="true">
-          <collectionProp name="Asserion.test_strings">
-            <stringProp name="1277069529">You deleted the category.</stringProp>
-          </collectionProp>
-          <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
-          <boolProp name="Assertion.assume_success">false</boolProp>
-          <intProp name="Assertion.test_type">2</intProp>
-        </ResponseAssertion>
-        <hashTree/>
-      </hashTree>
-      <TestAction guiclass="TestActionGui" testclass="TestAction" testname="Pause" enabled="true">
-        <intProp name="ActionProcessor.action">1</intProp>
-        <intProp name="ActionProcessor.target">0</intProp>
-        <stringProp name="ActionProcessor.duration">${__javaScript(Math.round(${adminCategoryManagementDelay}*1000))}</stringProp>
-      </TestAction>
-      <hashTree/>
-    </hashTree>
-  </hashTree>
-  </hashTree>
-
-  
-    <ThroughputController guiclass="ThroughputControllerGui" testclass="ThroughputController" testname="Admin Promotion Rules" enabled="true">
-      <intProp name="ThroughputController.style">1</intProp>
-      <boolProp name="ThroughputController.perThread">false</boolProp>
-      <intProp name="ThroughputController.maxThroughput">1</intProp>
-      <stringProp name="ThroughputController.percentThroughput">${adminPromotionRulesPercentage}</stringProp>
-    <stringProp name="TestPlan.comments">mpaf/tool/fragments/_system/scenario_controller_tmpl.jmx</stringProp></ThroughputController>
-    <hashTree>
-        <JSR223PreProcessor guiclass="TestBeanGUI" testclass="JSR223PreProcessor" testname="Set Test Label" enabled="true">
-            <stringProp name="script">
-var testLabel = "${testLabel}" ? " (${testLabel})" : "";
-if (testLabel
-    &amp;&amp; sampler.getClass().getName() == 'org.apache.jmeter.protocol.http.sampler.HTTPSamplerProxy'
-) {
-    if (sampler.getName().indexOf(testLabel) == -1) {
-       sampler.setName(sampler.getName() + testLabel);
-    }
-} else if (sampler.getName().indexOf("SetUp - ") == -1) {
-    sampler.setName("SetUp - " + sampler.getName());
-}
-            </stringProp>
-            <stringProp name="scriptLanguage">javascript</stringProp>
-        <stringProp name="TestPlan.comments">mpaf/tool/fragments/_system/setup_label.jmx</stringProp></JSR223PreProcessor>
-        <hashTree/>
-        <BeanShellSampler guiclass="BeanShellSamplerGui" testclass="BeanShellSampler" testname="SetUp - Set Label" enabled="true">
-            <stringProp name="BeanShellSampler.query">
-                vars.put("testLabel", "Admin Promotion Rules");
-            </stringProp>
-            <boolProp name="BeanShellSampler.resetInterpreter">true</boolProp>
-        </BeanShellSampler>
-        <hashTree/>
-    
-        <JSR223PostProcessor guiclass="TestBeanGUI" testclass="JSR223PostProcessor" testname="Get admin form key PostProcessor" enabled="true">
-        <stringProp name="script">
-        function getFormKeyFromResponse()
-        {
-            var url = prev.getUrlAsString(),
-            responseCode =  prev.getResponseCode(),
-            formKey = null;
-            searchPattern = /var FORM_KEY = '(.+)'/;
-            if (responseCode == "200" &amp;&amp; url) {
-                response = prev.getResponseDataAsString();
-                formKey = response  &amp;&amp; response.match(searchPattern) ? response.match(searchPattern)[1] : null;
-            }
-            return formKey;
-        }
-
-        formKey = vars.get("form_key_storage");
-
-	   currentFormKey = getFormKeyFromResponse();
-
-	   if (currentFormKey != null &amp;&amp; currentFormKey != formKey) {
-		  vars.put("form_key_storage", currentFormKey);
-	   }
-        </stringProp>
-        <stringProp name="scriptLanguage">javascript</stringProp>
-        <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin/handle_admin_form_key.jmx</stringProp></JSR223PostProcessor>
-        <hashTree/>
-        <JSR223PreProcessor guiclass="TestBeanGUI" testclass="JSR223PreProcessor" testname="Set admin form key PreProcessor" enabled="true">
-            <stringProp name="script">
-                formKey =  vars.get("form_key_storage");
-                if (formKey
-                    &amp;&amp; sampler.getClass().getName() == 'org.apache.jmeter.protocol.http.sampler.HTTPSamplerProxy'
-                    &amp;&amp; sampler.getMethod() == "POST")
-                    {
-                        arguments = sampler.getArguments();
-                        for (i=0; i&lt;arguments.getArgumentCount(); i++)
-                        {
-                            argument = arguments.getArgument(i);
-                            if (argument.getName() == 'form_key' &amp;&amp; argument.getValue() != formKey) {
-                            log.info("admin form key updated: " + argument.getValue() + " =&gt; " + formKey);
-                            argument.setValue(formKey);
-                        }
-                    }
-                }
-            </stringProp>
-            <stringProp name="scriptLanguage">javascript</stringProp>
-        </JSR223PreProcessor>
-        <hashTree/>
-    
-    <CookieManager guiclass="CookiePanel" testclass="CookieManager" testname="HTTP Cookie Manager" enabled="true">
-      <collectionProp name="CookieManager.cookies"/>
-      <boolProp name="CookieManager.clearEachIteration">false</boolProp>
-    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/http_cookie_manager_without_clear_each_iteration.jmx</stringProp></CookieManager>
-    <hashTree/>
-  
-    <OnceOnlyController guiclass="OnceOnlyControllerGui" testclass="OnceOnlyController" testname="Once Only Controller" enabled="true">
-  <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/once_only_controller.jmx</stringProp>
-</OnceOnlyController>
-    <hashTree>
-    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="SetUp - Login" enabled="true">
-      <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
-        <collectionProp name="Arguments.arguments"/>
-      </elementProp>
-      <stringProp name="HTTPSampler.domain"/>
-      <stringProp name="HTTPSampler.port"/>
-      <stringProp name="HTTPSampler.connect_timeout"/>
-      <stringProp name="HTTPSampler.response_timeout"/>
-      <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
-      <stringProp name="HTTPSampler.contentEncoding"/>
-      <stringProp name="HTTPSampler.path">${base_path}${admin_path}</stringProp>
-      <stringProp name="HTTPSampler.method">GET</stringProp>
-      <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
-      <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
-      <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
-      <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
-      <boolProp name="HTTPSampler.monitor">false</boolProp>
-      <stringProp name="HTTPSampler.embedded_url_re"/>
-    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_login/admin_login.jmx</stringProp></HTTPSamplerProxy>
-    <hashTree>
-      <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert login form shown" enabled="true">
-        <collectionProp name="Asserion.test_strings">
-          <stringProp name="-1397214398">Welcome</stringProp>
-          <stringProp name="-515240035">&lt;title&gt;Magento Admin&lt;/title&gt;</stringProp>
-        </collectionProp>
-        <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
-        <boolProp name="Assertion.assume_success">false</boolProp>
-        <intProp name="Assertion.test_type">2</intProp>
-      </ResponseAssertion>
-      <hashTree/>
-      <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract form key" enabled="true">
-        <stringProp name="RegexExtractor.useHeaders">false</stringProp>
-        <stringProp name="RegexExtractor.refname">admin_form_key</stringProp>
-        <stringProp name="RegexExtractor.regex">&lt;input name="form_key" type="hidden" value="([^'"]+)" /&gt;</stringProp>
-        <stringProp name="RegexExtractor.template">$1$</stringProp>
-        <stringProp name="RegexExtractor.default"/>
-        <stringProp name="RegexExtractor.match_number">1</stringProp>
-      </RegexExtractor>
-      <hashTree/>
-      <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert form_key extracted" enabled="true">
-        <collectionProp name="Asserion.test_strings">
-          <stringProp name="2845929">^.+$</stringProp>
-        </collectionProp>
-        <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
-        <boolProp name="Assertion.assume_success">false</boolProp>
-        <intProp name="Assertion.test_type">1</intProp>
-        <stringProp name="Assertion.scope">variable</stringProp>
-        <stringProp name="Scope.variable">admin_form_key</stringProp>
-      </ResponseAssertion>
-      <hashTree/>
-    </hashTree>
-  
-    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="SetUp - Login Submit Form" enabled="true">
-      <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
-        <collectionProp name="Arguments.arguments">
-          <elementProp name="dummy" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value"/>
-            <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">dummy</stringProp>
-          </elementProp>
-          <elementProp name="form_key" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">${admin_form_key}</stringProp>
-            <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">form_key</stringProp>
-          </elementProp>
-          <elementProp name="login[password]" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">${admin_password}</stringProp>
-            <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">login[password]</stringProp>
-          </elementProp>
-          <elementProp name="login[username]" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">${admin_user}</stringProp>
-            <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">login[username]</stringProp>
-          </elementProp>
-        </collectionProp>
-      </elementProp>
-      <stringProp name="HTTPSampler.domain"/>
-      <stringProp name="HTTPSampler.port"/>
-      <stringProp name="HTTPSampler.connect_timeout"/>
-      <stringProp name="HTTPSampler.response_timeout"/>
-      <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
-      <stringProp name="HTTPSampler.contentEncoding"/>
-      <stringProp name="HTTPSampler.path">${base_path}${admin_path}/admin/dashboard/</stringProp>
-      <stringProp name="HTTPSampler.method">POST</stringProp>
-      <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
-      <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
-      <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
-      <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
-      <stringProp name="HTTPSampler.implementation">Java</stringProp>
-      <boolProp name="HTTPSampler.monitor">false</boolProp>
-      <stringProp name="HTTPSampler.embedded_url_re"/>
-      <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_login/admin_login_submit_form.jmx</stringProp>
-    </HTTPSamplerProxy>
-    <hashTree>
-        <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract form key" enabled="true">
-            <stringProp name="RegexExtractor.useHeaders">false</stringProp>
-            <stringProp name="RegexExtractor.refname">admin_form_key</stringProp>
-            <stringProp name="RegexExtractor.regex">&lt;input name="form_key" type="hidden" value="([^'"]+)" /&gt;</stringProp>
-            <stringProp name="RegexExtractor.template">$1$</stringProp>
-            <stringProp name="RegexExtractor.default"/>
-            <stringProp name="RegexExtractor.match_number">1</stringProp>
-        <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_login/admin_retrieve_form_key.jmx</stringProp></RegexExtractor>
-        <hashTree/>
-    </hashTree>
-  </hashTree>
-  
-    <GenericController guiclass="LogicControllerGui" testclass="GenericController" testname="Simple Controller" enabled="true">
-  <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/simple_controller.jmx</stringProp>
-</GenericController>
-    <hashTree>
-    <TestFragmentController guiclass="TestFragmentControllerGui" testclass="TestFragmentController" testname="Admin Promotions Management" enabled="true">
-  <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_promotions_management/admin_promotions_management.jmx</stringProp>
-</TestFragmentController>
-    <hashTree>
-      <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Landing Page" enabled="true">
-        <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
-          <collectionProp name="Arguments.arguments"/>
-        </elementProp>
-        <stringProp name="HTTPSampler.domain"/>
-        <stringProp name="HTTPSampler.port"/>
-        <stringProp name="HTTPSampler.connect_timeout"/>
-        <stringProp name="HTTPSampler.response_timeout"/>
-        <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
-        <stringProp name="HTTPSampler.contentEncoding"/>
-        <stringProp name="HTTPSampler.path">${base_path}${admin_path}/sales_rule/promo_quote/</stringProp>
-        <stringProp name="HTTPSampler.method">GET</stringProp>
-        <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
-        <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
-        <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
-        <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
-        <boolProp name="HTTPSampler.monitor">false</boolProp>
-        <stringProp name="HTTPSampler.embedded_url_re"/>
-      </HTTPSamplerProxy>
-      <hashTree/>
-      <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Create New" enabled="true">
-        <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
-          <collectionProp name="Arguments.arguments"/>
-        </elementProp>
-        <stringProp name="HTTPSampler.domain"/>
-        <stringProp name="HTTPSampler.port"/>
-        <stringProp name="HTTPSampler.connect_timeout"/>
-        <stringProp name="HTTPSampler.response_timeout"/>
-        <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
-        <stringProp name="HTTPSampler.contentEncoding"/>
-        <stringProp name="HTTPSampler.path">${base_path}${admin_path}/sales_rule/promo_quote/new</stringProp>
-        <stringProp name="HTTPSampler.method">GET</stringProp>
-        <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
-        <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
-        <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
-        <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
-        <boolProp name="HTTPSampler.monitor">false</boolProp>
-        <stringProp name="HTTPSampler.embedded_url_re"/>
-      </HTTPSamplerProxy>
-      <hashTree/>
-      <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Create New Conditional" enabled="true">
-        <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
-          <collectionProp name="Arguments.arguments">
-            <elementProp name="isAjax" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">true</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">isAjax</stringProp>
-            </elementProp>
-            <elementProp name="form_key" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">${admin_form_key}</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">form_key</stringProp>
-              <stringProp name="Argument.desc">true</stringProp>
-            </elementProp>
-            <elementProp name="id" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1--1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">id</stringProp>
-            </elementProp>
-            <elementProp name="type" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">Magento\SalesRule\Model\Rule\Condition\Address|base_subtotal</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">type</stringProp>
-            </elementProp>
-          </collectionProp>
-        </elementProp>
-        <stringProp name="HTTPSampler.domain"/>
-        <stringProp name="HTTPSampler.port"/>
-        <stringProp name="HTTPSampler.connect_timeout"/>
-        <stringProp name="HTTPSampler.response_timeout"/>
-        <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
-        <stringProp name="HTTPSampler.contentEncoding"/>
-        <stringProp name="HTTPSampler.path">${base_path}${admin_path}/sales_rule/promo_quote/newConditionHtml/form/sales_rule_formrule_conditions_fieldset_/form_namespace/sales_rule_form</stringProp>
-        <stringProp name="HTTPSampler.method">POST</stringProp>
-        <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
-        <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
-        <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
-        <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
-        <boolProp name="HTTPSampler.monitor">false</boolProp>
-        <stringProp name="HTTPSampler.embedded_url_re"/>
-      </HTTPSamplerProxy>
-      <hashTree/>
-      <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Save" enabled="true">
-        <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
-          <collectionProp name="Arguments.arguments">
-            <elementProp name="name" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">Rule Name ${__time(YMDHMS)}-${__threadNum}-${__Random(1,1000000)}</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">name</stringProp>
-            </elementProp>
-            <elementProp name="is_active" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">0</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">is_active</stringProp>
-            </elementProp>
-            <elementProp name="use_auto_generation" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">0</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">use_auto_generation</stringProp>
-            </elementProp>
-            <elementProp name="is_rss" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">is_rss</stringProp>
-            </elementProp>
-            <elementProp name="apply_to_shipping" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">0</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">apply_to_shipping</stringProp>
-            </elementProp>
-            <elementProp name="stop_rules_processing" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">0</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">stop_rules_processing</stringProp>
-            </elementProp>
-            <elementProp name="coupon_code" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">coupon_code</stringProp>
-            </elementProp>
-            <elementProp name="uses_per_coupon" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">uses_per_coupon</stringProp>
-            </elementProp>
-            <elementProp name="uses_per_customer" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">uses_per_customer</stringProp>
-            </elementProp>
-            <elementProp name="sort_order" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">sort_order</stringProp>
-            </elementProp>
-            <elementProp name="discount_amount" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">5</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">discount_amount</stringProp>
-            </elementProp>
-            <elementProp name="discount_qty" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">0</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">discount_qty</stringProp>
-            </elementProp>
-            <elementProp name="discount_step" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">discount_step</stringProp>
-            </elementProp>
-            <elementProp name="reward_points_delta" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">reward_points_delta</stringProp>
-            </elementProp>
-            <elementProp name="store_labels[0]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">store_labels[0]</stringProp>
-            </elementProp>
-            <elementProp name="description" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">Rule Description ${__time(YMDHMS)}-${__threadNum}-${__Random(1,1000000)}</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">description</stringProp>
-            </elementProp>
-            <elementProp name="coupon_type" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">coupon_type</stringProp>
-            </elementProp>
-            <elementProp name="simple_action" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">cart_fixed</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">simple_action</stringProp>
-            </elementProp>
-            <elementProp name="website_ids[0]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">website_ids[0]</stringProp>
-            </elementProp>
-            <elementProp name="customer_group_ids[0]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">0</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">customer_group_ids[0]</stringProp>
-            </elementProp>
-            <elementProp name="from_date" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">from_date</stringProp>
-            </elementProp>
-            <elementProp name="to_date" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">to_date</stringProp>
-            </elementProp>
-            <elementProp name="rule[conditions][1][type]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">Magento\SalesRule\Model\Rule\Condition\Combine</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">rule[conditions][1][type]</stringProp>
-            </elementProp>
-            <elementProp name="rule[conditions][1][aggregator]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">all</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">rule[conditions][1][aggregator]</stringProp>
-            </elementProp>
-            <elementProp name="rule[conditions][1][value]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">rule[conditions][1][value]</stringProp>
-            </elementProp>
-            <elementProp name="rule[conditions][1--1][type]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">Magento\SalesRule\Model\Rule\Condition\Address</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">rule[conditions][1--1][type]</stringProp>
-            </elementProp>
-            <elementProp name="rule[conditions][1--1][attribute]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">base_subtotal</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">rule[conditions][1--1][attribute]</stringProp>
-            </elementProp>
-            <elementProp name="rule[conditions][1--1][operator]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">&gt;=</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">rule[conditions][1--1][operator]</stringProp>
-            </elementProp>
-            <elementProp name="rule[conditions][1--1][value]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">100</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">rule[conditions][1--1][value]</stringProp>
-            </elementProp>
-            <elementProp name="rule[conditions][1][new_chlid]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">rule[conditions][1][new_chlid]</stringProp>
-            </elementProp>
-            <elementProp name="rule[actions][1][type]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">Magento\SalesRule\Model\Rule\Condition\Product\Combine</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">rule[actions][1][type]</stringProp>
-            </elementProp>
-            <elementProp name="rule[actions][1][aggregator]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">all</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">rule[actions][1][aggregator]</stringProp>
-            </elementProp>
-            <elementProp name="rule[actions][1][value]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">rule[actions][1][value]</stringProp>
-            </elementProp>
-            <elementProp name="rule[actions][1][new_child]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">rule[actions][1][new_child]</stringProp>
-            </elementProp>
-            <elementProp name="store_labels[1]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">store_labels[1]</stringProp>
-            </elementProp>
-            <elementProp name="store_labels[2]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">store_labels[2]</stringProp>
-            </elementProp>
-            <elementProp name="related_banners" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">related_banners</stringProp>
-            </elementProp>
-            <elementProp name="form_key" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">${admin_form_key}</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">form_key</stringProp>
-            </elementProp>
-          </collectionProp>
-        </elementProp>
-        <stringProp name="HTTPSampler.domain"/>
-        <stringProp name="HTTPSampler.port"/>
-        <stringProp name="HTTPSampler.connect_timeout"/>
-        <stringProp name="HTTPSampler.response_timeout"/>
-        <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
-        <stringProp name="HTTPSampler.contentEncoding"/>
-        <stringProp name="HTTPSampler.path">${base_path}${admin_path}/sales_rule/promo_quote/save/</stringProp>
-        <stringProp name="HTTPSampler.method">POST</stringProp>
-        <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
-        <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
-        <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
-        <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
-        <boolProp name="HTTPSampler.monitor">false</boolProp>
-        <stringProp name="HTTPSampler.embedded_url_re"/>
-      </HTTPSamplerProxy>
-      <hashTree>
-        <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Response Assertion" enabled="true">
-          <collectionProp name="Asserion.test_strings">
-            <stringProp name="-396438583">You saved the rule.</stringProp>
-          </collectionProp>
-          <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
-          <boolProp name="Assertion.assume_success">false</boolProp>
-          <intProp name="Assertion.test_type">16</intProp>
-        </ResponseAssertion>
-        <hashTree/>
-      </hashTree>
-      <TestAction guiclass="TestActionGui" testclass="TestAction" testname="Pause" enabled="true">
-        <intProp name="ActionProcessor.action">1</intProp>
-        <intProp name="ActionProcessor.target">0</intProp>
-        <stringProp name="ActionProcessor.duration">${__javaScript(Math.round(${adminPromotionsManagementDelay}*1000))}</stringProp>
-      </TestAction>
-      <hashTree/>
-    </hashTree>
-  </hashTree>
-  </hashTree>
-
-  
-    <ThroughputController guiclass="ThroughputControllerGui" testclass="ThroughputController" testname="Admin Edit Order" enabled="true">
-      <intProp name="ThroughputController.style">1</intProp>
-      <boolProp name="ThroughputController.perThread">false</boolProp>
-      <intProp name="ThroughputController.maxThroughput">1</intProp>
-      <stringProp name="ThroughputController.percentThroughput">${adminEditOrderPercentage}</stringProp>
-    <stringProp name="TestPlan.comments">mpaf/tool/fragments/_system/scenario_controller_tmpl.jmx</stringProp></ThroughputController>
-    <hashTree>
-        <JSR223PreProcessor guiclass="TestBeanGUI" testclass="JSR223PreProcessor" testname="Set Test Label" enabled="true">
-            <stringProp name="script">
-var testLabel = "${testLabel}" ? " (${testLabel})" : "";
-if (testLabel
-    &amp;&amp; sampler.getClass().getName() == 'org.apache.jmeter.protocol.http.sampler.HTTPSamplerProxy'
-) {
-    if (sampler.getName().indexOf(testLabel) == -1) {
-       sampler.setName(sampler.getName() + testLabel);
-    }
-} else if (sampler.getName().indexOf("SetUp - ") == -1) {
-    sampler.setName("SetUp - " + sampler.getName());
-}
-            </stringProp>
-            <stringProp name="scriptLanguage">javascript</stringProp>
-        <stringProp name="TestPlan.comments">mpaf/tool/fragments/_system/setup_label.jmx</stringProp></JSR223PreProcessor>
-        <hashTree/>
-        <BeanShellSampler guiclass="BeanShellSamplerGui" testclass="BeanShellSampler" testname="SetUp - Set Label" enabled="true">
-            <stringProp name="BeanShellSampler.query">
-                vars.put("testLabel", "Admin Edit Order");
-            </stringProp>
-            <boolProp name="BeanShellSampler.resetInterpreter">true</boolProp>
-        </BeanShellSampler>
-        <hashTree/>
-    
-        <JSR223PostProcessor guiclass="TestBeanGUI" testclass="JSR223PostProcessor" testname="Get admin form key PostProcessor" enabled="true">
-        <stringProp name="script">
-        function getFormKeyFromResponse()
-        {
-            var url = prev.getUrlAsString(),
-            responseCode =  prev.getResponseCode(),
-            formKey = null;
-            searchPattern = /var FORM_KEY = '(.+)'/;
-            if (responseCode == "200" &amp;&amp; url) {
-                response = prev.getResponseDataAsString();
-                formKey = response  &amp;&amp; response.match(searchPattern) ? response.match(searchPattern)[1] : null;
-            }
-            return formKey;
-        }
-
-        formKey = vars.get("form_key_storage");
-
-	   currentFormKey = getFormKeyFromResponse();
-
-	   if (currentFormKey != null &amp;&amp; currentFormKey != formKey) {
-		  vars.put("form_key_storage", currentFormKey);
-	   }
-        </stringProp>
-        <stringProp name="scriptLanguage">javascript</stringProp>
-        <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin/handle_admin_form_key.jmx</stringProp></JSR223PostProcessor>
-        <hashTree/>
-        <JSR223PreProcessor guiclass="TestBeanGUI" testclass="JSR223PreProcessor" testname="Set admin form key PreProcessor" enabled="true">
-            <stringProp name="script">
-                formKey =  vars.get("form_key_storage");
-                if (formKey
-                    &amp;&amp; sampler.getClass().getName() == 'org.apache.jmeter.protocol.http.sampler.HTTPSamplerProxy'
-                    &amp;&amp; sampler.getMethod() == "POST")
-                    {
-                        arguments = sampler.getArguments();
-                        for (i=0; i&lt;arguments.getArgumentCount(); i++)
-                        {
-                            argument = arguments.getArgument(i);
-                            if (argument.getName() == 'form_key' &amp;&amp; argument.getValue() != formKey) {
-                            log.info("admin form key updated: " + argument.getValue() + " =&gt; " + formKey);
-                            argument.setValue(formKey);
-                        }
-                    }
-                }
-            </stringProp>
-            <stringProp name="scriptLanguage">javascript</stringProp>
-        </JSR223PreProcessor>
-        <hashTree/>
-    
-    <CookieManager guiclass="CookiePanel" testclass="CookieManager" testname="HTTP Cookie Manager" enabled="true">
-      <collectionProp name="CookieManager.cookies"/>
-      <boolProp name="CookieManager.clearEachIteration">false</boolProp>
-    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/http_cookie_manager_without_clear_each_iteration.jmx</stringProp></CookieManager>
-    <hashTree/>
-  
-    <OnceOnlyController guiclass="OnceOnlyControllerGui" testclass="OnceOnlyController" testname="Once Only Controller" enabled="true">
-  <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/once_only_controller.jmx</stringProp>
-</OnceOnlyController>
-    <hashTree>
-    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="SetUp - Login" enabled="true">
-      <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
-        <collectionProp name="Arguments.arguments"/>
-      </elementProp>
-      <stringProp name="HTTPSampler.domain"/>
-      <stringProp name="HTTPSampler.port"/>
-      <stringProp name="HTTPSampler.connect_timeout"/>
-      <stringProp name="HTTPSampler.response_timeout"/>
-      <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
-      <stringProp name="HTTPSampler.contentEncoding"/>
-      <stringProp name="HTTPSampler.path">${base_path}${admin_path}</stringProp>
-      <stringProp name="HTTPSampler.method">GET</stringProp>
-      <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
-      <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
-      <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
-      <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
-      <boolProp name="HTTPSampler.monitor">false</boolProp>
-      <stringProp name="HTTPSampler.embedded_url_re"/>
-    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_login/admin_login.jmx</stringProp></HTTPSamplerProxy>
-    <hashTree>
-      <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert login form shown" enabled="true">
-        <collectionProp name="Asserion.test_strings">
-          <stringProp name="-1397214398">Welcome</stringProp>
-          <stringProp name="-515240035">&lt;title&gt;Magento Admin&lt;/title&gt;</stringProp>
-        </collectionProp>
-        <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
-        <boolProp name="Assertion.assume_success">false</boolProp>
-        <intProp name="Assertion.test_type">2</intProp>
-      </ResponseAssertion>
-      <hashTree/>
-      <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract form key" enabled="true">
-        <stringProp name="RegexExtractor.useHeaders">false</stringProp>
-        <stringProp name="RegexExtractor.refname">admin_form_key</stringProp>
-        <stringProp name="RegexExtractor.regex">&lt;input name="form_key" type="hidden" value="([^'"]+)" /&gt;</stringProp>
-        <stringProp name="RegexExtractor.template">$1$</stringProp>
-        <stringProp name="RegexExtractor.default"/>
-        <stringProp name="RegexExtractor.match_number">1</stringProp>
-      </RegexExtractor>
-      <hashTree/>
-      <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert form_key extracted" enabled="true">
-        <collectionProp name="Asserion.test_strings">
-          <stringProp name="2845929">^.+$</stringProp>
-        </collectionProp>
-        <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
-        <boolProp name="Assertion.assume_success">false</boolProp>
-        <intProp name="Assertion.test_type">1</intProp>
-        <stringProp name="Assertion.scope">variable</stringProp>
-        <stringProp name="Scope.variable">admin_form_key</stringProp>
-      </ResponseAssertion>
-      <hashTree/>
-    </hashTree>
-  
-    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="SetUp - Login Submit Form" enabled="true">
-      <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
-        <collectionProp name="Arguments.arguments">
-          <elementProp name="dummy" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value"/>
-            <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">dummy</stringProp>
-          </elementProp>
-          <elementProp name="form_key" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">${admin_form_key}</stringProp>
-            <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">form_key</stringProp>
-          </elementProp>
-          <elementProp name="login[password]" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">${admin_password}</stringProp>
-            <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">login[password]</stringProp>
-          </elementProp>
-          <elementProp name="login[username]" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">${admin_user}</stringProp>
-            <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">login[username]</stringProp>
-          </elementProp>
-        </collectionProp>
-      </elementProp>
-      <stringProp name="HTTPSampler.domain"/>
-      <stringProp name="HTTPSampler.port"/>
-      <stringProp name="HTTPSampler.connect_timeout"/>
-      <stringProp name="HTTPSampler.response_timeout"/>
-      <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
-      <stringProp name="HTTPSampler.contentEncoding"/>
-      <stringProp name="HTTPSampler.path">${base_path}${admin_path}/admin/dashboard/</stringProp>
-      <stringProp name="HTTPSampler.method">POST</stringProp>
-      <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
-      <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
-      <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
-      <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
-      <stringProp name="HTTPSampler.implementation">Java</stringProp>
-      <boolProp name="HTTPSampler.monitor">false</boolProp>
-      <stringProp name="HTTPSampler.embedded_url_re"/>
-      <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_login/admin_login_submit_form.jmx</stringProp>
-    </HTTPSamplerProxy>
-    <hashTree>
-        <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract form key" enabled="true">
-            <stringProp name="RegexExtractor.useHeaders">false</stringProp>
-            <stringProp name="RegexExtractor.refname">admin_form_key</stringProp>
-            <stringProp name="RegexExtractor.regex">&lt;input name="form_key" type="hidden" value="([^'"]+)" /&gt;</stringProp>
-            <stringProp name="RegexExtractor.template">$1$</stringProp>
-            <stringProp name="RegexExtractor.default"/>
-            <stringProp name="RegexExtractor.match_number">1</stringProp>
-        <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_login/admin_retrieve_form_key.jmx</stringProp></RegexExtractor>
-        <hashTree/>
-    </hashTree>
-  </hashTree>
-  
-    <GenericController guiclass="LogicControllerGui" testclass="GenericController" testname="Simple Controller" enabled="true">
-  <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/simple_controller.jmx</stringProp>
-</GenericController>
-    <hashTree>
-  <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Orders page" enabled="true">
-    <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
-      <collectionProp name="Arguments.arguments"/>
-    </elementProp>
-    <stringProp name="HTTPSampler.domain"/>
-    <stringProp name="HTTPSampler.port"/>
-    <stringProp name="HTTPSampler.connect_timeout"/>
-    <stringProp name="HTTPSampler.response_timeout"/>
-    <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
-    <stringProp name="HTTPSampler.contentEncoding"/>
-    <stringProp name="HTTPSampler.path">${base_path}${admin_path}/sales/order/</stringProp>
-    <stringProp name="HTTPSampler.method">GET</stringProp>
-    <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
-    <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
-    <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
-    <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
-    <boolProp name="HTTPSampler.monitor">false</boolProp>
-    <stringProp name="HTTPSampler.embedded_url_re"/>
-  <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_create_process_returns/orders_page.jmx</stringProp></HTTPSamplerProxy>
-  <hashTree>
-    <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Response Assertion" enabled="true">
-      <collectionProp name="Asserion.test_strings">
-        <stringProp name="1204796042">Create New Order</stringProp>
-      </collectionProp>
-      <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
-      <boolProp name="Assertion.assume_success">false</boolProp>
-      <intProp name="Assertion.test_type">2</intProp>
-    </ResponseAssertion>
-    <hashTree/>
-  </hashTree>
-
-  <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Open Orders" enabled="true">
-    <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
-      <collectionProp name="Arguments.arguments">
-        <elementProp name="namespace" elementType="HTTPArgument">
-          <boolProp name="HTTPArgument.always_encode">true</boolProp>
-          <stringProp name="Argument.value">sales_order_grid</stringProp>
-          <stringProp name="Argument.metadata">=</stringProp>
-          <boolProp name="HTTPArgument.use_equals">true</boolProp>
-          <stringProp name="Argument.name">namespace</stringProp>
-        </elementProp>
-        <elementProp name="search" elementType="HTTPArgument">
-          <boolProp name="HTTPArgument.always_encode">true</boolProp>
-          <stringProp name="Argument.value"/>
-          <stringProp name="Argument.metadata">=</stringProp>
-          <boolProp name="HTTPArgument.use_equals">true</boolProp>
-          <stringProp name="Argument.name">search</stringProp>
-        </elementProp>
-        <elementProp name="filters[placeholder]" elementType="HTTPArgument">
-          <boolProp name="HTTPArgument.always_encode">true</boolProp>
-          <stringProp name="Argument.value">true</stringProp>
-          <stringProp name="Argument.metadata">=</stringProp>
-          <boolProp name="HTTPArgument.use_equals">true</boolProp>
-          <stringProp name="Argument.name">filters[placeholder]</stringProp>
-        </elementProp>
-        <elementProp name="paging[pageSize]" elementType="HTTPArgument">
-          <boolProp name="HTTPArgument.always_encode">true</boolProp>
-          <stringProp name="Argument.value">200</stringProp>
-          <stringProp name="Argument.metadata">=</stringProp>
-          <boolProp name="HTTPArgument.use_equals">true</boolProp>
-          <stringProp name="Argument.name">paging[pageSize]</stringProp>
-        </elementProp>
-        <elementProp name="paging[current]" elementType="HTTPArgument">
-          <boolProp name="HTTPArgument.always_encode">true</boolProp>
-          <stringProp name="Argument.value">1</stringProp>
-          <stringProp name="Argument.metadata">=</stringProp>
-          <boolProp name="HTTPArgument.use_equals">true</boolProp>
-          <stringProp name="Argument.name">paging[current]</stringProp>
-        </elementProp>
-        <elementProp name="sorting[field]" elementType="HTTPArgument">
-          <boolProp name="HTTPArgument.always_encode">true</boolProp>
-          <stringProp name="Argument.value">increment_id</stringProp>
-          <stringProp name="Argument.metadata">=</stringProp>
-          <boolProp name="HTTPArgument.use_equals">true</boolProp>
-          <stringProp name="Argument.name">sorting[field]</stringProp>
-        </elementProp>
-        <elementProp name="sorting[direction]" elementType="HTTPArgument">
-          <boolProp name="HTTPArgument.always_encode">true</boolProp>
-          <stringProp name="Argument.value">desc</stringProp>
-          <stringProp name="Argument.metadata">=</stringProp>
-          <boolProp name="HTTPArgument.use_equals">true</boolProp>
-          <stringProp name="Argument.name">sorting[direction]</stringProp>
-        </elementProp>
-        <elementProp name="isAjax" elementType="HTTPArgument">
-          <boolProp name="HTTPArgument.always_encode">true</boolProp>
-          <stringProp name="Argument.value">true</stringProp>
-          <stringProp name="Argument.metadata">=</stringProp>
-          <boolProp name="HTTPArgument.use_equals">true</boolProp>
-          <stringProp name="Argument.name">isAjax</stringProp>
-        </elementProp>
-        <elementProp name="form_key" elementType="HTTPArgument">
-          <boolProp name="HTTPArgument.always_encode">true</boolProp>
-          <stringProp name="Argument.value">${admin_form_key}</stringProp>
-          <stringProp name="Argument.metadata">=</stringProp>
-          <boolProp name="HTTPArgument.use_equals">true</boolProp>
-          <stringProp name="Argument.name">form_key</stringProp>
-          <stringProp name="Argument.desc">false</stringProp>
-        </elementProp>
-        <elementProp name="filters[status]" elementType="HTTPArgument">
-          <boolProp name="HTTPArgument.always_encode">true</boolProp>
-          <stringProp name="Argument.value">pending</stringProp>
-          <stringProp name="Argument.metadata">=</stringProp>
-          <boolProp name="HTTPArgument.use_equals">true</boolProp>
-          <stringProp name="Argument.name">filters[status]</stringProp>
-          <stringProp name="Argument.desc">true</stringProp>
-        </elementProp>
-        <elementProp name="_" elementType="HTTPArgument">
-          <boolProp name="HTTPArgument.always_encode">true</boolProp>
-          <stringProp name="Argument.value">${__time()}${__Random(1,1000000)}</stringProp>
-          <stringProp name="Argument.metadata">=</stringProp>
-          <boolProp name="HTTPArgument.use_equals">true</boolProp>
-          <stringProp name="Argument.name">_</stringProp>
-        </elementProp>
-      </collectionProp>
-    </elementProp>
-    <stringProp name="HTTPSampler.domain"/>
-    <stringProp name="HTTPSampler.port"/>
-    <stringProp name="HTTPSampler.connect_timeout"/>
-    <stringProp name="HTTPSampler.response_timeout"/>
-    <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
-    <stringProp name="HTTPSampler.contentEncoding"/>
-    <stringProp name="HTTPSampler.path">${base_path}${admin_path}/mui/index/render/</stringProp>
-    <stringProp name="HTTPSampler.method">GET</stringProp>
-    <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
-    <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
-    <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
-    <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
-    <boolProp name="HTTPSampler.monitor">false</boolProp>
-    <stringProp name="HTTPSampler.embedded_url_re"/>
-  <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_create_process_returns/open_orders.jmx</stringProp></HTTPSamplerProxy>
-  <hashTree>
-    <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Response Assertion" enabled="true">
-      <collectionProp name="Asserion.test_strings">
-        <stringProp name="1637639774">totalRecords</stringProp>
-      </collectionProp>
-      <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
-      <boolProp name="Assertion.assume_success">false</boolProp>
-      <intProp name="Assertion.test_type">2</intProp>
-    </ResponseAssertion>
-    <hashTree/>
-  </hashTree>
-
-  <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Search Pending Orders" enabled="true">
-    <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
-      <collectionProp name="Arguments.arguments">
-        <elementProp name="form_key" elementType="HTTPArgument">
-          <boolProp name="HTTPArgument.always_encode">true</boolProp>
-          <stringProp name="Argument.value">${admin_form_key}</stringProp>
-          <stringProp name="Argument.metadata">=</stringProp>
-          <boolProp name="HTTPArgument.use_equals">true</boolProp>
-          <stringProp name="Argument.name">form_key</stringProp>
-        </elementProp>
-        <elementProp name="namespace" elementType="HTTPArgument">
-          <boolProp name="HTTPArgument.always_encode">true</boolProp>
-          <stringProp name="Argument.value">sales_order_grid</stringProp>
-          <stringProp name="Argument.metadata">=</stringProp>
-          <boolProp name="HTTPArgument.use_equals">true</boolProp>
-          <stringProp name="Argument.name">namespace</stringProp>
-          <stringProp name="Argument.desc">true</stringProp>
-        </elementProp>
-        <elementProp name="search" elementType="HTTPArgument">
-          <boolProp name="HTTPArgument.always_encode">true</boolProp>
-          <stringProp name="Argument.value"/>
-          <stringProp name="Argument.metadata">=</stringProp>
-          <boolProp name="HTTPArgument.use_equals">true</boolProp>
-          <stringProp name="Argument.name">search</stringProp>
-          <stringProp name="Argument.desc">true</stringProp>
-        </elementProp>
-        <elementProp name="filters[placeholder]" elementType="HTTPArgument">
-          <boolProp name="HTTPArgument.always_encode">true</boolProp>
-          <stringProp name="Argument.value">true</stringProp>
-          <stringProp name="Argument.metadata">=</stringProp>
-          <boolProp name="HTTPArgument.use_equals">true</boolProp>
-          <stringProp name="Argument.name">filters[placeholder]</stringProp>
-          <stringProp name="Argument.desc">true</stringProp>
-        </elementProp>
-        <elementProp name="paging[pageSize]" elementType="HTTPArgument">
-          <boolProp name="HTTPArgument.always_encode">true</boolProp>
-          <stringProp name="Argument.value">200</stringProp>
-          <stringProp name="Argument.metadata">=</stringProp>
-          <boolProp name="HTTPArgument.use_equals">true</boolProp>
-          <stringProp name="Argument.name">paging[pageSize]</stringProp>
-          <stringProp name="Argument.desc">true</stringProp>
-        </elementProp>
-        <elementProp name="paging[current]" elementType="HTTPArgument">
-          <boolProp name="HTTPArgument.always_encode">true</boolProp>
-          <stringProp name="Argument.value">1</stringProp>
-          <stringProp name="Argument.metadata">=</stringProp>
-          <boolProp name="HTTPArgument.use_equals">true</boolProp>
-          <stringProp name="Argument.name">paging[current]</stringProp>
-          <stringProp name="Argument.desc">true</stringProp>
-        </elementProp>
-        <elementProp name="sorting[field]" elementType="HTTPArgument">
-          <boolProp name="HTTPArgument.always_encode">true</boolProp>
-          <stringProp name="Argument.value">increment_id</stringProp>
-          <stringProp name="Argument.metadata">=</stringProp>
-          <boolProp name="HTTPArgument.use_equals">true</boolProp>
-          <stringProp name="Argument.name">sorting[field]</stringProp>
-          <stringProp name="Argument.desc">true</stringProp>
-        </elementProp>
-        <elementProp name="sorting[direction]" elementType="HTTPArgument">
-          <boolProp name="HTTPArgument.always_encode">true</boolProp>
-          <stringProp name="Argument.value">asc</stringProp>
-          <stringProp name="Argument.metadata">=</stringProp>
-          <boolProp name="HTTPArgument.use_equals">true</boolProp>
-          <stringProp name="Argument.name">sorting[direction]</stringProp>
-          <stringProp name="Argument.desc">true</stringProp>
-        </elementProp>
-        <elementProp name="isAjax" elementType="HTTPArgument">
-          <boolProp name="HTTPArgument.always_encode">true</boolProp>
-          <stringProp name="Argument.value">true</stringProp>
-          <stringProp name="Argument.metadata">=</stringProp>
-          <boolProp name="HTTPArgument.use_equals">true</boolProp>
-          <stringProp name="Argument.name">isAjax</stringProp>
-          <stringProp name="Argument.desc">true</stringProp>
-        </elementProp>
-        <elementProp name="filters[status]" elementType="HTTPArgument">
-          <boolProp name="HTTPArgument.always_encode">true</boolProp>
-          <stringProp name="Argument.value">pending</stringProp>
-          <stringProp name="Argument.metadata">=</stringProp>
-          <boolProp name="HTTPArgument.use_equals">true</boolProp>
-          <stringProp name="Argument.name">filters[status]</stringProp>
-        </elementProp>
-        <elementProp name="_" elementType="HTTPArgument">
-          <boolProp name="HTTPArgument.always_encode">true</boolProp>
-          <stringProp name="Argument.value">${__time()}${__Random(1,1000000)}</stringProp>
-          <stringProp name="Argument.metadata">=</stringProp>
-          <boolProp name="HTTPArgument.use_equals">true</boolProp>
-          <stringProp name="Argument.name">_</stringProp>
-        </elementProp>
-      </collectionProp>
-    </elementProp>
-    <stringProp name="HTTPSampler.domain"/>
-    <stringProp name="HTTPSampler.port"/>
-    <stringProp name="HTTPSampler.connect_timeout"/>
-    <stringProp name="HTTPSampler.response_timeout"/>
-    <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
-    <stringProp name="HTTPSampler.contentEncoding"/>
-    <stringProp name="HTTPSampler.path">${base_path}${admin_path}/mui/index/render/</stringProp>
-    <stringProp name="HTTPSampler.method">GET</stringProp>
-    <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
-    <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
-    <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
-    <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
-    <boolProp name="HTTPSampler.monitor">false</boolProp>
-    <stringProp name="HTTPSampler.embedded_url_re"/>
-  <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_create_process_returns/search_orders.jmx</stringProp></HTTPSamplerProxy>
-<hashTree>
-      <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Response Assertion" enabled="true">
-        <collectionProp name="Asserion.test_strings">
-          <stringProp name="1637639774">totalRecords</stringProp>
-        </collectionProp>
-        <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
-        <boolProp name="Assertion.assume_success">false</boolProp>
-        <intProp name="Assertion.test_type">2</intProp>
-      </ResponseAssertion>
-      <hashTree/>
-      <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract order numbers" enabled="true">
-        <stringProp name="RegexExtractor.useHeaders">false</stringProp>
-        <stringProp name="RegexExtractor.refname">order_numbers</stringProp>
-        <stringProp name="RegexExtractor.regex">\"increment_id\":\"(\d+)\"\,</stringProp>
-        <stringProp name="RegexExtractor.template">$1$</stringProp>
-        <stringProp name="RegexExtractor.default"/>
-        <stringProp name="RegexExtractor.match_number">-1</stringProp>
-        <stringProp name="Scope.variable">simple_products</stringProp>
-      </RegexExtractor>
-      <hashTree/>
-      <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract order ids" enabled="true">
-        <stringProp name="RegexExtractor.useHeaders">false</stringProp>
-        <stringProp name="RegexExtractor.refname">order_ids</stringProp>
-        <stringProp name="RegexExtractor.regex">\"entity_id\":\"(\d+)\"\,</stringProp>
-        <stringProp name="RegexExtractor.template">$1$</stringProp>
-        <stringProp name="RegexExtractor.default"/>
-        <stringProp name="RegexExtractor.match_number">-1</stringProp>
-        <stringProp name="Scope.variable">simple_products</stringProp>
-      </RegexExtractor>
-      <hashTree/>
-    </hashTree>
-
-      <BeanShellSampler guiclass="BeanShellSamplerGui" testclass="BeanShellSampler" testname="SetUp - Generate Unique Ids for each Thread" enabled="true">
-        <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_create_process_returns/setup.jmx</stringProp>
-        <stringProp name="BeanShellSampler.query">
-  import java.util.ArrayList;
-  import java.util.HashMap;
-  import org.apache.jmeter.protocol.http.util.Base64Encoder;
-  import java.util.Random;
-
-  // get count of "order_numbers" variable defined in "Search Pending Orders Limit"
-  int ordersCount = Integer.parseInt(vars.get("order_numbers_matchNr"));
-
-
-  int clusterLength;
-  int threadsNumber = ctx.getThreadGroup().getNumThreads();
-  if (threadsNumber == 0) {
-      //Number of orders for one thread
-      clusterLength = ordersCount;
-  } else {
-      clusterLength = Math.round(ordersCount / threadsNumber);
-      if (clusterLength == 0) {
-          clusterLength = 1;
-      }
-  }
-
-  //Current thread number starts from 0
-  int currentThreadNum = ctx.getThreadNum();
-
-  //Index of the current product from the cluster
-  Random random = new Random();
-  int iterator = random.nextInt(clusterLength);
-  if (iterator == 0) {
-  	iterator = 1;
-  }
-
-  int i = clusterLength * currentThreadNum + iterator;
-
-  orderNumber = vars.get("order_numbers_" + i.toString());
-  orderId = vars.get("order_ids_" + i.toString());
-  vars.put("order_number", orderNumber);
-  vars.put("order_id", orderId);
-
-  </stringProp>
-    <stringProp name="BeanShellSampler.filename"/>
-    <stringProp name="BeanShellSampler.parameters"/>
-    <boolProp name="BeanShellSampler.resetInterpreter">false</boolProp>
-  </BeanShellSampler>
-  <hashTree/>
-
-  <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Open Order" enabled="true">
-    <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
-      <collectionProp name="Arguments.arguments"/>
-    </elementProp>
-    <stringProp name="HTTPSampler.domain"/>
-    <stringProp name="HTTPSampler.port"/>
-    <stringProp name="HTTPSampler.connect_timeout"/>
-    <stringProp name="HTTPSampler.response_timeout"/>
-    <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
-    <stringProp name="HTTPSampler.contentEncoding"/>
-    <stringProp name="HTTPSampler.path">${base_path}${admin_path}/sales/order/view/order_id/${order_id}/</stringProp>
-    <stringProp name="HTTPSampler.method">GET</stringProp>
-    <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
-    <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
-    <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
-    <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
-    <boolProp name="HTTPSampler.monitor">false</boolProp>
-    <stringProp name="HTTPSampler.embedded_url_re"/>
-  <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_create_process_returns/open_order.jmx</stringProp></HTTPSamplerProxy>
-  <hashTree>
-    <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Response Assertion" enabled="true">
-      <collectionProp name="Asserion.test_strings">
-        <stringProp name="2103620713">#${order_number}</stringProp>
-      </collectionProp>
-      <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
-      <boolProp name="Assertion.assume_success">false</boolProp>
-      <intProp name="Assertion.test_type">2</intProp>
-    </ResponseAssertion>
-    <hashTree/>
-    <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract order status" enabled="true">
-      <stringProp name="RegexExtractor.useHeaders">false</stringProp>
-      <stringProp name="RegexExtractor.refname">order_status</stringProp>
-      <stringProp name="RegexExtractor.regex">&lt;span id="order_status"&gt;([^&lt;]+)&lt;/span&gt;</stringProp>
-      <stringProp name="RegexExtractor.template">$1$</stringProp>
-      <stringProp name="RegexExtractor.default"/>
-      <stringProp name="RegexExtractor.match_number">1</stringProp>
-      <stringProp name="Scope.variable">simple_products</stringProp>
-    </RegexExtractor>
-    <hashTree/>
-  </hashTree>
-
-    <IfController guiclass="IfControllerPanel" testclass="IfController" testname="If Controller" enabled="true">
-      <stringProp name="IfController.condition">"${order_status}" == "Pending"</stringProp>
-      <boolProp name="IfController.evaluateAll">false</boolProp>
-    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_edit_order/if_controller.jmx</stringProp></IfController>
-    <hashTree>
-    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Add Comment" enabled="true">
-      <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
-        <collectionProp name="Arguments.arguments">
-          <elementProp name="history[status]" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">pending</stringProp>
-            <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">history[status]</stringProp>
-            <stringProp name="Argument.desc">false</stringProp>
-          </elementProp>
-          <elementProp name="history[comment]" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">Some text</stringProp>
-            <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">history[comment]</stringProp>
-          </elementProp>
-          <elementProp name="form_key" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">${admin_form_key}</stringProp>
-            <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">form_key</stringProp>
-            <stringProp name="Argument.desc">false</stringProp>
-          </elementProp>
-        </collectionProp>
-      </elementProp>
-      <stringProp name="HTTPSampler.domain"/>
-      <stringProp name="HTTPSampler.port"/>
-      <stringProp name="HTTPSampler.connect_timeout"/>
-      <stringProp name="HTTPSampler.response_timeout"/>
-      <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
-      <stringProp name="HTTPSampler.contentEncoding"/>
-      <stringProp name="HTTPSampler.path">${base_path}${admin_path}/sales/order/addComment/order_id/${order_id}/?isAjax=true</stringProp>
-      <stringProp name="HTTPSampler.method">POST</stringProp>
-      <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
-      <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
-      <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
-      <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
-      <boolProp name="HTTPSampler.monitor">false</boolProp>
-      <stringProp name="HTTPSampler.embedded_url_re"/>
-    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_edit_order/add_comment.jmx</stringProp></HTTPSamplerProxy>
-    <hashTree>
-      <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Response Assertion" enabled="true">
-        <collectionProp name="Asserion.test_strings">
-          <stringProp name="-2089278331">Not Notified</stringProp>
-        </collectionProp>
-        <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
-        <boolProp name="Assertion.assume_success">false</boolProp>
-        <intProp name="Assertion.test_type">2</intProp>
-      </ResponseAssertion>
-      <hashTree/>
-    </hashTree>
-  
-  <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Invoice Start" enabled="true">
-    <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
-      <collectionProp name="Arguments.arguments"/>
-    </elementProp>
-    <stringProp name="HTTPSampler.domain"/>
-    <stringProp name="HTTPSampler.port"/>
-    <stringProp name="HTTPSampler.connect_timeout"/>
-    <stringProp name="HTTPSampler.response_timeout"/>
-    <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
-    <stringProp name="HTTPSampler.contentEncoding"/>
-    <stringProp name="HTTPSampler.path">${base_path}${admin_path}/sales/order_invoice/start/order_id/${order_id}/</stringProp>
-    <stringProp name="HTTPSampler.method">GET</stringProp>
-    <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
-    <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
-    <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
-    <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
-    <boolProp name="HTTPSampler.monitor">false</boolProp>
-    <stringProp name="HTTPSampler.embedded_url_re"/>
-  <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_create_process_returns/invoice_start.jmx</stringProp></HTTPSamplerProxy>
-  <hashTree>
-    <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Response Assertion" enabled="true">
-      <collectionProp name="Asserion.test_strings">
-        <stringProp name="-1233850814">Invoice Totals</stringProp>
-      </collectionProp>
-      <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
-      <boolProp name="Assertion.assume_success">false</boolProp>
-      <intProp name="Assertion.test_type">2</intProp>
-    </ResponseAssertion>
-    <hashTree/>
-    <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract ordered items ids" enabled="true">
-      <stringProp name="RegexExtractor.useHeaders">false</stringProp>
-      <stringProp name="RegexExtractor.refname">item_ids</stringProp>
-      <stringProp name="RegexExtractor.regex">&lt;div id="order_item_(\d+)_title"\s*class="product-title"&gt;</stringProp>
-      <stringProp name="RegexExtractor.template">$1$</stringProp>
-      <stringProp name="RegexExtractor.default"/>
-      <stringProp name="RegexExtractor.match_number">-1</stringProp>
-      <stringProp name="Scope.variable">simple_products</stringProp>
-    </RegexExtractor>
-    <hashTree/>
-  </hashTree>
-
-  <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Invoice Submit" enabled="true">
-    <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
-      <collectionProp name="Arguments.arguments">
-        <elementProp name="form_key" elementType="HTTPArgument">
-          <boolProp name="HTTPArgument.always_encode">true</boolProp>
-          <stringProp name="Argument.value">${admin_form_key}</stringProp>
-          <stringProp name="Argument.metadata">=</stringProp>
-          <boolProp name="HTTPArgument.use_equals">true</boolProp>
-          <stringProp name="Argument.name">form_key</stringProp>
-          <stringProp name="Argument.desc">false</stringProp>
-        </elementProp>
-        <elementProp name="invoice[items][${item_ids_1}]" elementType="HTTPArgument">
-          <boolProp name="HTTPArgument.always_encode">true</boolProp>
-          <stringProp name="Argument.value">1</stringProp>
-          <stringProp name="Argument.metadata">=</stringProp>
-          <boolProp name="HTTPArgument.use_equals">true</boolProp>
-          <stringProp name="Argument.name">invoice[items][${item_ids_1}]</stringProp>
-        </elementProp>
-        <elementProp name="invoice[items][${item_ids_2}]" elementType="HTTPArgument">
-          <boolProp name="HTTPArgument.always_encode">true</boolProp>
-          <stringProp name="Argument.value">1</stringProp>
-          <stringProp name="Argument.metadata">=</stringProp>
-          <boolProp name="HTTPArgument.use_equals">true</boolProp>
-          <stringProp name="Argument.name">invoice[items][${item_ids_2}]</stringProp>
-        </elementProp>
-        <elementProp name="invoice[comment_text]" elementType="HTTPArgument">
-          <boolProp name="HTTPArgument.always_encode">true</boolProp>
-          <stringProp name="Argument.value">Invoiced</stringProp>
-          <stringProp name="Argument.metadata">=</stringProp>
-          <boolProp name="HTTPArgument.use_equals">true</boolProp>
-          <stringProp name="Argument.name">invoice[comment_text]</stringProp>
-        </elementProp>
-      </collectionProp>
-    </elementProp>
-    <stringProp name="HTTPSampler.domain"/>
-    <stringProp name="HTTPSampler.port"/>
-    <stringProp name="HTTPSampler.connect_timeout"/>
-    <stringProp name="HTTPSampler.response_timeout"/>
-    <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
-    <stringProp name="HTTPSampler.contentEncoding"/>
-    <stringProp name="HTTPSampler.path">${base_path}${admin_path}/sales/order_invoice/save/order_id/${order_id}/</stringProp>
-    <stringProp name="HTTPSampler.method">POST</stringProp>
-    <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
-    <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
-    <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
-    <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
-    <boolProp name="HTTPSampler.monitor">false</boolProp>
-    <stringProp name="HTTPSampler.embedded_url_re"/>
-  <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_create_process_returns/invoice_submit.jmx</stringProp></HTTPSamplerProxy>
-  <hashTree>
-    <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Response Assertion" enabled="true">
-      <collectionProp name="Asserion.test_strings">
-        <stringProp name="1740524604">The invoice has been created</stringProp>
-      </collectionProp>
-      <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
-      <boolProp name="Assertion.assume_success">false</boolProp>
-      <intProp name="Assertion.test_type">2</intProp>
-    </ResponseAssertion>
-    <hashTree/>
-  </hashTree>
-
-    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Shipment Start" enabled="true">
-      <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
-        <collectionProp name="Arguments.arguments"/>
-      </elementProp>
-      <stringProp name="HTTPSampler.domain"/>
-      <stringProp name="HTTPSampler.port"/>
-      <stringProp name="HTTPSampler.connect_timeout"/>
-      <stringProp name="HTTPSampler.response_timeout"/>
-      <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
-      <stringProp name="HTTPSampler.contentEncoding"/>
-      <stringProp name="HTTPSampler.path">${base_path}${admin_path}/admin/order_shipment/start/order_id/${order_id}/</stringProp>
-      <stringProp name="HTTPSampler.method">GET</stringProp>
-      <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
-      <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
-      <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
-      <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
-      <boolProp name="HTTPSampler.monitor">false</boolProp>
-      <stringProp name="HTTPSampler.embedded_url_re"/>
-    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_edit_order/shipment_start.jmx</stringProp></HTTPSamplerProxy>
-    <hashTree>
-      <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Response Assertion" enabled="true">
-        <collectionProp name="Asserion.test_strings">
-          <stringProp name="304100442">New Shipment</stringProp>
-        </collectionProp>
-        <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
-        <boolProp name="Assertion.assume_success">false</boolProp>
-        <intProp name="Assertion.test_type">2</intProp>
-      </ResponseAssertion>
-      <hashTree/>
-    </hashTree>
-  
-    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Shipment Submit" enabled="true">
-      <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
-        <collectionProp name="Arguments.arguments">
-          <elementProp name="form_key" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">${admin_form_key}</stringProp>
-            <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">form_key</stringProp>
-            <stringProp name="Argument.desc">false</stringProp>
-          </elementProp>
-          <elementProp name="shipment[items][${item_ids_1}]" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">1</stringProp>
-            <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">shipment[items][${item_ids_1}]</stringProp>
-          </elementProp>
-          <elementProp name="shipment[items][${item_ids_2}]" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">1</stringProp>
-            <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">shipment[items][${item_ids_2}]</stringProp>
-          </elementProp>
-          <elementProp name="shipment[comment_text]" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">Shipped</stringProp>
-            <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">shipment[comment_text]</stringProp>
-          </elementProp>
-        </collectionProp>
-      </elementProp>
-      <stringProp name="HTTPSampler.domain"/>
-      <stringProp name="HTTPSampler.port"/>
-      <stringProp name="HTTPSampler.connect_timeout"/>
-      <stringProp name="HTTPSampler.response_timeout"/>
-      <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
-      <stringProp name="HTTPSampler.contentEncoding"/>
-      <stringProp name="HTTPSampler.path">${base_path}${admin_path}/admin/order_shipment/save/order_id/${order_id}/</stringProp>
-      <stringProp name="HTTPSampler.method">POST</stringProp>
-      <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
-      <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
-      <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
-      <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
-      <boolProp name="HTTPSampler.monitor">false</boolProp>
-      <stringProp name="HTTPSampler.embedded_url_re"/>
-    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_edit_order/shipment_submit.jmx</stringProp></HTTPSamplerProxy>
-    <hashTree>
-      <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Response Assertion" enabled="true">
-        <collectionProp name="Asserion.test_strings">
-          <stringProp name="-2089453199">The shipment has been created</stringProp>
-        </collectionProp>
-        <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
-        <boolProp name="Assertion.assume_success">false</boolProp>
-        <intProp name="Assertion.test_type">2</intProp>
-      </ResponseAssertion>
-      <hashTree/>
-    </hashTree>
-  </hashTree>
-  </hashTree>
-  </hashTree>
-
-  </hashTree>
-
-    
-        <ThreadGroup guiclass="ThreadGroupGui" testclass="ThreadGroup" testname="CSR Pool" enabled="true">
-            <stringProp name="ThreadGroup.on_sample_error">continue</stringProp>
-            <elementProp name="ThreadGroup.main_controller" elementType="LoopController" guiclass="LoopControlPanel" testclass="LoopController" testname="Loop Controller" enabled="true">
-                <boolProp name="LoopController.continue_forever">false</boolProp>
-                <stringProp name="LoopController.loops">${loops}</stringProp>
-            </elementProp>
-            <stringProp name="ThreadGroup.num_threads">${csrPoolUsers}</stringProp>
-            <stringProp name="ThreadGroup.ramp_time">${ramp_period}</stringProp>
-            <longProp name="ThreadGroup.start_time">1505803944000</longProp>
-            <longProp name="ThreadGroup.end_time">1505803944000</longProp>
-            <boolProp name="ThreadGroup.scheduler">false</boolProp>
-            <stringProp name="ThreadGroup.duration"/>
-            <stringProp name="ThreadGroup.delay"/>
-        <stringProp name="TestPlan.comments">mpaf/tool/fragments/_system/thread_group.jmx</stringProp></ThreadGroup>
-        <hashTree>
-    <ThroughputController guiclass="ThroughputControllerGui" testclass="ThroughputController" testname="Admin Returns Management" enabled="true">
-      <intProp name="ThroughputController.style">1</intProp>
-      <boolProp name="ThroughputController.perThread">false</boolProp>
-      <intProp name="ThroughputController.maxThroughput">1</intProp>
-      <stringProp name="ThroughputController.percentThroughput">${adminReturnsManagementPercentage}</stringProp>
-    <stringProp name="TestPlan.comments">mpaf/tool/fragments/_system/scenario_controller_tmpl.jmx</stringProp></ThroughputController>
-    <hashTree>
-        <JSR223PreProcessor guiclass="TestBeanGUI" testclass="JSR223PreProcessor" testname="Set Test Label" enabled="true">
-            <stringProp name="script">
-var testLabel = "${testLabel}" ? " (${testLabel})" : "";
-if (testLabel
-    &amp;&amp; sampler.getClass().getName() == 'org.apache.jmeter.protocol.http.sampler.HTTPSamplerProxy'
-) {
-    if (sampler.getName().indexOf(testLabel) == -1) {
-       sampler.setName(sampler.getName() + testLabel);
-    }
-} else if (sampler.getName().indexOf("SetUp - ") == -1) {
-    sampler.setName("SetUp - " + sampler.getName());
-}
-            </stringProp>
-            <stringProp name="scriptLanguage">javascript</stringProp>
-        <stringProp name="TestPlan.comments">mpaf/tool/fragments/_system/setup_label.jmx</stringProp></JSR223PreProcessor>
-        <hashTree/>
-        <BeanShellSampler guiclass="BeanShellSamplerGui" testclass="BeanShellSampler" testname="SetUp - Set Label" enabled="true">
-            <stringProp name="BeanShellSampler.query">
-                vars.put("testLabel", "Admin Returns Management");
-            </stringProp>
-            <boolProp name="BeanShellSampler.resetInterpreter">true</boolProp>
-        </BeanShellSampler>
-        <hashTree/>
-    
-        <JSR223PostProcessor guiclass="TestBeanGUI" testclass="JSR223PostProcessor" testname="Get admin form key PostProcessor" enabled="true">
-        <stringProp name="script">
-        function getFormKeyFromResponse()
-        {
-            var url = prev.getUrlAsString(),
-            responseCode =  prev.getResponseCode(),
-            formKey = null;
-            searchPattern = /var FORM_KEY = '(.+)'/;
-            if (responseCode == "200" &amp;&amp; url) {
-                response = prev.getResponseDataAsString();
-                formKey = response  &amp;&amp; response.match(searchPattern) ? response.match(searchPattern)[1] : null;
-            }
-            return formKey;
-        }
-
-        formKey = vars.get("form_key_storage");
-
-	   currentFormKey = getFormKeyFromResponse();
-
-	   if (currentFormKey != null &amp;&amp; currentFormKey != formKey) {
-		  vars.put("form_key_storage", currentFormKey);
-	   }
-        </stringProp>
-        <stringProp name="scriptLanguage">javascript</stringProp>
-        <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin/handle_admin_form_key.jmx</stringProp></JSR223PostProcessor>
-        <hashTree/>
-        <JSR223PreProcessor guiclass="TestBeanGUI" testclass="JSR223PreProcessor" testname="Set admin form key PreProcessor" enabled="true">
-            <stringProp name="script">
-                formKey =  vars.get("form_key_storage");
-                if (formKey
-                    &amp;&amp; sampler.getClass().getName() == 'org.apache.jmeter.protocol.http.sampler.HTTPSamplerProxy'
-                    &amp;&amp; sampler.getMethod() == "POST")
-                    {
-                        arguments = sampler.getArguments();
-                        for (i=0; i&lt;arguments.getArgumentCount(); i++)
-                        {
-                            argument = arguments.getArgument(i);
-                            if (argument.getName() == 'form_key' &amp;&amp; argument.getValue() != formKey) {
-                            log.info("admin form key updated: " + argument.getValue() + " =&gt; " + formKey);
-                            argument.setValue(formKey);
-                        }
-                    }
-                }
-            </stringProp>
-            <stringProp name="scriptLanguage">javascript</stringProp>
-        </JSR223PreProcessor>
-        <hashTree/>
-    
-    <CookieManager guiclass="CookiePanel" testclass="CookieManager" testname="HTTP Cookie Manager" enabled="true">
-      <collectionProp name="CookieManager.cookies"/>
-      <boolProp name="CookieManager.clearEachIteration">false</boolProp>
-    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/http_cookie_manager_without_clear_each_iteration.jmx</stringProp></CookieManager>
-    <hashTree/>
-  
-    <OnceOnlyController guiclass="OnceOnlyControllerGui" testclass="OnceOnlyController" testname="Once Only Controller" enabled="true">
-  <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/once_only_controller.jmx</stringProp>
-</OnceOnlyController>
-    <hashTree>
-    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="SetUp - Login" enabled="true">
-      <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
-        <collectionProp name="Arguments.arguments"/>
-      </elementProp>
-      <stringProp name="HTTPSampler.domain"/>
-      <stringProp name="HTTPSampler.port"/>
-      <stringProp name="HTTPSampler.connect_timeout"/>
-      <stringProp name="HTTPSampler.response_timeout"/>
-      <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
-      <stringProp name="HTTPSampler.contentEncoding"/>
-      <stringProp name="HTTPSampler.path">${base_path}${admin_path}</stringProp>
-      <stringProp name="HTTPSampler.method">GET</stringProp>
-      <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
-      <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
-      <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
-      <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
-      <boolProp name="HTTPSampler.monitor">false</boolProp>
-      <stringProp name="HTTPSampler.embedded_url_re"/>
-    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_login/admin_login.jmx</stringProp></HTTPSamplerProxy>
-    <hashTree>
-      <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert login form shown" enabled="true">
-        <collectionProp name="Asserion.test_strings">
-          <stringProp name="-1397214398">Welcome</stringProp>
-          <stringProp name="-515240035">&lt;title&gt;Magento Admin&lt;/title&gt;</stringProp>
-        </collectionProp>
-        <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
-        <boolProp name="Assertion.assume_success">false</boolProp>
-        <intProp name="Assertion.test_type">2</intProp>
-      </ResponseAssertion>
-      <hashTree/>
-      <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract form key" enabled="true">
-        <stringProp name="RegexExtractor.useHeaders">false</stringProp>
-        <stringProp name="RegexExtractor.refname">admin_form_key</stringProp>
-        <stringProp name="RegexExtractor.regex">&lt;input name="form_key" type="hidden" value="([^'"]+)" /&gt;</stringProp>
-        <stringProp name="RegexExtractor.template">$1$</stringProp>
-        <stringProp name="RegexExtractor.default"/>
-        <stringProp name="RegexExtractor.match_number">1</stringProp>
-      </RegexExtractor>
-      <hashTree/>
-      <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert form_key extracted" enabled="true">
-        <collectionProp name="Asserion.test_strings">
-          <stringProp name="2845929">^.+$</stringProp>
-        </collectionProp>
-        <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
-        <boolProp name="Assertion.assume_success">false</boolProp>
-        <intProp name="Assertion.test_type">1</intProp>
-        <stringProp name="Assertion.scope">variable</stringProp>
-        <stringProp name="Scope.variable">admin_form_key</stringProp>
-      </ResponseAssertion>
-      <hashTree/>
-    </hashTree>
-  
-    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="SetUp - Login Submit Form" enabled="true">
-      <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
-        <collectionProp name="Arguments.arguments">
-          <elementProp name="dummy" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value"/>
-            <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">dummy</stringProp>
-          </elementProp>
-          <elementProp name="form_key" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">${admin_form_key}</stringProp>
-            <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">form_key</stringProp>
-          </elementProp>
-          <elementProp name="login[password]" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">${admin_password}</stringProp>
-            <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">login[password]</stringProp>
-          </elementProp>
-          <elementProp name="login[username]" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">${admin_user}</stringProp>
-            <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">login[username]</stringProp>
-          </elementProp>
-        </collectionProp>
-      </elementProp>
-      <stringProp name="HTTPSampler.domain"/>
-      <stringProp name="HTTPSampler.port"/>
-      <stringProp name="HTTPSampler.connect_timeout"/>
-      <stringProp name="HTTPSampler.response_timeout"/>
-      <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
-      <stringProp name="HTTPSampler.contentEncoding"/>
-      <stringProp name="HTTPSampler.path">${base_path}${admin_path}/admin/dashboard/</stringProp>
-      <stringProp name="HTTPSampler.method">POST</stringProp>
-      <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
-      <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
-      <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
-      <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
-      <stringProp name="HTTPSampler.implementation">Java</stringProp>
-      <boolProp name="HTTPSampler.monitor">false</boolProp>
-      <stringProp name="HTTPSampler.embedded_url_re"/>
-      <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_login/admin_login_submit_form.jmx</stringProp>
-    </HTTPSamplerProxy>
-    <hashTree>
-        <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract form key" enabled="true">
-            <stringProp name="RegexExtractor.useHeaders">false</stringProp>
-            <stringProp name="RegexExtractor.refname">admin_form_key</stringProp>
-            <stringProp name="RegexExtractor.regex">&lt;input name="form_key" type="hidden" value="([^'"]+)" /&gt;</stringProp>
-            <stringProp name="RegexExtractor.template">$1$</stringProp>
-            <stringProp name="RegexExtractor.default"/>
-            <stringProp name="RegexExtractor.match_number">1</stringProp>
-        <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_login/admin_retrieve_form_key.jmx</stringProp></RegexExtractor>
-        <hashTree/>
-    </hashTree>
-  </hashTree>
-  
-    <GenericController guiclass="LogicControllerGui" testclass="GenericController" testname="Simple Controller" enabled="true">
-  <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/simple_controller.jmx</stringProp>
-</GenericController>
-    <hashTree>
-  <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Orders page" enabled="true">
-    <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
-      <collectionProp name="Arguments.arguments"/>
-    </elementProp>
-    <stringProp name="HTTPSampler.domain"/>
-    <stringProp name="HTTPSampler.port"/>
-    <stringProp name="HTTPSampler.connect_timeout"/>
-    <stringProp name="HTTPSampler.response_timeout"/>
-    <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
-    <stringProp name="HTTPSampler.contentEncoding"/>
-    <stringProp name="HTTPSampler.path">${base_path}${admin_path}/sales/order/</stringProp>
-    <stringProp name="HTTPSampler.method">GET</stringProp>
-    <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
-    <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
-    <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
-    <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
-    <boolProp name="HTTPSampler.monitor">false</boolProp>
-    <stringProp name="HTTPSampler.embedded_url_re"/>
-  <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_create_process_returns/orders_page.jmx</stringProp></HTTPSamplerProxy>
-  <hashTree>
-    <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Response Assertion" enabled="true">
-      <collectionProp name="Asserion.test_strings">
-        <stringProp name="1204796042">Create New Order</stringProp>
-      </collectionProp>
-      <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
-      <boolProp name="Assertion.assume_success">false</boolProp>
-      <intProp name="Assertion.test_type">2</intProp>
-    </ResponseAssertion>
-    <hashTree/>
-  </hashTree>
-
-  <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Open Orders" enabled="true">
-    <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
-      <collectionProp name="Arguments.arguments">
-        <elementProp name="namespace" elementType="HTTPArgument">
-          <boolProp name="HTTPArgument.always_encode">true</boolProp>
-          <stringProp name="Argument.value">sales_order_grid</stringProp>
-          <stringProp name="Argument.metadata">=</stringProp>
-          <boolProp name="HTTPArgument.use_equals">true</boolProp>
-          <stringProp name="Argument.name">namespace</stringProp>
-        </elementProp>
-        <elementProp name="search" elementType="HTTPArgument">
-          <boolProp name="HTTPArgument.always_encode">true</boolProp>
-          <stringProp name="Argument.value"/>
-          <stringProp name="Argument.metadata">=</stringProp>
-          <boolProp name="HTTPArgument.use_equals">true</boolProp>
-          <stringProp name="Argument.name">search</stringProp>
-        </elementProp>
-        <elementProp name="filters[placeholder]" elementType="HTTPArgument">
-          <boolProp name="HTTPArgument.always_encode">true</boolProp>
-          <stringProp name="Argument.value">true</stringProp>
-          <stringProp name="Argument.metadata">=</stringProp>
-          <boolProp name="HTTPArgument.use_equals">true</boolProp>
-          <stringProp name="Argument.name">filters[placeholder]</stringProp>
-        </elementProp>
-        <elementProp name="paging[pageSize]" elementType="HTTPArgument">
-          <boolProp name="HTTPArgument.always_encode">true</boolProp>
-          <stringProp name="Argument.value">200</stringProp>
-          <stringProp name="Argument.metadata">=</stringProp>
-          <boolProp name="HTTPArgument.use_equals">true</boolProp>
-          <stringProp name="Argument.name">paging[pageSize]</stringProp>
-        </elementProp>
-        <elementProp name="paging[current]" elementType="HTTPArgument">
-          <boolProp name="HTTPArgument.always_encode">true</boolProp>
-          <stringProp name="Argument.value">1</stringProp>
-          <stringProp name="Argument.metadata">=</stringProp>
-          <boolProp name="HTTPArgument.use_equals">true</boolProp>
-          <stringProp name="Argument.name">paging[current]</stringProp>
-        </elementProp>
-        <elementProp name="sorting[field]" elementType="HTTPArgument">
-          <boolProp name="HTTPArgument.always_encode">true</boolProp>
-          <stringProp name="Argument.value">increment_id</stringProp>
-          <stringProp name="Argument.metadata">=</stringProp>
-          <boolProp name="HTTPArgument.use_equals">true</boolProp>
-          <stringProp name="Argument.name">sorting[field]</stringProp>
-        </elementProp>
-        <elementProp name="sorting[direction]" elementType="HTTPArgument">
-          <boolProp name="HTTPArgument.always_encode">true</boolProp>
-          <stringProp name="Argument.value">desc</stringProp>
-          <stringProp name="Argument.metadata">=</stringProp>
-          <boolProp name="HTTPArgument.use_equals">true</boolProp>
-          <stringProp name="Argument.name">sorting[direction]</stringProp>
-        </elementProp>
-        <elementProp name="isAjax" elementType="HTTPArgument">
-          <boolProp name="HTTPArgument.always_encode">true</boolProp>
-          <stringProp name="Argument.value">true</stringProp>
-          <stringProp name="Argument.metadata">=</stringProp>
-          <boolProp name="HTTPArgument.use_equals">true</boolProp>
-          <stringProp name="Argument.name">isAjax</stringProp>
-        </elementProp>
-        <elementProp name="form_key" elementType="HTTPArgument">
-          <boolProp name="HTTPArgument.always_encode">true</boolProp>
-          <stringProp name="Argument.value">${admin_form_key}</stringProp>
-          <stringProp name="Argument.metadata">=</stringProp>
-          <boolProp name="HTTPArgument.use_equals">true</boolProp>
-          <stringProp name="Argument.name">form_key</stringProp>
-          <stringProp name="Argument.desc">false</stringProp>
-        </elementProp>
-        <elementProp name="filters[status]" elementType="HTTPArgument">
-          <boolProp name="HTTPArgument.always_encode">true</boolProp>
-          <stringProp name="Argument.value">pending</stringProp>
-          <stringProp name="Argument.metadata">=</stringProp>
-          <boolProp name="HTTPArgument.use_equals">true</boolProp>
-          <stringProp name="Argument.name">filters[status]</stringProp>
-          <stringProp name="Argument.desc">true</stringProp>
-        </elementProp>
-        <elementProp name="_" elementType="HTTPArgument">
-          <boolProp name="HTTPArgument.always_encode">true</boolProp>
-          <stringProp name="Argument.value">${__time()}${__Random(1,1000000)}</stringProp>
-          <stringProp name="Argument.metadata">=</stringProp>
-          <boolProp name="HTTPArgument.use_equals">true</boolProp>
-          <stringProp name="Argument.name">_</stringProp>
-        </elementProp>
-      </collectionProp>
-    </elementProp>
-    <stringProp name="HTTPSampler.domain"/>
-    <stringProp name="HTTPSampler.port"/>
-    <stringProp name="HTTPSampler.connect_timeout"/>
-    <stringProp name="HTTPSampler.response_timeout"/>
-    <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
-    <stringProp name="HTTPSampler.contentEncoding"/>
-    <stringProp name="HTTPSampler.path">${base_path}${admin_path}/mui/index/render/</stringProp>
-    <stringProp name="HTTPSampler.method">GET</stringProp>
-    <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
-    <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
-    <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
-    <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
-    <boolProp name="HTTPSampler.monitor">false</boolProp>
-    <stringProp name="HTTPSampler.embedded_url_re"/>
-  <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_create_process_returns/open_orders.jmx</stringProp></HTTPSamplerProxy>
-  <hashTree>
-    <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Response Assertion" enabled="true">
-      <collectionProp name="Asserion.test_strings">
-        <stringProp name="1637639774">totalRecords</stringProp>
-      </collectionProp>
-      <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
-      <boolProp name="Assertion.assume_success">false</boolProp>
-      <intProp name="Assertion.test_type">2</intProp>
-    </ResponseAssertion>
-    <hashTree/>
-  </hashTree>
-
-  <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Search Pending Orders" enabled="true">
-    <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
-      <collectionProp name="Arguments.arguments">
-        <elementProp name="form_key" elementType="HTTPArgument">
-          <boolProp name="HTTPArgument.always_encode">true</boolProp>
-          <stringProp name="Argument.value">${admin_form_key}</stringProp>
-          <stringProp name="Argument.metadata">=</stringProp>
-          <boolProp name="HTTPArgument.use_equals">true</boolProp>
-          <stringProp name="Argument.name">form_key</stringProp>
-        </elementProp>
-        <elementProp name="namespace" elementType="HTTPArgument">
-          <boolProp name="HTTPArgument.always_encode">true</boolProp>
-          <stringProp name="Argument.value">sales_order_grid</stringProp>
-          <stringProp name="Argument.metadata">=</stringProp>
-          <boolProp name="HTTPArgument.use_equals">true</boolProp>
-          <stringProp name="Argument.name">namespace</stringProp>
-          <stringProp name="Argument.desc">true</stringProp>
-        </elementProp>
-        <elementProp name="search" elementType="HTTPArgument">
-          <boolProp name="HTTPArgument.always_encode">true</boolProp>
-          <stringProp name="Argument.value"/>
-          <stringProp name="Argument.metadata">=</stringProp>
-          <boolProp name="HTTPArgument.use_equals">true</boolProp>
-          <stringProp name="Argument.name">search</stringProp>
-          <stringProp name="Argument.desc">true</stringProp>
-        </elementProp>
-        <elementProp name="filters[placeholder]" elementType="HTTPArgument">
-          <boolProp name="HTTPArgument.always_encode">true</boolProp>
-          <stringProp name="Argument.value">true</stringProp>
-          <stringProp name="Argument.metadata">=</stringProp>
-          <boolProp name="HTTPArgument.use_equals">true</boolProp>
-          <stringProp name="Argument.name">filters[placeholder]</stringProp>
-          <stringProp name="Argument.desc">true</stringProp>
-        </elementProp>
-        <elementProp name="paging[pageSize]" elementType="HTTPArgument">
-          <boolProp name="HTTPArgument.always_encode">true</boolProp>
-          <stringProp name="Argument.value">200</stringProp>
-          <stringProp name="Argument.metadata">=</stringProp>
-          <boolProp name="HTTPArgument.use_equals">true</boolProp>
-          <stringProp name="Argument.name">paging[pageSize]</stringProp>
-          <stringProp name="Argument.desc">true</stringProp>
-        </elementProp>
-        <elementProp name="paging[current]" elementType="HTTPArgument">
-          <boolProp name="HTTPArgument.always_encode">true</boolProp>
-          <stringProp name="Argument.value">1</stringProp>
-          <stringProp name="Argument.metadata">=</stringProp>
-          <boolProp name="HTTPArgument.use_equals">true</boolProp>
-          <stringProp name="Argument.name">paging[current]</stringProp>
-          <stringProp name="Argument.desc">true</stringProp>
-        </elementProp>
-        <elementProp name="sorting[field]" elementType="HTTPArgument">
-          <boolProp name="HTTPArgument.always_encode">true</boolProp>
-          <stringProp name="Argument.value">increment_id</stringProp>
-          <stringProp name="Argument.metadata">=</stringProp>
-          <boolProp name="HTTPArgument.use_equals">true</boolProp>
-          <stringProp name="Argument.name">sorting[field]</stringProp>
-          <stringProp name="Argument.desc">true</stringProp>
-        </elementProp>
-        <elementProp name="sorting[direction]" elementType="HTTPArgument">
-          <boolProp name="HTTPArgument.always_encode">true</boolProp>
-          <stringProp name="Argument.value">asc</stringProp>
-          <stringProp name="Argument.metadata">=</stringProp>
-          <boolProp name="HTTPArgument.use_equals">true</boolProp>
-          <stringProp name="Argument.name">sorting[direction]</stringProp>
-          <stringProp name="Argument.desc">true</stringProp>
-        </elementProp>
-        <elementProp name="isAjax" elementType="HTTPArgument">
-          <boolProp name="HTTPArgument.always_encode">true</boolProp>
-          <stringProp name="Argument.value">true</stringProp>
-          <stringProp name="Argument.metadata">=</stringProp>
-          <boolProp name="HTTPArgument.use_equals">true</boolProp>
-          <stringProp name="Argument.name">isAjax</stringProp>
-          <stringProp name="Argument.desc">true</stringProp>
-        </elementProp>
-        <elementProp name="filters[status]" elementType="HTTPArgument">
-          <boolProp name="HTTPArgument.always_encode">true</boolProp>
-          <stringProp name="Argument.value">pending</stringProp>
-          <stringProp name="Argument.metadata">=</stringProp>
-          <boolProp name="HTTPArgument.use_equals">true</boolProp>
-          <stringProp name="Argument.name">filters[status]</stringProp>
-        </elementProp>
-        <elementProp name="_" elementType="HTTPArgument">
-          <boolProp name="HTTPArgument.always_encode">true</boolProp>
-          <stringProp name="Argument.value">${__time()}${__Random(1,1000000)}</stringProp>
-          <stringProp name="Argument.metadata">=</stringProp>
-          <boolProp name="HTTPArgument.use_equals">true</boolProp>
-          <stringProp name="Argument.name">_</stringProp>
-        </elementProp>
-      </collectionProp>
-    </elementProp>
-    <stringProp name="HTTPSampler.domain"/>
-    <stringProp name="HTTPSampler.port"/>
-    <stringProp name="HTTPSampler.connect_timeout"/>
-    <stringProp name="HTTPSampler.response_timeout"/>
-    <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
-    <stringProp name="HTTPSampler.contentEncoding"/>
-    <stringProp name="HTTPSampler.path">${base_path}${admin_path}/mui/index/render/</stringProp>
-    <stringProp name="HTTPSampler.method">GET</stringProp>
-    <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
-    <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
-    <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
-    <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
-    <boolProp name="HTTPSampler.monitor">false</boolProp>
-    <stringProp name="HTTPSampler.embedded_url_re"/>
-  <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_create_process_returns/search_orders.jmx</stringProp></HTTPSamplerProxy>
-<hashTree>
-      <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Response Assertion" enabled="true">
-        <collectionProp name="Asserion.test_strings">
-          <stringProp name="1637639774">totalRecords</stringProp>
-        </collectionProp>
-        <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
-        <boolProp name="Assertion.assume_success">false</boolProp>
-        <intProp name="Assertion.test_type">2</intProp>
-      </ResponseAssertion>
-      <hashTree/>
-      <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract order numbers" enabled="true">
-        <stringProp name="RegexExtractor.useHeaders">false</stringProp>
-        <stringProp name="RegexExtractor.refname">order_numbers</stringProp>
-        <stringProp name="RegexExtractor.regex">\"increment_id\":\"(\d+)\"\,</stringProp>
-        <stringProp name="RegexExtractor.template">$1$</stringProp>
-        <stringProp name="RegexExtractor.default"/>
-        <stringProp name="RegexExtractor.match_number">-1</stringProp>
-        <stringProp name="Scope.variable">simple_products</stringProp>
-      </RegexExtractor>
-      <hashTree/>
-      <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract order ids" enabled="true">
-        <stringProp name="RegexExtractor.useHeaders">false</stringProp>
-        <stringProp name="RegexExtractor.refname">order_ids</stringProp>
-        <stringProp name="RegexExtractor.regex">\"entity_id\":\"(\d+)\"\,</stringProp>
-        <stringProp name="RegexExtractor.template">$1$</stringProp>
-        <stringProp name="RegexExtractor.default"/>
-        <stringProp name="RegexExtractor.match_number">-1</stringProp>
-        <stringProp name="Scope.variable">simple_products</stringProp>
-      </RegexExtractor>
-      <hashTree/>
-    </hashTree>
-
-      <BeanShellSampler guiclass="BeanShellSamplerGui" testclass="BeanShellSampler" testname="SetUp - Generate Unique Ids for each Thread" enabled="true">
-        <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_create_process_returns/setup.jmx</stringProp>
-        <stringProp name="BeanShellSampler.query">
-  import java.util.ArrayList;
-  import java.util.HashMap;
-  import org.apache.jmeter.protocol.http.util.Base64Encoder;
-  import java.util.Random;
-
-  // get count of "order_numbers" variable defined in "Search Pending Orders Limit"
-  int ordersCount = Integer.parseInt(vars.get("order_numbers_matchNr"));
-
-
-  int clusterLength;
-  int threadsNumber = ctx.getThreadGroup().getNumThreads();
-  if (threadsNumber == 0) {
-      //Number of orders for one thread
-      clusterLength = ordersCount;
-  } else {
-      clusterLength = Math.round(ordersCount / threadsNumber);
-      if (clusterLength == 0) {
-          clusterLength = 1;
-      }
-  }
-
-  //Current thread number starts from 0
-  int currentThreadNum = ctx.getThreadNum();
-
-  //Index of the current product from the cluster
-  Random random = new Random();
-  int iterator = random.nextInt(clusterLength);
-  if (iterator == 0) {
-  	iterator = 1;
-  }
-
-  int i = clusterLength * currentThreadNum + iterator;
-
-  orderNumber = vars.get("order_numbers_" + i.toString());
-  orderId = vars.get("order_ids_" + i.toString());
-  vars.put("order_number", orderNumber);
-  vars.put("order_id", orderId);
-
-  </stringProp>
-    <stringProp name="BeanShellSampler.filename"/>
-    <stringProp name="BeanShellSampler.parameters"/>
-    <boolProp name="BeanShellSampler.resetInterpreter">false</boolProp>
-  </BeanShellSampler>
-  <hashTree/>
-
-  <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Open Order" enabled="true">
-    <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
-      <collectionProp name="Arguments.arguments"/>
-    </elementProp>
-    <stringProp name="HTTPSampler.domain"/>
-    <stringProp name="HTTPSampler.port"/>
-    <stringProp name="HTTPSampler.connect_timeout"/>
-    <stringProp name="HTTPSampler.response_timeout"/>
-    <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
-    <stringProp name="HTTPSampler.contentEncoding"/>
-    <stringProp name="HTTPSampler.path">${base_path}${admin_path}/sales/order/view/order_id/${order_id}/</stringProp>
-    <stringProp name="HTTPSampler.method">GET</stringProp>
-    <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
-    <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
-    <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
-    <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
-    <boolProp name="HTTPSampler.monitor">false</boolProp>
-    <stringProp name="HTTPSampler.embedded_url_re"/>
-  <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_create_process_returns/open_order.jmx</stringProp></HTTPSamplerProxy>
-  <hashTree>
-    <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Response Assertion" enabled="true">
-      <collectionProp name="Asserion.test_strings">
-        <stringProp name="2103620713">#${order_number}</stringProp>
-      </collectionProp>
-      <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
-      <boolProp name="Assertion.assume_success">false</boolProp>
-      <intProp name="Assertion.test_type">2</intProp>
-    </ResponseAssertion>
-    <hashTree/>
-    <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract order status" enabled="true">
-      <stringProp name="RegexExtractor.useHeaders">false</stringProp>
-      <stringProp name="RegexExtractor.refname">order_status</stringProp>
-      <stringProp name="RegexExtractor.regex">&lt;span id="order_status"&gt;([^&lt;]+)&lt;/span&gt;</stringProp>
-      <stringProp name="RegexExtractor.template">$1$</stringProp>
-      <stringProp name="RegexExtractor.default"/>
-      <stringProp name="RegexExtractor.match_number">1</stringProp>
-      <stringProp name="Scope.variable">simple_products</stringProp>
-    </RegexExtractor>
-    <hashTree/>
-  </hashTree>
-
-    <IfController guiclass="IfControllerPanel" testclass="IfController" testname="If Controller" enabled="true">
-      <stringProp name="IfController.condition">"${order_status}" == "Pending"</stringProp>
-      <boolProp name="IfController.evaluateAll">false</boolProp>
-    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_edit_order/if_controller.jmx</stringProp></IfController>
-    <hashTree>
-  <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Invoice Start" enabled="true">
-    <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
-      <collectionProp name="Arguments.arguments"/>
-    </elementProp>
-    <stringProp name="HTTPSampler.domain"/>
-    <stringProp name="HTTPSampler.port"/>
-    <stringProp name="HTTPSampler.connect_timeout"/>
-    <stringProp name="HTTPSampler.response_timeout"/>
-    <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
-    <stringProp name="HTTPSampler.contentEncoding"/>
-    <stringProp name="HTTPSampler.path">${base_path}${admin_path}/sales/order_invoice/start/order_id/${order_id}/</stringProp>
-    <stringProp name="HTTPSampler.method">GET</stringProp>
-    <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
-    <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
-    <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
-    <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
-    <boolProp name="HTTPSampler.monitor">false</boolProp>
-    <stringProp name="HTTPSampler.embedded_url_re"/>
-  <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_create_process_returns/invoice_start.jmx</stringProp></HTTPSamplerProxy>
-  <hashTree>
-    <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Response Assertion" enabled="true">
-      <collectionProp name="Asserion.test_strings">
-        <stringProp name="-1233850814">Invoice Totals</stringProp>
-      </collectionProp>
-      <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
-      <boolProp name="Assertion.assume_success">false</boolProp>
-      <intProp name="Assertion.test_type">2</intProp>
-    </ResponseAssertion>
-    <hashTree/>
-    <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract ordered items ids" enabled="true">
-      <stringProp name="RegexExtractor.useHeaders">false</stringProp>
-      <stringProp name="RegexExtractor.refname">item_ids</stringProp>
-      <stringProp name="RegexExtractor.regex">&lt;div id="order_item_(\d+)_title"\s*class="product-title"&gt;</stringProp>
-      <stringProp name="RegexExtractor.template">$1$</stringProp>
-      <stringProp name="RegexExtractor.default"/>
-      <stringProp name="RegexExtractor.match_number">-1</stringProp>
-      <stringProp name="Scope.variable">simple_products</stringProp>
-    </RegexExtractor>
-    <hashTree/>
-  </hashTree>
-
-  <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Invoice Submit" enabled="true">
-    <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
-      <collectionProp name="Arguments.arguments">
-        <elementProp name="form_key" elementType="HTTPArgument">
-          <boolProp name="HTTPArgument.always_encode">true</boolProp>
-          <stringProp name="Argument.value">${admin_form_key}</stringProp>
-          <stringProp name="Argument.metadata">=</stringProp>
-          <boolProp name="HTTPArgument.use_equals">true</boolProp>
-          <stringProp name="Argument.name">form_key</stringProp>
-          <stringProp name="Argument.desc">false</stringProp>
-        </elementProp>
-        <elementProp name="invoice[items][${item_ids_1}]" elementType="HTTPArgument">
-          <boolProp name="HTTPArgument.always_encode">true</boolProp>
-          <stringProp name="Argument.value">1</stringProp>
-          <stringProp name="Argument.metadata">=</stringProp>
-          <boolProp name="HTTPArgument.use_equals">true</boolProp>
-          <stringProp name="Argument.name">invoice[items][${item_ids_1}]</stringProp>
-        </elementProp>
-        <elementProp name="invoice[items][${item_ids_2}]" elementType="HTTPArgument">
-          <boolProp name="HTTPArgument.always_encode">true</boolProp>
-          <stringProp name="Argument.value">1</stringProp>
-          <stringProp name="Argument.metadata">=</stringProp>
-          <boolProp name="HTTPArgument.use_equals">true</boolProp>
-          <stringProp name="Argument.name">invoice[items][${item_ids_2}]</stringProp>
-        </elementProp>
-        <elementProp name="invoice[comment_text]" elementType="HTTPArgument">
-          <boolProp name="HTTPArgument.always_encode">true</boolProp>
-          <stringProp name="Argument.value">Invoiced</stringProp>
-          <stringProp name="Argument.metadata">=</stringProp>
-          <boolProp name="HTTPArgument.use_equals">true</boolProp>
-          <stringProp name="Argument.name">invoice[comment_text]</stringProp>
-        </elementProp>
-      </collectionProp>
-    </elementProp>
-    <stringProp name="HTTPSampler.domain"/>
-    <stringProp name="HTTPSampler.port"/>
-    <stringProp name="HTTPSampler.connect_timeout"/>
-    <stringProp name="HTTPSampler.response_timeout"/>
-    <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
-    <stringProp name="HTTPSampler.contentEncoding"/>
-    <stringProp name="HTTPSampler.path">${base_path}${admin_path}/sales/order_invoice/save/order_id/${order_id}/</stringProp>
-    <stringProp name="HTTPSampler.method">POST</stringProp>
-    <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
-    <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
-    <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
-    <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
-    <boolProp name="HTTPSampler.monitor">false</boolProp>
-    <stringProp name="HTTPSampler.embedded_url_re"/>
-  <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_create_process_returns/invoice_submit.jmx</stringProp></HTTPSamplerProxy>
-  <hashTree>
-    <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Response Assertion" enabled="true">
-      <collectionProp name="Asserion.test_strings">
-        <stringProp name="1740524604">The invoice has been created</stringProp>
-      </collectionProp>
-      <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
-      <boolProp name="Assertion.assume_success">false</boolProp>
-      <intProp name="Assertion.test_type">2</intProp>
-    </ResponseAssertion>
-    <hashTree/>
-  </hashTree>
-
-  <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Credit Memo Start" enabled="true">
-    <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
-      <collectionProp name="Arguments.arguments"/>
-    </elementProp>
-    <stringProp name="HTTPSampler.domain"/>
-    <stringProp name="HTTPSampler.port"/>
-    <stringProp name="HTTPSampler.connect_timeout"/>
-    <stringProp name="HTTPSampler.response_timeout"/>
-    <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
-    <stringProp name="HTTPSampler.contentEncoding"/>
-    <stringProp name="HTTPSampler.path">${base_path}${admin_path}/sales/order_creditmemo/start/order_id/${order_id}/</stringProp>
-    <stringProp name="HTTPSampler.method">GET</stringProp>
-    <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
-    <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
-    <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
-    <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
-    <boolProp name="HTTPSampler.monitor">false</boolProp>
-    <stringProp name="HTTPSampler.embedded_url_re"/>
-  <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_create_process_returns/credit_memo_start.jmx</stringProp></HTTPSamplerProxy>
-  <hashTree>
-    <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Response Assertion" enabled="true">
-      <collectionProp name="Asserion.test_strings">
-        <stringProp name="1382627322">New Memo</stringProp>
-      </collectionProp>
-      <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
-      <boolProp name="Assertion.assume_success">false</boolProp>
-      <intProp name="Assertion.test_type">2</intProp>
-    </ResponseAssertion>
-    <hashTree/>
-  </hashTree>
-
-    <RandomController guiclass="RandomControlGui" testclass="RandomController" testname="Random Controller" enabled="true">
-        <intProp name="InterleaveControl.style">1</intProp>
-    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_create_process_returns/credit_memo_submit.jmx</stringProp></RandomController>
-        <hashTree>
-            <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Credit Memo Submit - Full Refund" enabled="true">
-              <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
-                <collectionProp name="Arguments.arguments">
-                  <elementProp name="form_key" elementType="HTTPArgument">
-                    <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                    <stringProp name="Argument.value">${admin_form_key}</stringProp>
-                    <stringProp name="Argument.metadata">=</stringProp>
-                    <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                    <stringProp name="Argument.name">form_key</stringProp>
-                    <stringProp name="Argument.desc">false</stringProp>
-                  </elementProp>
-                  <elementProp name="creditmemo[items][${item_ids_1}][qty]" elementType="HTTPArgument">
-                    <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                    <stringProp name="Argument.value">1</stringProp>
-                    <stringProp name="Argument.metadata">=</stringProp>
-                    <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                    <stringProp name="Argument.name">creditmemo[items][${item_ids_1}][qty]</stringProp>
-                  </elementProp>
-                  <elementProp name="creditmemo[items][${item_ids_2}][qty]" elementType="HTTPArgument">
-                    <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                    <stringProp name="Argument.value">1</stringProp>
-                    <stringProp name="Argument.metadata">=</stringProp>
-                    <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                    <stringProp name="Argument.name">creditmemo[items][${item_ids_2}][qty]</stringProp>
-                  </elementProp>
-                  <elementProp name="creditmemo[do_offline]" elementType="HTTPArgument">
-                    <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                    <stringProp name="Argument.value">1</stringProp>
-                    <stringProp name="Argument.metadata">=</stringProp>
-                    <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                    <stringProp name="Argument.name">creditmemo[do_offline]</stringProp>
-                  </elementProp>
-                  <elementProp name="creditmemo[comment_text]" elementType="HTTPArgument">
-                    <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                    <stringProp name="Argument.value">Credit Memo added</stringProp>
-                    <stringProp name="Argument.metadata">=</stringProp>
-                    <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                    <stringProp name="Argument.name">creditmemo[comment_text]</stringProp>
-                  </elementProp>
-                  <elementProp name="creditmemo[shipping_amount]" elementType="HTTPArgument">
-                    <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                    <stringProp name="Argument.value">10</stringProp>
-                    <stringProp name="Argument.metadata">=</stringProp>
-                    <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                    <stringProp name="Argument.name">creditmemo[shipping_amount]</stringProp>
-                  </elementProp>
-                  <elementProp name="creditmemo[adjustment_positive]" elementType="HTTPArgument">
-                    <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                    <stringProp name="Argument.value">0</stringProp>
-                    <stringProp name="Argument.metadata">=</stringProp>
-                    <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                    <stringProp name="Argument.name">creditmemo[adjustment_positive]</stringProp>
-                  </elementProp>
-                  <elementProp name="creditmemo[adjustment_negative]" elementType="HTTPArgument">
-                    <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                    <stringProp name="Argument.value">0</stringProp>
-                    <stringProp name="Argument.metadata">=</stringProp>
-                    <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                    <stringProp name="Argument.name">creditmemo[adjustment_negative]</stringProp>
-                  </elementProp>
-                </collectionProp>
-              </elementProp>
-              <stringProp name="HTTPSampler.domain"/>
-              <stringProp name="HTTPSampler.port"/>
-              <stringProp name="HTTPSampler.connect_timeout"/>
-              <stringProp name="HTTPSampler.response_timeout"/>
-              <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
-              <stringProp name="HTTPSampler.contentEncoding"/>
-              <stringProp name="HTTPSampler.path">${base_path}${admin_path}/sales/order_creditmemo/save/order_id/${order_id}/</stringProp>
-              <stringProp name="HTTPSampler.method">POST</stringProp>
-              <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
-              <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
-              <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
-              <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
-              <boolProp name="HTTPSampler.monitor">false</boolProp>
-              <stringProp name="HTTPSampler.embedded_url_re"/>
-            </HTTPSamplerProxy>
-            <hashTree>
-              <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Response Assertion" enabled="true">
-                <collectionProp name="Asserion.test_strings">
-                  <stringProp name="-515117447">You created the credit memo</stringProp>
-                </collectionProp>
-                <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
-                <boolProp name="Assertion.assume_success">false</boolProp>
-                <intProp name="Assertion.test_type">2</intProp>
-              </ResponseAssertion>
-              <hashTree/>
-            </hashTree>
-            <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Credit Memo Submit - Partial Refund" enabled="true">
-              <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
-                <collectionProp name="Arguments.arguments">
-                  <elementProp name="form_key" elementType="HTTPArgument">
-                    <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                    <stringProp name="Argument.value">${admin_form_key}</stringProp>
-                    <stringProp name="Argument.metadata">=</stringProp>
-                    <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                    <stringProp name="Argument.name">form_key</stringProp>
-                    <stringProp name="Argument.desc">false</stringProp>
-                  </elementProp>
-                  <elementProp name="creditmemo[items][${item_ids_1}][qty]" elementType="HTTPArgument">
-                    <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                    <stringProp name="Argument.value">1</stringProp>
-                    <stringProp name="Argument.metadata">=</stringProp>
-                    <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                    <stringProp name="Argument.name">creditmemo[items][${item_ids_1}][qty]</stringProp>
-                  </elementProp>
-                  <elementProp name="creditmemo[do_offline]" elementType="HTTPArgument">
-                    <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                    <stringProp name="Argument.value">1</stringProp>
-                    <stringProp name="Argument.metadata">=</stringProp>
-                    <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                    <stringProp name="Argument.name">creditmemo[do_offline]</stringProp>
-                  </elementProp>
-                  <elementProp name="creditmemo[comment_text]" elementType="HTTPArgument">
-                    <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                    <stringProp name="Argument.value">Credit Memo added</stringProp>
-                    <stringProp name="Argument.metadata">=</stringProp>
-                    <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                    <stringProp name="Argument.name">creditmemo[comment_text]</stringProp>
-                  </elementProp>
-                  <elementProp name="creditmemo[shipping_amount]" elementType="HTTPArgument">
-                    <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                    <stringProp name="Argument.value">10</stringProp>
-                    <stringProp name="Argument.metadata">=</stringProp>
-                    <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                    <stringProp name="Argument.name">creditmemo[shipping_amount]</stringProp>
-                  </elementProp>
-                  <elementProp name="creditmemo[adjustment_positive]" elementType="HTTPArgument">
-                    <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                    <stringProp name="Argument.value">0</stringProp>
-                    <stringProp name="Argument.metadata">=</stringProp>
-                    <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                    <stringProp name="Argument.name">creditmemo[adjustment_positive]</stringProp>
-                  </elementProp>
-                  <elementProp name="creditmemo[adjustment_negative]" elementType="HTTPArgument">
-                    <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                    <stringProp name="Argument.value">0</stringProp>
-                    <stringProp name="Argument.metadata">=</stringProp>
-                    <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                    <stringProp name="Argument.name">creditmemo[adjustment_negative]</stringProp>
-                  </elementProp>
-                </collectionProp>
-              </elementProp>
-              <stringProp name="HTTPSampler.domain"/>
-              <stringProp name="HTTPSampler.port"/>
-              <stringProp name="HTTPSampler.connect_timeout"/>
-              <stringProp name="HTTPSampler.response_timeout"/>
-              <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
-              <stringProp name="HTTPSampler.contentEncoding"/>
-              <stringProp name="HTTPSampler.path">${base_path}${admin_path}/sales/order_creditmemo/save/order_id/${order_id}/</stringProp>
-              <stringProp name="HTTPSampler.method">POST</stringProp>
-              <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
-              <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
-              <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
-              <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
-              <boolProp name="HTTPSampler.monitor">false</boolProp>
-              <stringProp name="HTTPSampler.embedded_url_re"/>
-            </HTTPSamplerProxy>
-            <hashTree>
-              <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Response Assertion" enabled="true">
-                <collectionProp name="Asserion.test_strings">
-                  <stringProp name="-515117447">You created the credit memo</stringProp>
-                </collectionProp>
-                <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
-                <boolProp name="Assertion.assume_success">false</boolProp>
-                <intProp name="Assertion.test_type">2</intProp>
-              </ResponseAssertion>
-              <hashTree/>
-            </hashTree>
-          </hashTree>
-
-    <TestAction guiclass="TestActionGui" testclass="TestAction" testname="Create/Process Returns - Pause" enabled="true">
-      <intProp name="ActionProcessor.action">1</intProp>
-      <intProp name="ActionProcessor.target">0</intProp>
-      <stringProp name="ActionProcessor.duration">${__javaScript(Math.round(${adminCreateProcessReturnsDelay}*1000))}</stringProp>
-    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_create_process_returns/pause.jmx</stringProp></TestAction>
-    <hashTree/>
-  </hashTree>
-  </hashTree>
-  </hashTree>
-
-  
-    <ThroughputController guiclass="ThroughputControllerGui" testclass="ThroughputController" testname="Browse Customer Grid" enabled="true">
-      <intProp name="ThroughputController.style">1</intProp>
-      <boolProp name="ThroughputController.perThread">false</boolProp>
-      <intProp name="ThroughputController.maxThroughput">1</intProp>
-      <stringProp name="ThroughputController.percentThroughput">${browseCustomerGridPercentage}</stringProp>
-    <stringProp name="TestPlan.comments">mpaf/tool/fragments/_system/scenario_controller_tmpl.jmx</stringProp></ThroughputController>
-    <hashTree>
-        <JSR223PreProcessor guiclass="TestBeanGUI" testclass="JSR223PreProcessor" testname="Set Test Label" enabled="true">
-            <stringProp name="script">
-var testLabel = "${testLabel}" ? " (${testLabel})" : "";
-if (testLabel
-    &amp;&amp; sampler.getClass().getName() == 'org.apache.jmeter.protocol.http.sampler.HTTPSamplerProxy'
-) {
-    if (sampler.getName().indexOf(testLabel) == -1) {
-       sampler.setName(sampler.getName() + testLabel);
-    }
-} else if (sampler.getName().indexOf("SetUp - ") == -1) {
-    sampler.setName("SetUp - " + sampler.getName());
-}
-            </stringProp>
-            <stringProp name="scriptLanguage">javascript</stringProp>
-        <stringProp name="TestPlan.comments">mpaf/tool/fragments/_system/setup_label.jmx</stringProp></JSR223PreProcessor>
-        <hashTree/>
-        <BeanShellSampler guiclass="BeanShellSamplerGui" testclass="BeanShellSampler" testname="SetUp - Set Label" enabled="true">
-            <stringProp name="BeanShellSampler.query">
-                vars.put("testLabel", "Browse Customer Grid");
-            </stringProp>
-            <boolProp name="BeanShellSampler.resetInterpreter">true</boolProp>
-        </BeanShellSampler>
-        <hashTree/>
-    
-        <JSR223PostProcessor guiclass="TestBeanGUI" testclass="JSR223PostProcessor" testname="Get admin form key PostProcessor" enabled="true">
-        <stringProp name="script">
-        function getFormKeyFromResponse()
-        {
-            var url = prev.getUrlAsString(),
-            responseCode =  prev.getResponseCode(),
-            formKey = null;
-            searchPattern = /var FORM_KEY = '(.+)'/;
-            if (responseCode == "200" &amp;&amp; url) {
-                response = prev.getResponseDataAsString();
-                formKey = response  &amp;&amp; response.match(searchPattern) ? response.match(searchPattern)[1] : null;
-            }
-            return formKey;
-        }
-
-        formKey = vars.get("form_key_storage");
-
-	   currentFormKey = getFormKeyFromResponse();
-
-	   if (currentFormKey != null &amp;&amp; currentFormKey != formKey) {
-		  vars.put("form_key_storage", currentFormKey);
-	   }
-        </stringProp>
-        <stringProp name="scriptLanguage">javascript</stringProp>
-        <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin/handle_admin_form_key.jmx</stringProp></JSR223PostProcessor>
-        <hashTree/>
-        <JSR223PreProcessor guiclass="TestBeanGUI" testclass="JSR223PreProcessor" testname="Set admin form key PreProcessor" enabled="true">
-            <stringProp name="script">
-                formKey =  vars.get("form_key_storage");
-                if (formKey
-                    &amp;&amp; sampler.getClass().getName() == 'org.apache.jmeter.protocol.http.sampler.HTTPSamplerProxy'
-                    &amp;&amp; sampler.getMethod() == "POST")
-                    {
-                        arguments = sampler.getArguments();
-                        for (i=0; i&lt;arguments.getArgumentCount(); i++)
-                        {
-                            argument = arguments.getArgument(i);
-                            if (argument.getName() == 'form_key' &amp;&amp; argument.getValue() != formKey) {
-                            log.info("admin form key updated: " + argument.getValue() + " =&gt; " + formKey);
-                            argument.setValue(formKey);
-                        }
-                    }
-                }
-            </stringProp>
-            <stringProp name="scriptLanguage">javascript</stringProp>
-        </JSR223PreProcessor>
-        <hashTree/>
-    
-    <CookieManager guiclass="CookiePanel" testclass="CookieManager" testname="HTTP Cookie Manager" enabled="true">
-      <collectionProp name="CookieManager.cookies"/>
-      <boolProp name="CookieManager.clearEachIteration">false</boolProp>
-    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/http_cookie_manager_without_clear_each_iteration.jmx</stringProp></CookieManager>
-    <hashTree/>
-  
-    <JSR223PostProcessor guiclass="TestBeanGUI" testclass="JSR223PreProcessor" testname="SetUp - Set Arguments" enabled="true">
-      <stringProp name="script">
-        vars.put("gridEntityType" , "Customer");
-
-        pagesCount = parseInt(vars.get("customers_page_size")) || 20;
-        vars.put("grid_entity_page_size" , pagesCount);
-        vars.put("grid_namespace" , "customer_listing");
-        vars.put("grid_admin_browse_filter_text" , vars.get("admin_browse_customer_filter_text"));
-        vars.put("grid_filter_field", "name");
-
-        // set sort fields and sort directions
-        vars.put("grid_sort_field_1", "name");
-        vars.put("grid_sort_field_2", "group_id");
-        vars.put("grid_sort_field_3", "billing_country_id");
-        vars.put("grid_sort_order_1", "asc");
-        vars.put("grid_sort_order_2", "desc");
-      </stringProp>
-      <stringProp name="scriptLanguage">javascript</stringProp>
-    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_browse_customers_grid/setup.jmx</stringProp></JSR223PostProcessor>
-    <hashTree/>
-  
-    <OnceOnlyController guiclass="OnceOnlyControllerGui" testclass="OnceOnlyController" testname="Once Only Controller" enabled="true">
-  <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/once_only_controller.jmx</stringProp>
-</OnceOnlyController>
-    <hashTree>
-    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="SetUp - Login" enabled="true">
-      <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
-        <collectionProp name="Arguments.arguments"/>
-      </elementProp>
-      <stringProp name="HTTPSampler.domain"/>
-      <stringProp name="HTTPSampler.port"/>
-      <stringProp name="HTTPSampler.connect_timeout"/>
-      <stringProp name="HTTPSampler.response_timeout"/>
-      <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
-      <stringProp name="HTTPSampler.contentEncoding"/>
-      <stringProp name="HTTPSampler.path">${base_path}${admin_path}</stringProp>
-      <stringProp name="HTTPSampler.method">GET</stringProp>
-      <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
-      <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
-      <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
-      <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
-      <boolProp name="HTTPSampler.monitor">false</boolProp>
-      <stringProp name="HTTPSampler.embedded_url_re"/>
-    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_login/admin_login.jmx</stringProp></HTTPSamplerProxy>
-    <hashTree>
-      <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert login form shown" enabled="true">
-        <collectionProp name="Asserion.test_strings">
-          <stringProp name="-1397214398">Welcome</stringProp>
-          <stringProp name="-515240035">&lt;title&gt;Magento Admin&lt;/title&gt;</stringProp>
-        </collectionProp>
-        <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
-        <boolProp name="Assertion.assume_success">false</boolProp>
-        <intProp name="Assertion.test_type">2</intProp>
-      </ResponseAssertion>
-      <hashTree/>
-      <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract form key" enabled="true">
-        <stringProp name="RegexExtractor.useHeaders">false</stringProp>
-        <stringProp name="RegexExtractor.refname">admin_form_key</stringProp>
-        <stringProp name="RegexExtractor.regex">&lt;input name="form_key" type="hidden" value="([^'"]+)" /&gt;</stringProp>
-        <stringProp name="RegexExtractor.template">$1$</stringProp>
-        <stringProp name="RegexExtractor.default"/>
-        <stringProp name="RegexExtractor.match_number">1</stringProp>
-      </RegexExtractor>
-      <hashTree/>
-      <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert form_key extracted" enabled="true">
-        <collectionProp name="Asserion.test_strings">
-          <stringProp name="2845929">^.+$</stringProp>
-        </collectionProp>
-        <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
-        <boolProp name="Assertion.assume_success">false</boolProp>
-        <intProp name="Assertion.test_type">1</intProp>
-        <stringProp name="Assertion.scope">variable</stringProp>
-        <stringProp name="Scope.variable">admin_form_key</stringProp>
-      </ResponseAssertion>
-      <hashTree/>
-    </hashTree>
-  
-    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="SetUp - Login Submit Form" enabled="true">
-      <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
-        <collectionProp name="Arguments.arguments">
-          <elementProp name="dummy" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value"/>
-            <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">dummy</stringProp>
-          </elementProp>
-          <elementProp name="form_key" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">${admin_form_key}</stringProp>
-            <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">form_key</stringProp>
-          </elementProp>
-          <elementProp name="login[password]" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">${admin_password}</stringProp>
-            <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">login[password]</stringProp>
-          </elementProp>
-          <elementProp name="login[username]" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">${admin_user}</stringProp>
-            <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">login[username]</stringProp>
-          </elementProp>
-        </collectionProp>
-      </elementProp>
-      <stringProp name="HTTPSampler.domain"/>
-      <stringProp name="HTTPSampler.port"/>
-      <stringProp name="HTTPSampler.connect_timeout"/>
-      <stringProp name="HTTPSampler.response_timeout"/>
-      <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
-      <stringProp name="HTTPSampler.contentEncoding"/>
-      <stringProp name="HTTPSampler.path">${base_path}${admin_path}/admin/dashboard/</stringProp>
-      <stringProp name="HTTPSampler.method">POST</stringProp>
-      <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
-      <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
-      <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
-      <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
-      <stringProp name="HTTPSampler.implementation">Java</stringProp>
-      <boolProp name="HTTPSampler.monitor">false</boolProp>
-      <stringProp name="HTTPSampler.embedded_url_re"/>
-      <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_login/admin_login_submit_form.jmx</stringProp>
-    </HTTPSamplerProxy>
-    <hashTree/>
-  
-    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="SetUp - Set ${gridEntityType} Pages Count" enabled="true">
-      <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
-        <collectionProp name="Arguments.arguments">
-          <elementProp name="namespace" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">${grid_namespace}</stringProp>
-            <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">namespace</stringProp>
-            <stringProp name="Argument.desc">true</stringProp>
-          </elementProp>
-          <elementProp name="search" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value"/>
-            <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">search</stringProp>
-            <stringProp name="Argument.desc">true</stringProp>
-          </elementProp>
-          <elementProp name="filters[placeholder]" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">true</stringProp>
-            <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">filters[placeholder]</stringProp>
-            <stringProp name="Argument.desc">true</stringProp>
-          </elementProp>
-          <elementProp name="paging[pageSize]" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">${grid_entity_page_size}</stringProp>
-            <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">paging[pageSize]</stringProp>
-            <stringProp name="Argument.desc">true</stringProp>
-          </elementProp>
-          <elementProp name="paging[current]" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">1</stringProp>
-            <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">paging[current]</stringProp>
-            <stringProp name="Argument.desc">true</stringProp>
-          </elementProp>
-          <elementProp name="sorting[field]" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">entity_id</stringProp>
-            <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">sorting[field]</stringProp>
-            <stringProp name="Argument.desc">true</stringProp>
-          </elementProp>
-          <elementProp name="sorting[direction]" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">asc</stringProp>
-            <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">sorting[direction]</stringProp>
-            <stringProp name="Argument.desc">true</stringProp>
-          </elementProp>
-          <elementProp name="isAjax" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">true</stringProp>
-            <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">isAjax</stringProp>
-            <stringProp name="Argument.desc">true</stringProp>
-          </elementProp>
-        </collectionProp>
-      </elementProp>
-      <stringProp name="HTTPSampler.domain"/>
-      <stringProp name="HTTPSampler.port"/>
-      <stringProp name="HTTPSampler.connect_timeout"/>
-      <stringProp name="HTTPSampler.response_timeout"/>
-      <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
-      <stringProp name="HTTPSampler.contentEncoding"/>
-      <stringProp name="HTTPSampler.path">${base_path}${admin_path}/mui/index/render/</stringProp>
-      <stringProp name="HTTPSampler.method">GET</stringProp>
-      <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
-      <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
-      <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
-      <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
-      <boolProp name="HTTPSampler.monitor">false</boolProp>
-      <stringProp name="HTTPSampler.embedded_url_re"/>
-    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_grid_browsing/set_pages_count.jmx</stringProp></HTTPSamplerProxy>
-    <hashTree>
-      <com.atlantbh.jmeter.plugins.jsonutils.jsonpathassertion.JSONPathAssertion guiclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathassertion.gui.JSONPathAssertionGui" testclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathassertion.JSONPathAssertion" testname="Assert total records is not 0" enabled="true">
-        <stringProp name="JSON_PATH">$.totalRecords</stringProp>
-        <stringProp name="EXPECTED_VALUE">0</stringProp>
-        <boolProp name="JSONVALIDATION">true</boolProp>
-        <boolProp name="EXPECT_NULL">false</boolProp>
-        <boolProp name="INVERT">true</boolProp>
-      </com.atlantbh.jmeter.plugins.jsonutils.jsonpathassertion.JSONPathAssertion>
-      <hashTree/>
-      <com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor guiclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.gui.JSONPathExtractorGui" testclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor" testname="Extract total records" enabled="true">
-        <stringProp name="VAR">entity_total_records</stringProp>
-        <stringProp name="JSONPATH">$.totalRecords</stringProp>
-        <stringProp name="DEFAULT"/>
-        <stringProp name="VARIABLE"/>
-        <stringProp name="SUBJECT">BODY</stringProp>
-      </com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor>
-      <hashTree/>
-      <JSR223PostProcessor guiclass="TestBeanGUI" testclass="JSR223PreProcessor" testname="SetUp - Calculate ${gridEntityType} pages count" enabled="true">
-        <stringProp name="cacheKey"/>
-        <stringProp name="filename"/>
-        <stringProp name="parameters"/>
-        <stringProp name="script">
-          var pageSize = parseInt(vars.get("grid_entity_page_size")) || 20;
-          var totalsRecord = parseInt(vars.get("entity_total_records"));
-          var pageCount = Math.round(totalsRecord/pageSize);
-
-          vars.put("grid_pages_count", pageCount);
-        </stringProp>
-        <stringProp name="scriptLanguage">javascript</stringProp>
-      </JSR223PostProcessor>
-      <hashTree/>
-    </hashTree>
-  
-    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="SetUp - Set ${gridEntityType} Filtered Pages Count" enabled="true">
-      <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
-        <collectionProp name="Arguments.arguments">
-          <elementProp name="namespace" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">${grid_namespace}</stringProp>
-            <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">namespace</stringProp>
-            <stringProp name="Argument.desc">true</stringProp>
-          </elementProp>
-          <elementProp name="search" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value"/>
-            <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">search</stringProp>
-            <stringProp name="Argument.desc">true</stringProp>
-          </elementProp>
-          <elementProp name="filters[placeholder]" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">${grid_admin_browse_filter_text}</stringProp>
-            <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">filters[placeholder]</stringProp>
-            <stringProp name="Argument.desc">true</stringProp>
-          </elementProp>
-          <elementProp name="paging[pageSize]" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">${grid_entity_page_size}</stringProp>
-            <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">paging[pageSize]</stringProp>
-            <stringProp name="Argument.desc">true</stringProp>
-          </elementProp>
-          <elementProp name="paging[current]" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">1</stringProp>
-            <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">paging[current]</stringProp>
-            <stringProp name="Argument.desc">true</stringProp>
-          </elementProp>
-          <elementProp name="sorting[field]" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">entity_id</stringProp>
-            <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">sorting[field]</stringProp>
-            <stringProp name="Argument.desc">true</stringProp>
-          </elementProp>
-          <elementProp name="sorting[direction]" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">asc</stringProp>
-            <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">sorting[direction]</stringProp>
-            <stringProp name="Argument.desc">true</stringProp>
-          </elementProp>
-          <elementProp name="isAjax" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">true</stringProp>
-            <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">isAjax</stringProp>
-            <stringProp name="Argument.desc">true</stringProp>
-          </elementProp>
-        </collectionProp>
-      </elementProp>
-      <stringProp name="HTTPSampler.domain"/>
-      <stringProp name="HTTPSampler.port"/>
-      <stringProp name="HTTPSampler.connect_timeout"/>
-      <stringProp name="HTTPSampler.response_timeout"/>
-      <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
-      <stringProp name="HTTPSampler.contentEncoding"/>
-      <stringProp name="HTTPSampler.path">${base_path}${admin_path}/mui/index/render/</stringProp>
-      <stringProp name="HTTPSampler.method">GET</stringProp>
-      <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
-      <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
-      <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
-      <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
-      <boolProp name="HTTPSampler.monitor">false</boolProp>
-      <stringProp name="HTTPSampler.embedded_url_re"/>
-    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_grid_browsing/set_filtered_pages_count.jmx</stringProp></HTTPSamplerProxy>
-    <hashTree>
-      <com.atlantbh.jmeter.plugins.jsonutils.jsonpathassertion.JSONPathAssertion guiclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathassertion.gui.JSONPathAssertionGui" testclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathassertion.JSONPathAssertion" testname="Assert total records is not 0" enabled="true">
-        <stringProp name="JSON_PATH">$.totalRecords</stringProp>
-        <stringProp name="EXPECTED_VALUE">0</stringProp>
-        <boolProp name="JSONVALIDATION">true</boolProp>
-        <boolProp name="EXPECT_NULL">false</boolProp>
-        <boolProp name="INVERT">true</boolProp>
-        <boolProp name="ISREGEX">true</boolProp>
-      </com.atlantbh.jmeter.plugins.jsonutils.jsonpathassertion.JSONPathAssertion>
-      <hashTree/>
-      <com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor guiclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.gui.JSONPathExtractorGui" testclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor" testname="Extract total records" enabled="true">
-        <stringProp name="VAR">entity_total_records</stringProp>
-        <stringProp name="JSONPATH">$.totalRecords</stringProp>
-        <stringProp name="DEFAULT"/>
-        <stringProp name="VARIABLE"/>
-        <stringProp name="SUBJECT">BODY</stringProp>
-      </com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor>
-      <hashTree/>
-      <JSR223PostProcessor guiclass="TestBeanGUI" testclass="JSR223PreProcessor" testname="SetUp - Calculate ${gridEntityType} filtered pages count" enabled="true">
-        <stringProp name="parameters"/>
-        <stringProp name="filename"/>
-        <stringProp name="script">
-          var pageSize = parseInt(vars.get("grid_entity_page_size")) || 20;
-var totalsRecord = parseInt(vars.get("entity_total_records"));
-var pageCount = Math.round(totalsRecord/pageSize);
-
-vars.put("grid_pages_count_filtered", pageCount);
-        </stringProp>
-        <stringProp name="scriptLanguage">javascript</stringProp>
-      </JSR223PostProcessor>
-      <hashTree/>
-    </hashTree>
-  </hashTree>
-  
-    <GenericController guiclass="LogicControllerGui" testclass="GenericController" testname="Simple Controller" enabled="true">
-  <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/simple_controller.jmx</stringProp>
-</GenericController>
-    <hashTree>
-    <CounterConfig guiclass="CounterConfigGui" testclass="CounterConfig" testname="SetUp - Select ${gridEntityType} Page Number" enabled="true">
-      <stringProp name="CounterConfig.start">1</stringProp>
-      <stringProp name="CounterConfig.end">${grid_pages_count}</stringProp>
-      <stringProp name="CounterConfig.incr">1</stringProp>
-      <stringProp name="CounterConfig.name">page_number</stringProp>
-      <stringProp name="CounterConfig.format"/>
-      <boolProp name="CounterConfig.per_user">true</boolProp>
-      <boolProp name="CounterConfig.reset_on_tg_iteration">false</boolProp>
-    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_grid_browsing/select_page_number.jmx</stringProp></CounterConfig>
-    <hashTree/>
-  
-    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="View ${gridEntityType} page" enabled="true">
-      <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
-        <collectionProp name="Arguments.arguments">
-          <elementProp name="namespace" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">${grid_namespace}</stringProp>
-            <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">namespace</stringProp>
-            <stringProp name="Argument.desc">true</stringProp>
-          </elementProp>
-          <elementProp name="search" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value"/>
-            <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">search</stringProp>
-            <stringProp name="Argument.desc">true</stringProp>
-          </elementProp>
-          <elementProp name="filters[placeholder]" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">true</stringProp>
-            <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">filters[placeholder]</stringProp>
-            <stringProp name="Argument.desc">true</stringProp>
-          </elementProp>
-          <elementProp name="paging[pageSize]" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">${grid_entity_page_size}</stringProp>
-            <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">paging[pageSize]</stringProp>
-            <stringProp name="Argument.desc">true</stringProp>
-          </elementProp>
-          <elementProp name="paging[current]" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">${page_number}</stringProp>
-            <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">paging[current]</stringProp>
-            <stringProp name="Argument.desc">true</stringProp>
-          </elementProp>
-          <elementProp name="sorting[field]" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">entity_id</stringProp>
-            <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">sorting[field]</stringProp>
-            <stringProp name="Argument.desc">true</stringProp>
-          </elementProp>
-          <elementProp name="sorting[direction]" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">asc</stringProp>
-            <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">sorting[direction]</stringProp>
-            <stringProp name="Argument.desc">true</stringProp>
-          </elementProp>
-          <elementProp name="isAjax" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">true</stringProp>
-            <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">isAjax</stringProp>
-            <stringProp name="Argument.desc">true</stringProp>
-          </elementProp>
-        </collectionProp>
-      </elementProp>
-      <stringProp name="HTTPSampler.domain"/>
-      <stringProp name="HTTPSampler.port"/>
-      <stringProp name="HTTPSampler.connect_timeout"/>
-      <stringProp name="HTTPSampler.response_timeout"/>
-      <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
-      <stringProp name="HTTPSampler.contentEncoding"/>
-      <stringProp name="HTTPSampler.path">${base_path}${admin_path}/mui/index/render/</stringProp>
-      <stringProp name="HTTPSampler.method">GET</stringProp>
-      <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
-      <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
-      <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
-      <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
-      <boolProp name="HTTPSampler.monitor">false</boolProp>
-      <stringProp name="HTTPSampler.embedded_url_re"/>
-    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_grid_browsing/admin_browse_grid.jmx</stringProp></HTTPSamplerProxy>
-    <hashTree>
-      <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Response Assertion" enabled="true">
-        <collectionProp name="Asserion.test_strings">
-          <stringProp name="1637639774">\"totalRecords\":[^0]\d*</stringProp>
-        </collectionProp>
-        <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
-        <boolProp name="Assertion.assume_success">false</boolProp>
-        <intProp name="Assertion.test_type">2</intProp>
-      </ResponseAssertion>
-      <hashTree/>
-    </hashTree>
-  
-    <CounterConfig guiclass="CounterConfigGui" testclass="CounterConfig" testname="SetUp - Select Filtered ${gridEntityType} Page Number" enabled="true">
-      <stringProp name="CounterConfig.start">1</stringProp>
-      <stringProp name="CounterConfig.end">${grid_pages_count_filtered}</stringProp>
-      <stringProp name="CounterConfig.incr">1</stringProp>
-      <stringProp name="CounterConfig.name">page_number</stringProp>
-      <stringProp name="CounterConfig.format"/>
-      <boolProp name="CounterConfig.per_user">true</boolProp>
-      <boolProp name="CounterConfig.reset_on_tg_iteration">false</boolProp>
-    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_grid_browsing/select_filtered_page_number.jmx</stringProp></CounterConfig>
-    <hashTree/>
-  
-    <TestFragmentController guiclass="TestFragmentControllerGui" testclass="TestFragmentController" testname="View ${gridEntityType} page - Filtering + Sorting" enabled="true">
-  <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_grid_browsing/admin_browse_grid_sort_and_filter.jmx</stringProp>
-</TestFragmentController>
-    <hashTree>
-      <ForeachController guiclass="ForeachControlPanel" testclass="ForeachController" testname="ForEach Sort Field Defined" enabled="true">
-        <stringProp name="ForeachController.inputVal">grid_sort_field</stringProp>
-        <stringProp name="ForeachController.returnVal">grid_sort_field</stringProp>
-        <boolProp name="ForeachController.useSeparator">true</boolProp>
-        <stringProp name="ForeachController.startIndex">0</stringProp>
-        <stringProp name="ForeachController.endIndex">3</stringProp>
-      </ForeachController>
-      <hashTree>
-        <ForeachController guiclass="ForeachControlPanel" testclass="ForeachController" testname="ForEach Sort Order Defined" enabled="true">
-          <stringProp name="ForeachController.inputVal">grid_sort_order</stringProp>
-          <stringProp name="ForeachController.returnVal">grid_sort_order</stringProp>
-          <boolProp name="ForeachController.useSeparator">true</boolProp>
-          <stringProp name="ForeachController.startIndex">0</stringProp>
-          <stringProp name="ForeachController.endIndex">2</stringProp>
-        </ForeachController>
-        <hashTree>
-          <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="View ${gridEntityType} page - Filtering + Sort By ${grid_sort_field} ${grid_sort_order}" enabled="true">
-            <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
-              <collectionProp name="Arguments.arguments">
-                <elementProp name="namespace" elementType="HTTPArgument">
-                  <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                  <stringProp name="Argument.value">${grid_namespace}</stringProp>
-                  <stringProp name="Argument.metadata">=</stringProp>
-                  <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                  <stringProp name="Argument.name">namespace</stringProp>
-                  <stringProp name="Argument.desc">false</stringProp>
-                </elementProp>
-                <elementProp name="filters[${grid_filter_field}]" elementType="HTTPArgument">
-                  <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                  <stringProp name="Argument.value">${grid_admin_browse_filter_text}</stringProp>
-                  <stringProp name="Argument.metadata">=</stringProp>
-                  <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                  <stringProp name="Argument.name">filters[${grid_filter_field}]</stringProp>
-                  <stringProp name="Argument.desc">false</stringProp>
-                </elementProp>
-                <elementProp name="filters[placeholder]" elementType="HTTPArgument">
-                  <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">true</stringProp>
-                  <stringProp name="Argument.metadata">=</stringProp>
-                  <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                  <stringProp name="Argument.name">filters[placeholder]</stringProp>
-                  <stringProp name="Argument.desc">false</stringProp>
-                </elementProp>
-                <elementProp name="paging[pageSize]" elementType="HTTPArgument">
-                  <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                  <stringProp name="Argument.value">${grid_entity_page_size}</stringProp>
-                  <stringProp name="Argument.metadata">=</stringProp>
-                  <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                  <stringProp name="Argument.name">paging[pageSize]</stringProp>
-                  <stringProp name="Argument.desc">false</stringProp>
-                </elementProp>
-                <elementProp name="paging[current]" elementType="HTTPArgument">
-                  <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                  <stringProp name="Argument.value">${page_number}</stringProp>
-                  <stringProp name="Argument.metadata">=</stringProp>
-                  <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                  <stringProp name="Argument.name">paging[current]</stringProp>
-                  <stringProp name="Argument.desc">false</stringProp>
-                </elementProp>
-                <elementProp name="sorting[field]" elementType="HTTPArgument">
-                  <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                  <stringProp name="Argument.value">${grid_sort_field}</stringProp>
-                  <stringProp name="Argument.metadata">=</stringProp>
-                  <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                  <stringProp name="Argument.name">sorting[field]</stringProp>
-                  <stringProp name="Argument.desc">false</stringProp>
-                </elementProp>
-                <elementProp name="sorting[direction]" elementType="HTTPArgument">
-                  <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                  <stringProp name="Argument.value">${grid_sort_order}</stringProp>
-                  <stringProp name="Argument.metadata">=</stringProp>
-                  <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                  <stringProp name="Argument.name">sorting[direction]</stringProp>
-                  <stringProp name="Argument.desc">false</stringProp>
-                </elementProp>
-                <elementProp name="isAjax" elementType="HTTPArgument">
-                  <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                  <stringProp name="Argument.value">true</stringProp>
-                  <stringProp name="Argument.metadata">=</stringProp>
-                  <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                  <stringProp name="Argument.name">isAjax</stringProp>
-                  <stringProp name="Argument.desc">false</stringProp>
-                </elementProp>
-              </collectionProp>
-            </elementProp>
-            <stringProp name="HTTPSampler.domain"/>
-            <stringProp name="HTTPSampler.port"/>
-            <stringProp name="HTTPSampler.connect_timeout"/>
-            <stringProp name="HTTPSampler.response_timeout"/>
-            <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
-            <stringProp name="HTTPSampler.contentEncoding"/>
-            <stringProp name="HTTPSampler.path">${base_path}${admin_path}/mui/index/render/</stringProp>
-            <stringProp name="HTTPSampler.method">GET</stringProp>
-            <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
-            <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
-            <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
-            <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
-            <boolProp name="HTTPSampler.monitor">false</boolProp>
-            <stringProp name="HTTPSampler.embedded_url_re"/>
-          </HTTPSamplerProxy>
-          <hashTree>
-            <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Response Assertion" enabled="true">
-              <collectionProp name="Asserion.test_strings">
-                <stringProp name="1637639774">\"totalRecords\":[^0]\d*</stringProp>
-              </collectionProp>
-              <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
-              <boolProp name="Assertion.assume_success">false</boolProp>
-              <intProp name="Assertion.test_type">2</intProp>
-            </ResponseAssertion>
-            <hashTree/>
-          </hashTree>
-        </hashTree>
-      </hashTree>
-    </hashTree>
-  </hashTree>
-  </hashTree>
-
-  
-    <ThroughputController guiclass="ThroughputControllerGui" testclass="ThroughputController" testname="Admin Create Order" enabled="true">
-      <intProp name="ThroughputController.style">1</intProp>
-      <boolProp name="ThroughputController.perThread">false</boolProp>
-      <intProp name="ThroughputController.maxThroughput">1</intProp>
-      <stringProp name="ThroughputController.percentThroughput">${adminCreateOrderPercentage}</stringProp>
-    <stringProp name="TestPlan.comments">mpaf/tool/fragments/_system/scenario_controller_tmpl.jmx</stringProp></ThroughputController>
-    <hashTree>
-        <JSR223PreProcessor guiclass="TestBeanGUI" testclass="JSR223PreProcessor" testname="Set Test Label" enabled="true">
-            <stringProp name="script">
-var testLabel = "${testLabel}" ? " (${testLabel})" : "";
-if (testLabel
-    &amp;&amp; sampler.getClass().getName() == 'org.apache.jmeter.protocol.http.sampler.HTTPSamplerProxy'
-) {
-    if (sampler.getName().indexOf(testLabel) == -1) {
-       sampler.setName(sampler.getName() + testLabel);
-    }
-} else if (sampler.getName().indexOf("SetUp - ") == -1) {
-    sampler.setName("SetUp - " + sampler.getName());
-}
-            </stringProp>
-            <stringProp name="scriptLanguage">javascript</stringProp>
-        <stringProp name="TestPlan.comments">mpaf/tool/fragments/_system/setup_label.jmx</stringProp></JSR223PreProcessor>
-        <hashTree/>
-        <BeanShellSampler guiclass="BeanShellSamplerGui" testclass="BeanShellSampler" testname="SetUp - Set Label" enabled="true">
-            <stringProp name="BeanShellSampler.query">
-                vars.put("testLabel", "Admin Create Order");
-            </stringProp>
-            <boolProp name="BeanShellSampler.resetInterpreter">true</boolProp>
-        </BeanShellSampler>
-        <hashTree/>
-    
-        <JSR223PostProcessor guiclass="TestBeanGUI" testclass="JSR223PostProcessor" testname="Get admin form key PostProcessor" enabled="true">
-        <stringProp name="script">
-        function getFormKeyFromResponse()
-        {
-            var url = prev.getUrlAsString(),
-            responseCode =  prev.getResponseCode(),
-            formKey = null;
-            searchPattern = /var FORM_KEY = '(.+)'/;
-            if (responseCode == "200" &amp;&amp; url) {
-                response = prev.getResponseDataAsString();
-                formKey = response  &amp;&amp; response.match(searchPattern) ? response.match(searchPattern)[1] : null;
-            }
-            return formKey;
-        }
-
-        formKey = vars.get("form_key_storage");
-
-	   currentFormKey = getFormKeyFromResponse();
-
-	   if (currentFormKey != null &amp;&amp; currentFormKey != formKey) {
-		  vars.put("form_key_storage", currentFormKey);
-	   }
-        </stringProp>
-        <stringProp name="scriptLanguage">javascript</stringProp>
-        <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin/handle_admin_form_key.jmx</stringProp></JSR223PostProcessor>
-        <hashTree/>
-        <JSR223PreProcessor guiclass="TestBeanGUI" testclass="JSR223PreProcessor" testname="Set admin form key PreProcessor" enabled="true">
-            <stringProp name="script">
-                formKey =  vars.get("form_key_storage");
-                if (formKey
-                    &amp;&amp; sampler.getClass().getName() == 'org.apache.jmeter.protocol.http.sampler.HTTPSamplerProxy'
-                    &amp;&amp; sampler.getMethod() == "POST")
-                    {
-                        arguments = sampler.getArguments();
-                        for (i=0; i&lt;arguments.getArgumentCount(); i++)
-                        {
-                            argument = arguments.getArgument(i);
-                            if (argument.getName() == 'form_key' &amp;&amp; argument.getValue() != formKey) {
-                            log.info("admin form key updated: " + argument.getValue() + " =&gt; " + formKey);
-                            argument.setValue(formKey);
-                        }
-                    }
-                }
-            </stringProp>
-            <stringProp name="scriptLanguage">javascript</stringProp>
-        </JSR223PreProcessor>
-        <hashTree/>
-    
-    <CookieManager guiclass="CookiePanel" testclass="CookieManager" testname="HTTP Cookie Manager" enabled="true">
-      <collectionProp name="CookieManager.cookies"/>
-      <boolProp name="CookieManager.clearEachIteration">false</boolProp>
-    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/http_cookie_manager_without_clear_each_iteration.jmx</stringProp></CookieManager>
-    <hashTree/>
-  
-    <OnceOnlyController guiclass="OnceOnlyControllerGui" testclass="OnceOnlyController" testname="Once Only Controller" enabled="true">
-  <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/once_only_controller.jmx</stringProp>
-</OnceOnlyController>
-    <hashTree>
-    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="SetUp - Login" enabled="true">
-      <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
-        <collectionProp name="Arguments.arguments"/>
-      </elementProp>
-      <stringProp name="HTTPSampler.domain"/>
-      <stringProp name="HTTPSampler.port"/>
-      <stringProp name="HTTPSampler.connect_timeout"/>
-      <stringProp name="HTTPSampler.response_timeout"/>
-      <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
-      <stringProp name="HTTPSampler.contentEncoding"/>
-      <stringProp name="HTTPSampler.path">${base_path}${admin_path}</stringProp>
-      <stringProp name="HTTPSampler.method">GET</stringProp>
-      <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
-      <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
-      <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
-      <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
-      <boolProp name="HTTPSampler.monitor">false</boolProp>
-      <stringProp name="HTTPSampler.embedded_url_re"/>
-    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_login/admin_login.jmx</stringProp></HTTPSamplerProxy>
-    <hashTree>
-      <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert login form shown" enabled="true">
-        <collectionProp name="Asserion.test_strings">
-          <stringProp name="-1397214398">Welcome</stringProp>
-          <stringProp name="-515240035">&lt;title&gt;Magento Admin&lt;/title&gt;</stringProp>
-        </collectionProp>
-        <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
-        <boolProp name="Assertion.assume_success">false</boolProp>
-        <intProp name="Assertion.test_type">2</intProp>
-      </ResponseAssertion>
-      <hashTree/>
-      <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract form key" enabled="true">
-        <stringProp name="RegexExtractor.useHeaders">false</stringProp>
-        <stringProp name="RegexExtractor.refname">admin_form_key</stringProp>
-        <stringProp name="RegexExtractor.regex">&lt;input name="form_key" type="hidden" value="([^'"]+)" /&gt;</stringProp>
-        <stringProp name="RegexExtractor.template">$1$</stringProp>
-        <stringProp name="RegexExtractor.default"/>
-        <stringProp name="RegexExtractor.match_number">1</stringProp>
-      </RegexExtractor>
-      <hashTree/>
-      <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert form_key extracted" enabled="true">
-        <collectionProp name="Asserion.test_strings">
-          <stringProp name="2845929">^.+$</stringProp>
-        </collectionProp>
-        <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
-        <boolProp name="Assertion.assume_success">false</boolProp>
-        <intProp name="Assertion.test_type">1</intProp>
-        <stringProp name="Assertion.scope">variable</stringProp>
-        <stringProp name="Scope.variable">admin_form_key</stringProp>
-      </ResponseAssertion>
-      <hashTree/>
-    </hashTree>
-  
-    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="SetUp - Login Submit Form" enabled="true">
-      <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
-        <collectionProp name="Arguments.arguments">
-          <elementProp name="dummy" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value"/>
-            <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">dummy</stringProp>
-          </elementProp>
-          <elementProp name="form_key" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">${admin_form_key}</stringProp>
-            <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">form_key</stringProp>
-          </elementProp>
-          <elementProp name="login[password]" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">${admin_password}</stringProp>
-            <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">login[password]</stringProp>
-          </elementProp>
-          <elementProp name="login[username]" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">${admin_user}</stringProp>
-            <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">login[username]</stringProp>
-          </elementProp>
-        </collectionProp>
-      </elementProp>
-      <stringProp name="HTTPSampler.domain"/>
-      <stringProp name="HTTPSampler.port"/>
-      <stringProp name="HTTPSampler.connect_timeout"/>
-      <stringProp name="HTTPSampler.response_timeout"/>
-      <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
-      <stringProp name="HTTPSampler.contentEncoding"/>
-      <stringProp name="HTTPSampler.path">${base_path}${admin_path}/admin/dashboard/</stringProp>
-      <stringProp name="HTTPSampler.method">POST</stringProp>
-      <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
-      <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
-      <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
-      <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
-      <stringProp name="HTTPSampler.implementation">Java</stringProp>
-      <boolProp name="HTTPSampler.monitor">false</boolProp>
-      <stringProp name="HTTPSampler.embedded_url_re"/>
-      <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_login/admin_login_submit_form.jmx</stringProp>
-    </HTTPSamplerProxy>
-    <hashTree>
-        <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract form key" enabled="true">
-            <stringProp name="RegexExtractor.useHeaders">false</stringProp>
-            <stringProp name="RegexExtractor.refname">admin_form_key</stringProp>
-            <stringProp name="RegexExtractor.regex">&lt;input name="form_key" type="hidden" value="([^'"]+)" /&gt;</stringProp>
-            <stringProp name="RegexExtractor.template">$1$</stringProp>
-            <stringProp name="RegexExtractor.default"/>
-            <stringProp name="RegexExtractor.match_number">1</stringProp>
-        <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_login/admin_retrieve_form_key.jmx</stringProp></RegexExtractor>
-        <hashTree/>
-    </hashTree>
-  </hashTree>
-  
-    <GenericController guiclass="LogicControllerGui" testclass="GenericController" testname="Simple Controller" enabled="true">
-  <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/simple_controller.jmx</stringProp>
-</GenericController>
-    <hashTree>
-    <TestFragmentController guiclass="TestFragmentControllerGui" testclass="TestFragmentController" testname="Admin Create Order" enabled="true"/>
-    <hashTree>
-      <BeanShellSampler guiclass="BeanShellSamplerGui" testclass="BeanShellSampler" testname="SetUp - Set Arguments" enabled="true">
-        <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_create_order/admin_create_order.jmx</stringProp>
-        <stringProp name="BeanShellSampler.query">import org.apache.jmeter.samplers.SampleResult;
-import java.util.Random;
-Random random = new Random();
-if (${seedForRandom} &gt; 0) {
-  random.setSeed(${seedForRandom});
-}
-number = random.nextInt(props.get("simple_products_list").size());
-simpleList = props.get("simple_products_list").get(number);
-vars.put("simple_product_1_url_key", simpleList.get("url_key"));
-vars.put("simple_product_1_name", simpleList.get("title"));
-vars.put("simple_product_1_id", simpleList.get("id"));
-
-do {
-    number1 = random.nextInt(props.get("simple_products_list").size());
-} while(number == number1);
-simpleList = props.get("simple_products_list").get(number1);
-vars.put("simple_product_2_url_key", simpleList.get("url_key"));
-vars.put("simple_product_2_name", simpleList.get("title"));
-vars.put("simple_product_2_id", simpleList.get("id"));
-
-number = random.nextInt(props.get("configurable_products_list").size());
-configurableList = props.get("configurable_products_list").get(number);
-vars.put("configurable_product_1_url_key", configurableList.get("url_key"));
-vars.put("configurable_product_1_name", configurableList.get("title"));
-vars.put("configurable_product_1_id", configurableList.get("id"));
-vars.put("configurable_product_1_sku", configurableList.get("sku"));
-vars.put("configurable_attribute_id", configurableList.get("attribute_id"));
-vars.put("configurable_option_id", configurableList.get("attribute_option_id"));
-
-
-customers_index = 0;
-if (!props.containsKey("customer_ids_index")) {
-	props.put("customer_ids_index", customers_index);
-}
-
-try {
-	customers_index = props.get("customer_ids_index");
-	customers_list = props.get("customer_ids_list");
-
-	if (customers_index == customers_list.size()) {
-		customers_index=0;
-	}
-	vars.put("customer_id", customers_list.get(customers_index));
-	props.put("customer_ids_index", ++customers_index);
-}
-catch (java.lang.Exception e) {
-	   log.error("Caught Exception in 'Admin Create Order' thread.");
-	   SampleResult.setStopThread(true);
-}</stringProp>
-        <stringProp name="BeanShellSampler.filename"/>
-        <stringProp name="BeanShellSampler.parameters"/>
-        <boolProp name="BeanShellSampler.resetInterpreter">true</boolProp>
-      </BeanShellSampler>
-      <hashTree/>
-      <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Start Order" enabled="true">
-        <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
-          <collectionProp name="Arguments.arguments"/>
-        </elementProp>
-        <stringProp name="HTTPSampler.domain"/>
-        <stringProp name="HTTPSampler.port"/>
-        <stringProp name="HTTPSampler.connect_timeout"/>
-        <stringProp name="HTTPSampler.response_timeout"/>
-        <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
-        <stringProp name="HTTPSampler.contentEncoding"/>
-        <stringProp name="HTTPSampler.path">${base_path}${admin_path}/sales/order_create/start/</stringProp>
-        <stringProp name="HTTPSampler.method">GET</stringProp>
-        <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
-        <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
-        <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
-        <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
-        <boolProp name="HTTPSampler.monitor">false</boolProp>
-        <stringProp name="HTTPSampler.embedded_url_re"/>
-        <stringProp name="TestPlan.comments">Detected the start of a redirect chain</stringProp>
-      </HTTPSamplerProxy>
-      <hashTree/>
-      <GenericController guiclass="LogicControllerGui" testclass="GenericController" testname="SetUp - Get Configurable Product Options" enabled="true"/>
-      <hashTree>
-        <HeaderManager guiclass="HeaderPanel" testclass="HeaderManager" testname="HTTP Header Manager" enabled="true">
-          <collectionProp name="HeaderManager.headers">
-            <elementProp name="" elementType="Header">
-              <stringProp name="Header.name">Content-Type</stringProp>
-              <stringProp name="Header.value">application/json</stringProp>
-            </elementProp>
-            <elementProp name="" elementType="Header">
-              <stringProp name="Header.name">Accept</stringProp>
-              <stringProp name="Header.value">*/*</stringProp>
-            </elementProp>
-          </collectionProp>
-        </HeaderManager>
-        <hashTree/>
-        <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="SetUp - Admin Token Retrieval" enabled="true">
-          <boolProp name="HTTPSampler.postBodyRaw">true</boolProp>
-          <elementProp name="HTTPsampler.Arguments" elementType="Arguments">
-            <collectionProp name="Arguments.arguments">
-              <elementProp name="" elementType="HTTPArgument">
-                <boolProp name="HTTPArgument.always_encode">false</boolProp>
-                <stringProp name="Argument.value">{"username":"${admin_user}","password":"${admin_password}"}</stringProp>
-                <stringProp name="Argument.metadata">=</stringProp>
-              </elementProp>
-            </collectionProp>
-          </elementProp>
-          <stringProp name="HTTPSampler.domain"/>
-          <stringProp name="HTTPSampler.port"/>
-          <stringProp name="HTTPSampler.connect_timeout"/>
-          <stringProp name="HTTPSampler.response_timeout"/>
-          <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
-          <stringProp name="HTTPSampler.contentEncoding"/>
-          <stringProp name="HTTPSampler.path">${base_path}rest/V1/integration/admin/token</stringProp>
-          <stringProp name="HTTPSampler.method">POST</stringProp>
-          <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
-          <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
-          <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
-          <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
-          <boolProp name="HTTPSampler.monitor">false</boolProp>
-          <stringProp name="HTTPSampler.embedded_url_re"/>
-        </HTTPSamplerProxy>
-        <hashTree>
-          <com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor guiclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.gui.JSONPathExtractorGui" testclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor" testname="jp@gc - JSON Path Extractor" enabled="true">
-            <stringProp name="VAR">admin_token</stringProp>
-            <stringProp name="JSONPATH">$</stringProp>
-            <stringProp name="DEFAULT"/>
-            <stringProp name="VARIABLE"/>
-            <stringProp name="SUBJECT">BODY</stringProp>
-          </com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor>
-          <hashTree/>
-          <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert token not null" enabled="true">
-            <collectionProp name="Asserion.test_strings">
-              <stringProp name="484395188">^[a-z0-9-]+$</stringProp>
-            </collectionProp>
-            <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
-            <boolProp name="Assertion.assume_success">false</boolProp>
-            <intProp name="Assertion.test_type">1</intProp>
-            <stringProp name="Assertion.scope">variable</stringProp>
-            <stringProp name="Scope.variable">admin_token</stringProp>
-          </ResponseAssertion>
-          <hashTree/>
-        </hashTree>
-        <HeaderManager guiclass="HeaderPanel" testclass="HeaderManager" testname="HTTP Header Manager" enabled="true">
-          <collectionProp name="HeaderManager.headers">
-            <elementProp name="" elementType="Header">
-              <stringProp name="Header.name">Authorization</stringProp>
-              <stringProp name="Header.value">Bearer ${admin_token}</stringProp>
-            </elementProp>
-          </collectionProp>
-        </HeaderManager>
-        <hashTree/>
-        <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="SetUp - Get Configurable Product Options" enabled="true">
-          <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
-            <collectionProp name="Arguments.arguments"/>
-          </elementProp>
-          <stringProp name="HTTPSampler.domain"/>
-          <stringProp name="HTTPSampler.port"/>
-          <stringProp name="HTTPSampler.connect_timeout"/>
-          <stringProp name="HTTPSampler.response_timeout"/>
-          <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
-          <stringProp name="HTTPSampler.contentEncoding"/>
-          <stringProp name="HTTPSampler.path">${base_path}rest/V1/configurable-products/${configurable_product_1_sku}/options/all</stringProp>
-          <stringProp name="HTTPSampler.method">GET</stringProp>
-          <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
-          <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
-          <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
-          <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
-          <boolProp name="HTTPSampler.monitor">false</boolProp>
-          <stringProp name="HTTPSampler.embedded_url_re"/>
-        </HTTPSamplerProxy>
-        <hashTree>
-          <com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor guiclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.gui.JSONPathExtractorGui" testclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor" testname="JSON Path Extractor: Extract attribute_ids" enabled="true">
-            <stringProp name="VAR">attribute_ids</stringProp>
-            <stringProp name="JSONPATH">$.[*].attribute_id</stringProp>
-            <stringProp name="DEFAULT">NO_VALUE</stringProp>
-            <stringProp name="VARIABLE"/>
-            <stringProp name="SUBJECT">BODY</stringProp>
-          </com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor>
-          <hashTree/>
-          <com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor guiclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.gui.JSONPathExtractorGui" testclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor" testname="JSON Path Extractor: Extract option_values" enabled="true">
-            <stringProp name="VAR">option_values</stringProp>
-            <stringProp name="JSONPATH">$.[*].values[0].value_index</stringProp>
-            <stringProp name="DEFAULT">NO_VALUE</stringProp>
-            <stringProp name="VARIABLE"/>
-            <stringProp name="SUBJECT">BODY</stringProp>
-          </com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor>
-          <hashTree/>
-        </hashTree>
-      </hashTree>
-      <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Add Products" enabled="true">
-        <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
-          <collectionProp name="Arguments.arguments">
-            <elementProp name="item[${simple_product_1_id}][qty]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.name">item[${simple_product_1_id}][qty]</stringProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            </elementProp>
-            <elementProp name="item[${simple_product_2_id}][qty]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.name">item[${simple_product_2_id}][qty]</stringProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            </elementProp>
-            <elementProp name="item[${configurable_product_1_id}][qty]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.name">item[${configurable_product_1_id}][qty]</stringProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            </elementProp>
-            <elementProp name="customer_id" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.name">customer_id</stringProp>
-              <stringProp name="Argument.value">${customer_id}</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            </elementProp>
-            <elementProp name="store_id" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.name">store_id</stringProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            </elementProp>
-            <elementProp name="currency_id" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.name">currency_id</stringProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            </elementProp>
-            <elementProp name="form_key" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.name">form_key</stringProp>
-              <stringProp name="Argument.value">${admin_form_key}</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            </elementProp>
-            <elementProp name="payment[method]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.name">payment[method]</stringProp>
-              <stringProp name="Argument.value">checkmo</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            </elementProp>
-            <elementProp name="reset_shipping" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.name">reset_shipping</stringProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            </elementProp>
-            <elementProp name="json" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.name">json</stringProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            </elementProp>
-            <elementProp name="as_js_varname" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.name">as_js_varname</stringProp>
-              <stringProp name="Argument.value">iFrameResponse</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            </elementProp>
-            <elementProp name="form_key" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.name">form_key</stringProp>
-              <stringProp name="Argument.value">${admin_form_key}</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            </elementProp>
-          </collectionProp>
-        </elementProp>
-        <stringProp name="HTTPSampler.domain"/>
-        <stringProp name="HTTPSampler.port"/>
-        <stringProp name="HTTPSampler.connect_timeout"/>
-        <stringProp name="HTTPSampler.response_timeout"/>
-        <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
-        <stringProp name="HTTPSampler.contentEncoding"/>
-        <stringProp name="HTTPSampler.path">${base_path}${admin_path}/sales/order_create/loadBlock/block/search,items,shipping_method,totals,giftmessage,billing_method?isAjax=true</stringProp>
-        <stringProp name="HTTPSampler.method">POST</stringProp>
-        <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
-        <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
-        <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
-        <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
-        <boolProp name="HTTPSampler.monitor">false</boolProp>
-        <stringProp name="HTTPSampler.embedded_url_re"/>
-        <stringProp name="TestPlan.comments">Detected the start of a redirect chain</stringProp>
-      </HTTPSamplerProxy>
-      <hashTree>
-        <BeanShellPreProcessor guiclass="TestBeanGUI" testclass="BeanShellPreProcessor" testname="Configure product options" enabled="true">
-          <boolProp name="resetInterpreter">false</boolProp>
-          <stringProp name="parameters"/>
-          <stringProp name="filename"/>
-          <stringProp name="script">try {
-	attribute_ids = vars.get("attribute_ids");
-	option_values = vars.get("option_values");
-	attribute_ids = attribute_ids.replace("[","").replace("]","").replace("\"", "");
-	option_values = option_values.replace("[","").replace("]","").replace("\"", "");
-	attribute_ids_array = attribute_ids.split(",");
-	option_values_array = option_values.split(",");
-	args = ctx.getCurrentSampler().getArguments();
-	it = args.iterator();
-	while (it.hasNext()) {
-	    argument = it.next();
-	    if (argument.getStringValue().contains("${")) {
-	        args.removeArgument(argument.getName());
-	    }
-	}
-	for (int i = 0; i &lt; attribute_ids_array.length; i++) {
+vars.put("product_url_key", product.get("url_key"));
+vars.put("product_id", product.get("id"));
+vars.put("product_name", product.get("title"));
+vars.put("product_uenc", product.get("uenc"));
+vars.put("product_sku", product.get("sku"));
+      </stringProp>
+      <stringProp name="BeanShellSampler.filename"/>
+      <stringProp name="BeanShellSampler.parameters"/>
+      <boolProp name="BeanShellSampler.resetInterpreter">true</boolProp>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/product_browsing_and_adding_items_to_the_cart/simple_products_setup.jmx</stringProp></BeanShellSampler>
+    <hashTree/>
+  
+    <BeanShellSampler guiclass="BeanShellSamplerGui" testclass="BeanShellSampler" testname="SetUp - Update Products Added Counter" enabled="true">
+      <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/loops/update_products_added_counter.jmx</stringProp>
+      <stringProp name="BeanShellSampler.query">
+productsAdded = Integer.parseInt(vars.get("totalProductsAdded"));
+productsAdded = productsAdded + 1;
 
-    ctx.getCurrentSampler().addArgument("item[" + vars.get("configurable_product_1_id") + "][super_attribute][" + attribute_ids_array[i] + "]", option_values_array[i]);
-	}
-} catch (Exception e) {
-    log.error("error???", e);
-}</stringProp>
-        </BeanShellPreProcessor>
-        <hashTree/>
-      </hashTree>
-      <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Collect Shipping Rates" enabled="true">
-        <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
-          <collectionProp name="Arguments.arguments">
-            <elementProp name="collect_shipping_rates" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.name">collect_shipping_rates</stringProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            </elementProp>
-            <elementProp name="customer_id" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.name">customer_id</stringProp>
-              <stringProp name="Argument.value">${customer_id}</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            </elementProp>
-            <elementProp name="store_id" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.name">store_id</stringProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            </elementProp>
-            <elementProp name="currency_id" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.name">currency_id</stringProp>
-              <stringProp name="Argument.value">false</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            </elementProp>
-            <elementProp name="form_key" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.name">form_key</stringProp>
-              <stringProp name="Argument.value">${admin_form_key}</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            </elementProp>
-            <elementProp name="payment[method]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.name">payment[method]</stringProp>
-              <stringProp name="Argument.value">checkmo</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            </elementProp>
-            <elementProp name="json" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.name">json</stringProp>
-              <stringProp name="Argument.value">true</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            </elementProp>
-          </collectionProp>
-        </elementProp>
-        <stringProp name="HTTPSampler.domain"/>
-        <stringProp name="HTTPSampler.port"/>
-        <stringProp name="HTTPSampler.connect_timeout"/>
-        <stringProp name="HTTPSampler.response_timeout"/>
-        <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
-        <stringProp name="HTTPSampler.contentEncoding"/>
-        <stringProp name="HTTPSampler.path">${base_path}${admin_path}/sales/order_create/loadBlock/block/shipping_method,totals?isAjax=true</stringProp>
-        <stringProp name="HTTPSampler.method">POST</stringProp>
-        <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
-        <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
-        <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
-        <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
-        <boolProp name="HTTPSampler.monitor">false</boolProp>
-        <stringProp name="HTTPSampler.embedded_url_re"/>
-      </HTTPSamplerProxy>
-      <hashTree>
-        <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert Shipping Method" enabled="true">
-          <collectionProp name="Asserion.test_strings">
-            <stringProp name="-1987784558">shipping_method</stringProp>
-            <stringProp name="818779431">Flat Rate</stringProp>
-          </collectionProp>
-          <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
-          <boolProp name="Assertion.assume_success">false</boolProp>
-          <intProp name="Assertion.test_type">2</intProp>
-        </ResponseAssertion>
-        <hashTree/>
-      </hashTree>
-      <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Save Order" enabled="true">
-        <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
-          <collectionProp name="Arguments.arguments">
-            <elementProp name="form_key" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.name">form_key</stringProp>
-              <stringProp name="Argument.value">${admin_form_key}</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            </elementProp>
-            <elementProp name="limit" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.name">limit</stringProp>
-              <stringProp name="Argument.value">20</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            </elementProp>
-            <elementProp name="entity_id" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.name">entity_id</stringProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            </elementProp>
-            <elementProp name="name" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.name">name</stringProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            </elementProp>
-            <elementProp name="email" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.name">email</stringProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            </elementProp>
-            <elementProp name="Telephone" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.name">Telephone</stringProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            </elementProp>
-            <elementProp name="billing_postcode" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.name">billing_postcode</stringProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            </elementProp>
-            <elementProp name="billing_country_id" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.name">billing_country_id</stringProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            </elementProp>
-            <elementProp name="billing_regione" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.name">billing_regione</stringProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            </elementProp>
-            <elementProp name="store_name" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.name">store_name</stringProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            </elementProp>
-            <elementProp name="page" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.name">page</stringProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            </elementProp>
-            <elementProp name="order[currency]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.name">order[currency]</stringProp>
-              <stringProp name="Argument.value">USD</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            </elementProp>
-            <elementProp name="sku" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.name">sku</stringProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            </elementProp>
-            <elementProp name="qty" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.name">qty</stringProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            </elementProp>
-            <elementProp name="limit" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.name">limit</stringProp>
-              <stringProp name="Argument.value">20</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            </elementProp>
-            <elementProp name="entity_id" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.name">entity_id</stringProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            </elementProp>
-            <elementProp name="name" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.name">name</stringProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            </elementProp>
-            <elementProp name="sku" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.name">sku</stringProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            </elementProp>
-            <elementProp name="price[from]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.name">price[from]</stringProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            </elementProp>
-            <elementProp name="price[to]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.name">price[to]</stringProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            </elementProp>
-            <elementProp name="in_products" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.name">in_products</stringProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            </elementProp>
-            <elementProp name="page" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.name">page</stringProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            </elementProp>
-            <elementProp name="coupon_code" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.name">coupon_code</stringProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            </elementProp>
-            <elementProp name="order[account][group_id]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.name">order[account][group_id]</stringProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            </elementProp>
-            <elementProp name="order[account][email]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.name">order[account][email]</stringProp>
-              <stringProp name="Argument.value">user_${customer_id}@example.com</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            </elementProp>
-            <elementProp name="order[billing_address][customer_address_id]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.name">order[billing_address][customer_address_id]</stringProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            </elementProp>
-            <elementProp name="order[billing_address][prefix]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.name">order[billing_address][prefix]</stringProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            </elementProp>
-            <elementProp name="order[billing_address][firstname]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.name">order[billing_address][firstname]</stringProp>
-              <stringProp name="Argument.value">Anthony</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            </elementProp>
-            <elementProp name="order[billing_address][middlename]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.name">order[billing_address][middlename]</stringProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            </elementProp>
-            <elementProp name="order[billing_address][lastname]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.name">order[billing_address][lastname]</stringProp>
-              <stringProp name="Argument.value">Nealy</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            </elementProp>
-            <elementProp name="order[billing_address][suffix]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.name">order[billing_address][suffix]</stringProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            </elementProp>
-            <elementProp name="order[billing_address][company]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.name">order[billing_address][company]</stringProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            </elementProp>
-            <elementProp name="order[billing_address][street][0]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.name">order[billing_address][street][0]</stringProp>
-              <stringProp name="Argument.value">123 Freedom Blvd. #123</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            </elementProp>
-            <elementProp name="order[billing_address][street][1]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.name">order[billing_address][street][1]</stringProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            </elementProp>
-            <elementProp name="order[billing_address][city]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.name">order[billing_address][city]</stringProp>
-              <stringProp name="Argument.value">Fayetteville</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            </elementProp>
-            <elementProp name="order[billing_address][country_id]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.name">order[billing_address][country_id]</stringProp>
-              <stringProp name="Argument.value">US</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            </elementProp>
-            <elementProp name="order[billing_address][region]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.name">order[billing_address][region]</stringProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            </elementProp>
-            <elementProp name="order[billing_address][region_id]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.name">order[billing_address][region_id]</stringProp>
-              <stringProp name="Argument.value">5</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            </elementProp>
-            <elementProp name="order[billing_address][postcode]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.name">order[billing_address][postcode]</stringProp>
-              <stringProp name="Argument.value">123123</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            </elementProp>
-            <elementProp name="order[billing_address][telephone]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.name">order[billing_address][telephone]</stringProp>
-              <stringProp name="Argument.value">022-333-4455</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            </elementProp>
-            <elementProp name="order[billing_address][fax]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.name">order[billing_address][fax]</stringProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            </elementProp>
-            <elementProp name="order[billing_address][vat_id]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.name">order[billing_address][vat_id]</stringProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            </elementProp>
-            <elementProp name="shipping_same_as_billing" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.name">shipping_same_as_billing</stringProp>
-              <stringProp name="Argument.value">on</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            </elementProp>
-            <elementProp name="payment[method]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.name">payment[method]</stringProp>
-              <stringProp name="Argument.value">checkmo</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            </elementProp>
-            <elementProp name="order[shipping_method]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.name">order[shipping_method]</stringProp>
-              <stringProp name="Argument.value">flatrate_flatrate</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            </elementProp>
-            <elementProp name="order[comment][customer_note]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.name">order[comment][customer_note]</stringProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+vars.put("totalProductsAdded", String.valueOf(productsAdded));
+      </stringProp>
+      <stringProp name="BeanShellSampler.filename"/>
+      <stringProp name="BeanShellSampler.parameters"/>
+      <boolProp name="BeanShellSampler.resetInterpreter">true</boolProp>
+    </BeanShellSampler>
+    <hashTree/>
+  
+        <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Simple Product ${_counter} View" enabled="true">
+            <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
+                <collectionProp name="Arguments.arguments"/>
             </elementProp>
-            <elementProp name="order[comment][customer_note_notify]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.name">order[comment][customer_note_notify]</stringProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="HTTPSampler.domain"/>
+            <stringProp name="HTTPSampler.port"/>
+            <stringProp name="HTTPSampler.connect_timeout"/>
+            <stringProp name="HTTPSampler.response_timeout"/>
+            <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
+            <stringProp name="HTTPSampler.contentEncoding"/>
+            <stringProp name="HTTPSampler.path">${base_path}${product_url_key}${url_suffix}</stringProp>
+            <stringProp name="HTTPSampler.method">GET</stringProp>
+            <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
+            <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
+            <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
+            <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
+            <boolProp name="HTTPSampler.monitor">false</boolProp>
+            <stringProp name="HTTPSampler.embedded_url_re"/>
+        <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/product_browsing_and_adding_items_to_the_cart/product_view.jmx</stringProp></HTTPSamplerProxy>
+        <hashTree>
+            <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Response Assertion" enabled="true">
+                <collectionProp name="Asserion.test_strings">
+                    <stringProp name="-1787050162">&lt;span&gt;In stock&lt;/span&gt;</stringProp>
+                </collectionProp>
+                <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
+                <boolProp name="Assertion.assume_success">false</boolProp>
+                <intProp name="Assertion.test_type">2</intProp>
+            </ResponseAssertion>
+            <hashTree/>
+        </hashTree>
+    
+    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Simple Product ${_counter} Add To Cart" enabled="true">
+      <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
+        <collectionProp name="Arguments.arguments">
+          <elementProp name="product" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">${product_id}</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">product</stringProp>
+          </elementProp>
+          <elementProp name="related_product" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value"/>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">related_product</stringProp>
+          </elementProp>
+          <elementProp name="qty" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">1</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">qty</stringProp>
+          </elementProp>
+          <elementProp name="form_key" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">${form_key}</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">form_key</stringProp>
+          </elementProp>
+        </collectionProp>
+      </elementProp>
+      <stringProp name="HTTPSampler.domain"/>
+      <stringProp name="HTTPSampler.port"/>
+      <stringProp name="HTTPSampler.connect_timeout"/>
+      <stringProp name="HTTPSampler.response_timeout"/>
+      <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
+      <stringProp name="HTTPSampler.contentEncoding"/>
+      <stringProp name="HTTPSampler.path">${base_path}checkout/cart/add/</stringProp>
+      <stringProp name="HTTPSampler.method">POST</stringProp>
+      <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
+      <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
+      <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
+      <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
+      <boolProp name="HTTPSampler.monitor">false</boolProp>
+      <stringProp name="HTTPSampler.embedded_url_re"/>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/product_browsing_and_adding_items_to_the_cart/simple_product_add_to_cart.jmx</stringProp></HTTPSamplerProxy>
+    <hashTree>
+    <HeaderManager guiclass="HeaderPanel" testclass="HeaderManager" testname="HTTP Header Manager" enabled="true">
+      <collectionProp name="HeaderManager.headers">
+        <elementProp name="" elementType="Header">
+          <stringProp name="Header.name">X-Requested-With</stringProp>
+          <stringProp name="Header.value">XMLHttpRequest</stringProp>
+        </elementProp>
+      </collectionProp>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/common/http_header_manager_ajax.jmx</stringProp></HeaderManager>
+    <hashTree/>
+  </hashTree>
+  
+    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Load Cart Section ${_counter}" enabled="true">
+      <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
+        <collectionProp name="Arguments.arguments">
+          <elementProp name="sections" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">cart,messages</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">sections</stringProp>
+          </elementProp>
+          <elementProp name="update_section_id" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">true</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">update_section_id</stringProp>
+          </elementProp>
+          <elementProp name="_" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">${__time()}${__Random(1,1000000)}</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">_</stringProp>
+          </elementProp>
+        </collectionProp>
+      </elementProp>
+      <stringProp name="HTTPSampler.domain"/>
+      <stringProp name="HTTPSampler.port"/>
+      <stringProp name="HTTPSampler.connect_timeout"/>
+      <stringProp name="HTTPSampler.response_timeout"/>
+      <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
+      <stringProp name="HTTPSampler.contentEncoding"/>
+      <stringProp name="HTTPSampler.path">${base_path}customer/section/load/</stringProp>
+      <stringProp name="HTTPSampler.method">GET</stringProp>
+      <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
+      <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
+      <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
+      <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
+      <boolProp name="HTTPSampler.monitor">false</boolProp>
+      <stringProp name="HTTPSampler.embedded_url_re"/>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/load_cart_section.jmx</stringProp></HTTPSamplerProxy>
+    <hashTree>
+      <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Response Assertion" enabled="true">
+        <collectionProp name="Asserion.test_strings">
+          <stringProp name="210217247">You added ${product_name} to your shopping cart.</stringProp>
+        </collectionProp>
+        <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
+        <boolProp name="Assertion.assume_success">false</boolProp>
+        <intProp name="Assertion.test_type">2</intProp>
+      </ResponseAssertion>
+      <hashTree/>
+      <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Response Assertion" enabled="true">
+        <collectionProp name="Asserion.test_strings">
+          <stringProp name="2057973164">This product is out of stock.</stringProp>
+        </collectionProp>
+        <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
+        <boolProp name="Assertion.assume_success">false</boolProp>
+        <intProp name="Assertion.test_type">6</intProp>
+      </ResponseAssertion>
+      <hashTree/>
+      <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Response Assertion" enabled="true">
+        <collectionProp name="Asserion.test_strings">
+          <stringProp name="-350323027">\"summary_count\":${totalProductsAdded}</stringProp>
+        </collectionProp>
+        <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
+        <boolProp name="Assertion.assume_success">false</boolProp>
+        <intProp name="Assertion.test_type">2</intProp>
+      </ResponseAssertion>
+      <hashTree/>
+    
+    <HeaderManager guiclass="HeaderPanel" testclass="HeaderManager" testname="HTTP Header Manager" enabled="true">
+      <collectionProp name="HeaderManager.headers">
+        <elementProp name="" elementType="Header">
+          <stringProp name="Header.name">X-Requested-With</stringProp>
+          <stringProp name="Header.value">XMLHttpRequest</stringProp>
+        </elementProp>
+      </collectionProp>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/common/http_header_manager_ajax.jmx</stringProp></HeaderManager>
+    <hashTree/>
+  </hashTree>
+  </hashTree>
+  
+    <LoopController guiclass="LoopControlPanel" testclass="LoopController" testname="Add Configurable Products to Cart" enabled="true">
+      <boolProp name="LoopController.continue_forever">true</boolProp>
+      <stringProp name="LoopController.loops">1</stringProp>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/loop_controller.jmx</stringProp></LoopController>
+    <hashTree>
+      <CounterConfig guiclass="CounterConfigGui" testclass="CounterConfig" testname="Counter" enabled="true">
+        <stringProp name="CounterConfig.start">1</stringProp>
+        <stringProp name="CounterConfig.end"/>
+        <stringProp name="CounterConfig.incr">1</stringProp>
+        <stringProp name="CounterConfig.name">_counter</stringProp>
+        <stringProp name="CounterConfig.format"/>
+        <boolProp name="CounterConfig.per_user">true</boolProp>
+        <boolProp name="CounterConfig.reset_on_tg_iteration">true</boolProp>
+      </CounterConfig>
+      <hashTree/>
+    
+    <BeanShellSampler guiclass="BeanShellSamplerGui" testclass="BeanShellSampler" testname="SetUp - Prepare Configurable Product Data" enabled="true">
+      <stringProp name="BeanShellSampler.query">
+import java.util.Random;
+
+Random random = vars.getObject("randomIntGenerator");
+number = random.nextInt(props.get("configurable_products_list").size());
+product = props.get("configurable_products_list").get(number);
+
+vars.put("product_url_key", product.get("url_key"));
+vars.put("product_id", product.get("id"));
+vars.put("product_name", product.get("title"));
+vars.put("product_uenc", product.get("uenc"));
+vars.put("product_sku", product.get("sku"));
+      </stringProp>
+      <stringProp name="BeanShellSampler.filename"/>
+      <stringProp name="BeanShellSampler.parameters"/>
+      <boolProp name="BeanShellSampler.resetInterpreter">true</boolProp>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/product_browsing_and_adding_items_to_the_cart/configurable_products_setup.jmx</stringProp></BeanShellSampler>
+    <hashTree/>
+  
+    <BeanShellSampler guiclass="BeanShellSamplerGui" testclass="BeanShellSampler" testname="SetUp - Update Products Added Counter" enabled="true">
+      <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/loops/update_products_added_counter.jmx</stringProp>
+      <stringProp name="BeanShellSampler.query">
+productsAdded = Integer.parseInt(vars.get("totalProductsAdded"));
+productsAdded = productsAdded + 1;
+
+vars.put("totalProductsAdded", String.valueOf(productsAdded));
+      </stringProp>
+      <stringProp name="BeanShellSampler.filename"/>
+      <stringProp name="BeanShellSampler.parameters"/>
+      <boolProp name="BeanShellSampler.resetInterpreter">true</boolProp>
+    </BeanShellSampler>
+    <hashTree/>
+  
+        <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Configurable Product ${_counter} View" enabled="true">
+            <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
+                <collectionProp name="Arguments.arguments"/>
             </elementProp>
-            <elementProp name="order[send_confirmation]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.name">order[send_confirmation]</stringProp>
-              <stringProp name="Argument.value">1</stringProp>
+            <stringProp name="HTTPSampler.domain"/>
+            <stringProp name="HTTPSampler.port"/>
+            <stringProp name="HTTPSampler.connect_timeout"/>
+            <stringProp name="HTTPSampler.response_timeout"/>
+            <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
+            <stringProp name="HTTPSampler.contentEncoding"/>
+            <stringProp name="HTTPSampler.path">${base_path}${product_url_key}${url_suffix}</stringProp>
+            <stringProp name="HTTPSampler.method">GET</stringProp>
+            <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
+            <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
+            <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
+            <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
+            <boolProp name="HTTPSampler.monitor">false</boolProp>
+            <stringProp name="HTTPSampler.embedded_url_re"/>
+        <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/product_browsing_and_adding_items_to_the_cart/product_view.jmx</stringProp></HTTPSamplerProxy>
+        <hashTree>
+            <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Response Assertion" enabled="true">
+                <collectionProp name="Asserion.test_strings">
+                    <stringProp name="-1787050162">&lt;span&gt;In stock&lt;/span&gt;</stringProp>
+                </collectionProp>
+                <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
+                <boolProp name="Assertion.assume_success">false</boolProp>
+                <intProp name="Assertion.test_type">2</intProp>
+            </ResponseAssertion>
+            <hashTree/>
+        </hashTree>
+    
+    <LoopController guiclass="LoopControlPanel" testclass="LoopController" testname="SetUp - Get Configurable Product Options" enabled="true">
+      <boolProp name="LoopController.continue_forever">true</boolProp>
+      <stringProp name="LoopController.loops">1</stringProp>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/common/get_configurable_product_options.jmx</stringProp></LoopController>
+    <hashTree>
+      <HeaderManager guiclass="HeaderPanel" testclass="HeaderManager" testname="HTTP Header Manager" enabled="true">
+        <collectionProp name="HeaderManager.headers">
+          <elementProp name="" elementType="Header">
+            <stringProp name="Header.name">Content-Type</stringProp>
+            <stringProp name="Header.value">application/json</stringProp>
+          </elementProp>
+          <elementProp name="" elementType="Header">
+            <stringProp name="Header.name">Accept</stringProp>
+            <stringProp name="Header.value">*/*</stringProp>
+          </elementProp>
+        </collectionProp>
+      </HeaderManager>
+      <hashTree/>
+      <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="SetUp - Admin Token Retrieval" enabled="true">
+        <boolProp name="HTTPSampler.postBodyRaw">true</boolProp>
+        <elementProp name="HTTPsampler.Arguments" elementType="Arguments">
+          <collectionProp name="Arguments.arguments">
+            <elementProp name="" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">false</boolProp>
+              <stringProp name="Argument.value">{"username":"${admin_user}","password":"${admin_password}"}</stringProp>
               <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
             </elementProp>
           </collectionProp>
         </elementProp>
@@ -22592,146 +9225,554 @@ catch (java.lang.Exception e) {
         <stringProp name="HTTPSampler.response_timeout"/>
         <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
         <stringProp name="HTTPSampler.contentEncoding"/>
-        <stringProp name="HTTPSampler.path">${base_path}${admin_path}/sales/order_create/save/</stringProp>
+        <stringProp name="HTTPSampler.path">${base_path}rest/V1/integration/admin/token</stringProp>
         <stringProp name="HTTPSampler.method">POST</stringProp>
         <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
         <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
         <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
-        <boolProp name="HTTPSampler.DO_MULTIPART_POST">true</boolProp>
+        <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
         <boolProp name="HTTPSampler.monitor">false</boolProp>
         <stringProp name="HTTPSampler.embedded_url_re"/>
-        <stringProp name="TestPlan.comments">Detected the start of a redirect chain</stringProp>
       </HTTPSamplerProxy>
       <hashTree>
-        <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract Order Id" enabled="true">
-          <stringProp name="RegexExtractor.useHeaders">false</stringProp>
-          <stringProp name="RegexExtractor.refname">order_id</stringProp>
-          <stringProp name="RegexExtractor.regex">${host}${base_path}${admin_path}/sales/order/index/order_id/(\d+)/</stringProp>
-          <stringProp name="RegexExtractor.template">$1$</stringProp>
-          <stringProp name="RegexExtractor.default"/>
-          <stringProp name="RegexExtractor.match_number">1</stringProp>
-        </RegexExtractor>
-        <hashTree/>
-        <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract Order Item 1" enabled="true">
-          <stringProp name="RegexExtractor.useHeaders">false</stringProp>
-          <stringProp name="RegexExtractor.refname">order_item_1</stringProp>
-          <stringProp name="RegexExtractor.regex">order_item_(\d+)_title</stringProp>
-          <stringProp name="RegexExtractor.template">$1$</stringProp>
-          <stringProp name="RegexExtractor.default"/>
-          <stringProp name="RegexExtractor.match_number">1</stringProp>
-        </RegexExtractor>
-        <hashTree/>
-        <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract Order Item 2" enabled="true">
-          <stringProp name="RegexExtractor.useHeaders">false</stringProp>
-          <stringProp name="RegexExtractor.refname">order_item_2</stringProp>
-          <stringProp name="RegexExtractor.regex">order_item_(\d+)_title</stringProp>
-          <stringProp name="RegexExtractor.template">$1$</stringProp>
-          <stringProp name="RegexExtractor.default"/>
-          <stringProp name="RegexExtractor.match_number">2</stringProp>
-        </RegexExtractor>
-        <hashTree/>
-        <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract Order Item 3" enabled="true">
-          <stringProp name="RegexExtractor.useHeaders">false</stringProp>
-          <stringProp name="RegexExtractor.refname">order_item_3</stringProp>
-          <stringProp name="RegexExtractor.regex">order_item_(\d+)_title</stringProp>
-          <stringProp name="RegexExtractor.template">$1$</stringProp>
-          <stringProp name="RegexExtractor.default"/>
-          <stringProp name="RegexExtractor.match_number">3</stringProp>
-        </RegexExtractor>
+        <com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor guiclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.gui.JSONPathExtractorGui" testclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor" testname="jp@gc - JSON Path Extractor" enabled="true">
+          <stringProp name="VAR">admin_token</stringProp>
+          <stringProp name="JSONPATH">$</stringProp>
+          <stringProp name="DEFAULT"/>
+          <stringProp name="VARIABLE"/>
+          <stringProp name="SUBJECT">BODY</stringProp>
+        </com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor>
         <hashTree/>
-        <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert Order Id" enabled="true">
+        <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert token not null" enabled="true">
           <collectionProp name="Asserion.test_strings">
-            <stringProp name="89649215">^\d+$</stringProp>
+            <stringProp name="484395188">^[a-z0-9-]+$</stringProp>
           </collectionProp>
           <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
           <boolProp name="Assertion.assume_success">false</boolProp>
           <intProp name="Assertion.test_type">1</intProp>
           <stringProp name="Assertion.scope">variable</stringProp>
-          <stringProp name="Scope.variable">order_id</stringProp>
+          <stringProp name="Scope.variable">admin_token</stringProp>
         </ResponseAssertion>
         <hashTree/>
-        <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert Order Item 1" enabled="true">
-          <collectionProp name="Asserion.test_strings">
-            <stringProp name="89649215">^\d+$</stringProp>
-          </collectionProp>
-          <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
-          <boolProp name="Assertion.assume_success">false</boolProp>
-          <intProp name="Assertion.test_type">1</intProp>
-          <stringProp name="Assertion.scope">variable</stringProp>
-          <stringProp name="Scope.variable">order_item_1</stringProp>
-        </ResponseAssertion>
+      </hashTree>
+      <HeaderManager guiclass="HeaderPanel" testclass="HeaderManager" testname="HTTP Header Manager" enabled="true">
+        <collectionProp name="HeaderManager.headers">
+          <elementProp name="" elementType="Header">
+            <stringProp name="Header.name">Authorization</stringProp>
+            <stringProp name="Header.value">Bearer ${admin_token}</stringProp>
+          </elementProp>
+        </collectionProp>
+      </HeaderManager>
+      <hashTree/>
+      <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Get Configurable Product Options" enabled="true">
+        <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
+          <collectionProp name="Arguments.arguments"/>
+        </elementProp>
+        <stringProp name="HTTPSampler.domain"/>
+        <stringProp name="HTTPSampler.port"/>
+        <stringProp name="HTTPSampler.connect_timeout"/>
+        <stringProp name="HTTPSampler.response_timeout"/>
+        <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
+        <stringProp name="HTTPSampler.contentEncoding"/>
+        <stringProp name="HTTPSampler.path">${base_path}rest/V1/configurable-products/${product_sku}/options/all</stringProp>
+        <stringProp name="HTTPSampler.method">GET</stringProp>
+        <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
+        <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
+        <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
+        <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
+        <boolProp name="HTTPSampler.monitor">false</boolProp>
+        <stringProp name="HTTPSampler.embedded_url_re"/>
+      </HTTPSamplerProxy>
+      <hashTree>
+        <com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor guiclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.gui.JSONPathExtractorGui" testclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor" testname="JSON Path Extractor: Extract attribute_ids" enabled="true">
+          <stringProp name="VAR">attribute_ids</stringProp>
+          <stringProp name="JSONPATH">$.[*].attribute_id</stringProp>
+          <stringProp name="DEFAULT">NO_VALUE</stringProp>
+          <stringProp name="VARIABLE"/>
+          <stringProp name="SUBJECT">BODY</stringProp>
+        </com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor>
         <hashTree/>
-        <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert Order Item 2" enabled="true">
-          <collectionProp name="Asserion.test_strings">
-            <stringProp name="89649215">^\d+$</stringProp>
-          </collectionProp>
-          <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
-          <boolProp name="Assertion.assume_success">false</boolProp>
-          <intProp name="Assertion.test_type">1</intProp>
-          <stringProp name="Assertion.scope">variable</stringProp>
-          <stringProp name="Scope.variable">order_item_2</stringProp>
-        </ResponseAssertion>
+        <com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor guiclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.gui.JSONPathExtractorGui" testclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor" testname="JSON Path Extractor: Extract option_values" enabled="true">
+          <stringProp name="VAR">option_values</stringProp>
+          <stringProp name="JSONPATH">$.[*].values[0].value_index</stringProp>
+          <stringProp name="DEFAULT">NO_VALUE</stringProp>
+          <stringProp name="VARIABLE"/>
+          <stringProp name="SUBJECT">BODY</stringProp>
+        </com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor>
         <hashTree/>
-        <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert Order Item 3" enabled="true">
-          <collectionProp name="Asserion.test_strings">
-            <stringProp name="89649215">^\d+$</stringProp>
-          </collectionProp>
-          <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
-          <boolProp name="Assertion.assume_success">false</boolProp>
-          <intProp name="Assertion.test_type">1</intProp>
-          <stringProp name="Assertion.scope">variable</stringProp>
-          <stringProp name="Scope.variable">order_item_3</stringProp>
-        </ResponseAssertion>
+      </hashTree>
+    </hashTree>
+  
+    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Configurable Product ${_counter} Add To Cart" enabled="true">
+      <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
+        <collectionProp name="Arguments.arguments">
+          <elementProp name="product" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">${product_id}</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">product</stringProp>
+          </elementProp>
+          <elementProp name="related_product" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value"/>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">related_product</stringProp>
+          </elementProp>
+          <elementProp name="qty" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">1</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">qty</stringProp>
+          </elementProp>
+          <elementProp name="form_key" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">${form_key}</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">form_key</stringProp>
+          </elementProp>
+        </collectionProp>
+      </elementProp>
+      <stringProp name="HTTPSampler.domain"/>
+      <stringProp name="HTTPSampler.port"/>
+      <stringProp name="HTTPSampler.connect_timeout"/>
+      <stringProp name="HTTPSampler.response_timeout"/>
+      <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
+      <stringProp name="HTTPSampler.contentEncoding"/>
+      <stringProp name="HTTPSampler.path">${base_path}checkout/cart/add/</stringProp>
+      <stringProp name="HTTPSampler.method">POST</stringProp>
+      <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
+      <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
+      <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
+      <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
+      <boolProp name="HTTPSampler.monitor">false</boolProp>
+      <stringProp name="HTTPSampler.embedded_url_re"/>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/product_browsing_and_adding_items_to_the_cart/configurable_product_add_to_cart.jmx</stringProp></HTTPSamplerProxy>
+    <hashTree>
+        <BeanShellPreProcessor guiclass="TestBeanGUI" testclass="BeanShellPreProcessor" testname="BeanShell PreProcessor" enabled="true">
+                <boolProp name="resetInterpreter">false</boolProp>
+                <stringProp name="parameters"/>
+                <stringProp name="filename"/>
+                <stringProp name="script">
+                    try {
+                    attribute_ids = vars.get("attribute_ids");
+                    option_values = vars.get("option_values");
+                    attribute_ids = attribute_ids.replace("[","").replace("]","").replace("\"", "");
+                    option_values = option_values.replace("[","").replace("]","").replace("\"", "");
+                    attribute_ids_array = attribute_ids.split(",");
+                    option_values_array = option_values.split(",");
+                    args = ctx.getCurrentSampler().getArguments();
+                    it = args.iterator();
+                    while (it.hasNext()) {
+                        argument = it.next();
+                        if (argument.getStringValue().contains("${")) {
+                            args.removeArgument(argument.getName());
+                        }
+                    }
+                    for (int i = 0; i &lt; attribute_ids_array.length; i++) {
+                        ctx.getCurrentSampler().addArgument("super_attribute[" + attribute_ids_array[i] + "]", option_values_array[i]);
+                    }
+                    } catch (Exception e) {
+                        log.error("eror&#x2026;", e);
+                    }
+                </stringProp>
+              <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/common/configurable_product_add_to_cart_preprocessor.jmx</stringProp></BeanShellPreProcessor>
         <hashTree/>
-        <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert Order Created" enabled="true">
+    
+    <HeaderManager guiclass="HeaderPanel" testclass="HeaderManager" testname="HTTP Header Manager" enabled="true">
+      <collectionProp name="HeaderManager.headers">
+        <elementProp name="" elementType="Header">
+          <stringProp name="Header.name">X-Requested-With</stringProp>
+          <stringProp name="Header.value">XMLHttpRequest</stringProp>
+        </elementProp>
+      </collectionProp>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/common/http_header_manager_ajax.jmx</stringProp></HeaderManager>
+    <hashTree/>
+  </hashTree>
+  
+    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Load Cart Section ${_counter}" enabled="true">
+      <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
+        <collectionProp name="Arguments.arguments">
+          <elementProp name="sections" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">cart,messages</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">sections</stringProp>
+          </elementProp>
+          <elementProp name="update_section_id" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">true</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">update_section_id</stringProp>
+          </elementProp>
+          <elementProp name="_" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">${__time()}${__Random(1,1000000)}</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">_</stringProp>
+          </elementProp>
+        </collectionProp>
+      </elementProp>
+      <stringProp name="HTTPSampler.domain"/>
+      <stringProp name="HTTPSampler.port"/>
+      <stringProp name="HTTPSampler.connect_timeout"/>
+      <stringProp name="HTTPSampler.response_timeout"/>
+      <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
+      <stringProp name="HTTPSampler.contentEncoding"/>
+      <stringProp name="HTTPSampler.path">${base_path}customer/section/load/</stringProp>
+      <stringProp name="HTTPSampler.method">GET</stringProp>
+      <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
+      <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
+      <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
+      <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
+      <boolProp name="HTTPSampler.monitor">false</boolProp>
+      <stringProp name="HTTPSampler.embedded_url_re"/>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/load_cart_section.jmx</stringProp></HTTPSamplerProxy>
+    <hashTree>
+      <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Response Assertion" enabled="true">
+        <collectionProp name="Asserion.test_strings">
+          <stringProp name="210217247">You added ${product_name} to your shopping cart.</stringProp>
+        </collectionProp>
+        <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
+        <boolProp name="Assertion.assume_success">false</boolProp>
+        <intProp name="Assertion.test_type">2</intProp>
+      </ResponseAssertion>
+      <hashTree/>
+      <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Response Assertion" enabled="true">
+        <collectionProp name="Asserion.test_strings">
+          <stringProp name="2057973164">This product is out of stock.</stringProp>
+        </collectionProp>
+        <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
+        <boolProp name="Assertion.assume_success">false</boolProp>
+        <intProp name="Assertion.test_type">6</intProp>
+      </ResponseAssertion>
+      <hashTree/>
+      <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Response Assertion" enabled="true">
+        <collectionProp name="Asserion.test_strings">
+          <stringProp name="-350323027">\"summary_count\":${totalProductsAdded}</stringProp>
+        </collectionProp>
+        <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
+        <boolProp name="Assertion.assume_success">false</boolProp>
+        <intProp name="Assertion.test_type">2</intProp>
+      </ResponseAssertion>
+      <hashTree/>
+    
+    <HeaderManager guiclass="HeaderPanel" testclass="HeaderManager" testname="HTTP Header Manager" enabled="true">
+      <collectionProp name="HeaderManager.headers">
+        <elementProp name="" elementType="Header">
+          <stringProp name="Header.name">X-Requested-With</stringProp>
+          <stringProp name="Header.value">XMLHttpRequest</stringProp>
+        </elementProp>
+      </collectionProp>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/common/http_header_manager_ajax.jmx</stringProp></HeaderManager>
+    <hashTree/>
+  </hashTree>
+  </hashTree>
+  
+    <GenericController guiclass="LogicControllerGui" testclass="GenericController" testname="Make Cart Empty" enabled="true">
+  <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/simple_controller.jmx</stringProp>
+</GenericController>
+    <hashTree>
+      <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Open Cart" enabled="true">
+        <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
+          <collectionProp name="Arguments.arguments"/>
+        </elementProp>
+        <stringProp name="HTTPSampler.domain"/>
+        <stringProp name="HTTPSampler.port"/>
+        <stringProp name="HTTPSampler.connect_timeout"/>
+        <stringProp name="HTTPSampler.response_timeout"/>
+        <stringProp name="HTTPSampler.protocol"/>
+        <stringProp name="HTTPSampler.contentEncoding"/>
+        <stringProp name="HTTPSampler.path">${base_path}checkout/cart/</stringProp>
+        <stringProp name="HTTPSampler.method">GET</stringProp>
+        <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
+        <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
+        <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
+        <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
+        <boolProp name="HTTPSampler.monitor">false</boolProp>
+        <stringProp name="HTTPSampler.embedded_url_re"/>
+      <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/product_browsing_and_adding_items_to_the_cart/open_cart.jmx</stringProp></HTTPSamplerProxy>
+      <hashTree>
+        <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert Cart Opened" enabled="true">
           <collectionProp name="Asserion.test_strings">
-            <stringProp name="563107624">You created the order.</stringProp>
+            <stringProp name="-179817969">&lt;title&gt;Shopping Cart&lt;/title&gt;</stringProp>
           </collectionProp>
           <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
           <boolProp name="Assertion.assume_success">false</boolProp>
           <intProp name="Assertion.test_type">2</intProp>
         </ResponseAssertion>
         <hashTree/>
+        <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract cart qty inputs" enabled="true">
+          <stringProp name="RegexExtractor.useHeaders">false</stringProp>
+          <stringProp name="RegexExtractor.refname">cart_items_qty_inputs</stringProp>
+          <stringProp name="RegexExtractor.regex">name="cart\[([^\[\]]+)\]\[qty\]"</stringProp>
+          <stringProp name="RegexExtractor.template">$1$</stringProp>
+          <stringProp name="RegexExtractor.default"/>
+          <stringProp name="RegexExtractor.match_number">-1</stringProp>
+        </RegexExtractor>
+        <hashTree/>
       </hashTree>
-      <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Save Invoice" enabled="true">
+    
+    <LoopController guiclass="LoopControlPanel" testclass="LoopController" testname="Remove Items From Cart" enabled="true">
+      <boolProp name="LoopController.continue_forever">true</boolProp>
+      <stringProp name="LoopController.loops">${cart_items_qty_inputs_matchNr}</stringProp>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/loop_controller.jmx</stringProp></LoopController>
+    <hashTree>
+      <CounterConfig guiclass="CounterConfigGui" testclass="CounterConfig" testname="Counter" enabled="true">
+        <stringProp name="CounterConfig.start">1</stringProp>
+        <stringProp name="CounterConfig.end"/>
+        <stringProp name="CounterConfig.incr">1</stringProp>
+        <stringProp name="CounterConfig.name">_counter</stringProp>
+        <stringProp name="CounterConfig.format"/>
+        <boolProp name="CounterConfig.per_user">true</boolProp>
+        <boolProp name="CounterConfig.reset_on_tg_iteration">true</boolProp>
+      </CounterConfig>
+      <hashTree/>
+    
+    <BeanShellSampler guiclass="BeanShellSamplerGui" testclass="BeanShellSampler" testname="SetUp - Prepare Product Data for Removing from Cart" enabled="true">
+      <stringProp name="BeanShellSampler.query">
+id = vars.get("_counter");
+vars.put("uenc", vars.get("cart_items_uencs_" + id));
+vars.put("item_id", vars.get("cart_items_qty_inputs_" + id));
+      </stringProp>
+      <stringProp name="BeanShellSampler.filename"/>
+      <stringProp name="BeanShellSampler.parameters"/>
+      <boolProp name="BeanShellSampler.resetInterpreter">true</boolProp>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/product_browsing_and_adding_items_to_the_cart/remove_item_from_cart_setup.jmx</stringProp></BeanShellSampler>
+    <hashTree/>
+  
+        <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Remove item" enabled="true">
+           <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
+             <collectionProp name="Arguments.arguments">
+               <elementProp name="form_key" elementType="HTTPArgument">
+                 <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                 <stringProp name="Argument.value">${form_key}</stringProp>
+                 <stringProp name="Argument.metadata">=</stringProp>
+                 <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                 <stringProp name="Argument.name">form_key</stringProp>
+               </elementProp>
+               <elementProp name="uenc" elementType="HTTPArgument">
+                 <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                 <stringProp name="Argument.value">${uenc}</stringProp>
+                 <stringProp name="Argument.metadata">=</stringProp>
+                 <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                 <stringProp name="Argument.name">uenc</stringProp>
+               </elementProp>
+               <elementProp name="id" elementType="HTTPArgument">
+                 <boolProp name="HTTPArgument.always_encode">false</boolProp>
+                 <stringProp name="Argument.value">${item_id}</stringProp>
+                 <stringProp name="Argument.metadata">=</stringProp>
+                 <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                 <stringProp name="Argument.name">id</stringProp>
+               </elementProp>
+             </collectionProp>
+           </elementProp>
+           <stringProp name="HTTPSampler.domain"/>
+           <stringProp name="HTTPSampler.port"/>
+           <stringProp name="HTTPSampler.connect_timeout"/>
+           <stringProp name="HTTPSampler.response_timeout"/>
+           <stringProp name="HTTPSampler.protocol"/>
+           <stringProp name="HTTPSampler.contentEncoding"/>
+           <stringProp name="HTTPSampler.path">${base_path}checkout/cart/delete/</stringProp>
+           <stringProp name="HTTPSampler.method">POST</stringProp>
+           <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
+           <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
+           <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
+           <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
+           <boolProp name="HTTPSampler.monitor">false</boolProp>
+           <stringProp name="HTTPSampler.embedded_url_re"/>
+         <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/product_browsing_and_adding_items_to_the_cart/remove_item_from_cart.jmx</stringProp></HTTPSamplerProxy>
+    </hashTree>
+  
+    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Check Cart is Empty" enabled="true">
+      <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
+        <collectionProp name="Arguments.arguments">
+          <elementProp name="sections" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">cart</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">sections</stringProp>
+          </elementProp>
+          <elementProp name="update_section_id" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">true</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">update_section_id</stringProp>
+          </elementProp>
+          <elementProp name="_" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">${__time()}${__Random(1,1000000)}</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">_</stringProp>
+          </elementProp>
+        </collectionProp>
+      </elementProp>
+      <stringProp name="HTTPSampler.domain"/>
+      <stringProp name="HTTPSampler.port"/>
+      <stringProp name="HTTPSampler.connect_timeout"/>
+      <stringProp name="HTTPSampler.response_timeout"/>
+      <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
+      <stringProp name="HTTPSampler.contentEncoding"/>
+      <stringProp name="HTTPSampler.path">${base_path}customer/section/load/</stringProp>
+      <stringProp name="HTTPSampler.method">GET</stringProp>
+      <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
+      <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
+      <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
+      <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
+      <boolProp name="HTTPSampler.monitor">false</boolProp>
+      <stringProp name="HTTPSampler.embedded_url_re"/>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/product_browsing_and_adding_items_to_the_cart/check_cart_is_empty.jmx</stringProp></HTTPSamplerProxy>
+    <hashTree>
+      <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Response Assertion" enabled="true">
+        <collectionProp name="Asserion.test_strings">
+          <stringProp name="-350323027">\"summary_count\":0</stringProp>
+        </collectionProp>
+        <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
+        <boolProp name="Assertion.assume_success">false</boolProp>
+        <intProp name="Assertion.test_type">2</intProp>
+      </ResponseAssertion>
+      <hashTree/>
+    </hashTree>
+  </hashTree>
+  
+    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Logout" enabled="true">
+      <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
+        <collectionProp name="Arguments.arguments"/>
+      </elementProp>
+      <stringProp name="HTTPSampler.domain"/>
+      <stringProp name="HTTPSampler.port"/>
+      <stringProp name="HTTPSampler.connect_timeout"/>
+      <stringProp name="HTTPSampler.response_timeout"/>
+      <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
+      <stringProp name="HTTPSampler.contentEncoding"/>
+      <stringProp name="HTTPSampler.path">${base_path}customer/account/logout/</stringProp>
+      <stringProp name="HTTPSampler.method">GET</stringProp>
+      <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
+      <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
+      <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
+      <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
+      <boolProp name="HTTPSampler.monitor">false</boolProp>
+      <stringProp name="HTTPSampler.embedded_url_re"/>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/common/logout.jmx</stringProp></HTTPSamplerProxy>
+    <hashTree>
+      <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert success" enabled="true">
+        <collectionProp name="Asserion.test_strings">
+          <stringProp name="1723813687">You are signed out.</stringProp>
+        </collectionProp>
+        <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
+        <boolProp name="Assertion.assume_success">false</boolProp>
+        <intProp name="Assertion.test_type">2</intProp>
+      </ResponseAssertion>
+      <hashTree/>
+    
+    <BeanShellPostProcessor guiclass="TestBeanGUI" testclass="BeanShellPostProcessor" testname="Return Customer to Pool" enabled="true">
+        <boolProp name="resetInterpreter">false</boolProp>
+        <stringProp name="parameters"/>
+        <stringProp name="filename"/>
+        <stringProp name="script">
+customerUserList = props.get("customer_emails_list");
+customerUserList.add(vars.get("customer_email"));
+        </stringProp>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/common/return_email_to_pool.jmx</stringProp></BeanShellPostProcessor>
+    <hashTree/>
+  </hashTree>
+  </hashTree>
+
+  
+    <ThroughputController guiclass="ThroughputControllerGui" testclass="ThroughputController" testname="Account management" enabled="true">
+      <intProp name="ThroughputController.style">1</intProp>
+      <boolProp name="ThroughputController.perThread">false</boolProp>
+      <intProp name="ThroughputController.maxThroughput">1</intProp>
+      <stringProp name="ThroughputController.percentThroughput">${accountManagementPercentage}</stringProp>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/_system/scenario_controller_tmpl.jmx</stringProp></ThroughputController>
+    <hashTree>
+        <JSR223PreProcessor guiclass="TestBeanGUI" testclass="JSR223PreProcessor" testname="Set Test Label" enabled="true">
+            <stringProp name="script">
+var testLabel = "${testLabel}" ? " (${testLabel})" : "";
+if (testLabel
+    &amp;&amp; sampler.getClass().getName() == 'org.apache.jmeter.protocol.http.sampler.HTTPSamplerProxy'
+) {
+    if (sampler.getName().indexOf(testLabel) == -1) {
+       sampler.setName(sampler.getName() + testLabel);
+    }
+} else if (sampler.getName().indexOf("SetUp - ") == -1) {
+    sampler.setName("SetUp - " + sampler.getName());
+}
+            </stringProp>
+            <stringProp name="scriptLanguage">javascript</stringProp>
+        <stringProp name="TestPlan.comments">mpaf/tool/fragments/_system/setup_label.jmx</stringProp></JSR223PreProcessor>
+        <hashTree/>
+        <BeanShellSampler guiclass="BeanShellSamplerGui" testclass="BeanShellSampler" testname="SetUp - Set Label" enabled="true">
+            <stringProp name="BeanShellSampler.query">
+                vars.put("testLabel", "Account management");
+            </stringProp>
+            <boolProp name="BeanShellSampler.resetInterpreter">true</boolProp>
+        </BeanShellSampler>
+        <hashTree/>
+    
+    <CookieManager guiclass="CookiePanel" testclass="CookieManager" testname="HTTP Cookie Manager" enabled="true">
+      <collectionProp name="CookieManager.cookies">
+        <elementProp name="product_list_limit" elementType="Cookie" testname="product_list_limit">
+          <stringProp name="Cookie.value">30</stringProp>
+          <stringProp name="Cookie.domain">${host}</stringProp>
+          <stringProp name="Cookie.path">/</stringProp>
+          <boolProp name="Cookie.secure">false</boolProp>
+          <longProp name="Cookie.expires">0</longProp>
+          <boolProp name="Cookie.path_specified">true</boolProp>
+          <boolProp name="Cookie.domain_specified">true</boolProp>
+        </elementProp>
+        <elementProp name="product_list_limit" elementType="Cookie" testname="form_key">
+          <stringProp name="Cookie.value">${form_key}</stringProp>
+          <stringProp name="Cookie.domain">${host}</stringProp>
+          <stringProp name="Cookie.path">${base_path}</stringProp>
+          <boolProp name="Cookie.secure">false</boolProp>
+          <longProp name="Cookie.expires">0</longProp>
+          <boolProp name="Cookie.path_specified">true</boolProp>
+          <boolProp name="Cookie.domain_specified">true</boolProp>
+        </elementProp>
+      </collectionProp>
+      <boolProp name="CookieManager.clearEachIteration">true</boolProp>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/http_cookie_manager.jmx</stringProp></CookieManager>
+    <hashTree/>
+  
+    <CriticalSectionController guiclass="CriticalSectionControllerGui" testclass="CriticalSectionController" testname="Get Customer Email" enabled="true">
+        <stringProp name="CriticalSectionController.lockName">get-email</stringProp>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/lock_controller.jmx</stringProp></CriticalSectionController>
+    <hashTree>
+    
+    <BeanShellSampler guiclass="BeanShellSamplerGui" testclass="BeanShellSampler" testname="SetUp - Get Customer Email" enabled="true">
+      <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/get_customer_email.jmx</stringProp>
+      <stringProp name="BeanShellSampler.query">
+customerUserList = props.get("customer_emails_list");
+customerUser = customerUserList.poll();
+if (customerUser == null) {
+  SampleResult.setResponseMessage("customernUser list is empty");
+  SampleResult.setResponseData("customerUser list is empty","UTF-8");
+  IsSuccess=false;
+  SampleResult.setSuccessful(false);
+  SampleResult.setStopThread(true);
+}
+vars.put("customer_email", customerUser);
+      </stringProp>
+      <stringProp name="BeanShellSampler.filename"/>
+      <stringProp name="BeanShellSampler.parameters"/>
+      <boolProp name="BeanShellSampler.resetInterpreter">true</boolProp>
+    </BeanShellSampler>
+    <hashTree/>
+  </hashTree>
+  
+      <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Open Home Page" enabled="true">
         <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
-          <collectionProp name="Arguments.arguments">
-            <elementProp name="form_key" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.name">form_key</stringProp>
-              <stringProp name="Argument.value">${admin_form_key}</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            </elementProp>
-            <elementProp name="invoice[items][${order_item_1}]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.name">invoice[items][${order_item_1}]</stringProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            </elementProp>
-            <elementProp name="invoice[items][${order_item_2}]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.name">invoice[items][${order_item_2}]</stringProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            </elementProp>
-            <elementProp name="invoice[items][${order_item_3}]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.name">invoice[items][${order_item_3}]</stringProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            </elementProp>
-            <elementProp name="invoice[comment_text]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.name">invoice[comment_text]</stringProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            </elementProp>
-          </collectionProp>
+          <collectionProp name="Arguments.arguments"/>
         </elementProp>
         <stringProp name="HTTPSampler.domain"/>
         <stringProp name="HTTPSampler.port"/>
@@ -22739,20 +9780,19 @@ catch (java.lang.Exception e) {
         <stringProp name="HTTPSampler.response_timeout"/>
         <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
         <stringProp name="HTTPSampler.contentEncoding"/>
-        <stringProp name="HTTPSampler.path">${base_path}${admin_path}/sales/order_invoice/save/order_id/${order_id}/</stringProp>
-        <stringProp name="HTTPSampler.method">POST</stringProp>
+        <stringProp name="HTTPSampler.path">${base_path}</stringProp>
+        <stringProp name="HTTPSampler.method">GET</stringProp>
         <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
         <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
         <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
         <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
         <boolProp name="HTTPSampler.monitor">false</boolProp>
         <stringProp name="HTTPSampler.embedded_url_re"/>
-        <stringProp name="TestPlan.comments">Detected the start of a redirect chain</stringProp>
-      </HTTPSamplerProxy>
+      <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/common/open_home_page.jmx</stringProp></HTTPSamplerProxy>
       <hashTree>
-        <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert Invoice Created" enabled="true">
+        <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Response Assertion" enabled="true">
           <collectionProp name="Asserion.test_strings">
-            <stringProp name="-1878312078">The invoice has been created.</stringProp>
+            <stringProp name="571386695">&lt;title&gt;Home page&lt;/title&gt;</stringProp>
           </collectionProp>
           <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
           <boolProp name="Assertion.assume_success">false</boolProp>
@@ -22760,45 +9800,209 @@ catch (java.lang.Exception e) {
         </ResponseAssertion>
         <hashTree/>
       </hashTree>
-      <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Save Shipment" enabled="true">
+  
+    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Open Login Page" enabled="true">
+      <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
+        <collectionProp name="Arguments.arguments"/>
+      </elementProp>
+      <stringProp name="HTTPSampler.domain"/>
+      <stringProp name="HTTPSampler.port"/>
+      <stringProp name="HTTPSampler.connect_timeout"/>
+      <stringProp name="HTTPSampler.response_timeout"/>
+      <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
+      <stringProp name="HTTPSampler.contentEncoding"/>
+      <stringProp name="HTTPSampler.path">${base_path}customer/account/login/</stringProp>
+      <stringProp name="HTTPSampler.method">GET</stringProp>
+      <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
+      <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
+      <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
+      <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
+      <boolProp name="HTTPSampler.monitor">false</boolProp>
+      <stringProp name="HTTPSampler.embedded_url_re"/>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/common/open_login_page.jmx</stringProp></HTTPSamplerProxy>
+    <hashTree>
+      <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Response Assertion" enabled="true">
+        <collectionProp name="Asserion.test_strings">
+          <stringProp name="637394530">&lt;title&gt;Customer Login&lt;/title&gt;</stringProp>
+        </collectionProp>
+        <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
+        <boolProp name="Assertion.assume_success">false</boolProp>
+        <intProp name="Assertion.test_type">2</intProp>
+      </ResponseAssertion>
+      <hashTree/>
+    </hashTree>
+  
+    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Login" enabled="true">
+      <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
+        <collectionProp name="Arguments.arguments">
+          <elementProp name="form_key" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">${form_key}</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">form_key</stringProp>
+          </elementProp>
+          <elementProp name="login[username]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">${customer_email}</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">login[username]</stringProp>
+          </elementProp>
+          <elementProp name="login[password]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">${customer_password}</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">login[password]</stringProp>
+          </elementProp>
+          <elementProp name="send" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value"/>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">send</stringProp>
+          </elementProp>
+        </collectionProp>
+      </elementProp>
+      <stringProp name="HTTPSampler.domain"/>
+      <stringProp name="HTTPSampler.port"/>
+      <stringProp name="HTTPSampler.connect_timeout"/>
+      <stringProp name="HTTPSampler.response_timeout"/>
+      <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
+      <stringProp name="HTTPSampler.contentEncoding"/>
+      <stringProp name="HTTPSampler.path">${base_path}customer/account/loginPost/</stringProp>
+      <stringProp name="HTTPSampler.method">POST</stringProp>
+      <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
+      <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
+      <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
+      <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
+      <boolProp name="HTTPSampler.monitor">false</boolProp>
+      <stringProp name="HTTPSampler.embedded_url_re"/>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/common/login.jmx</stringProp></HTTPSamplerProxy>
+    <hashTree>
+      <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Response Assertion" enabled="true">
+        <collectionProp name="Asserion.test_strings">
+          <stringProp name="1312950388">&lt;title&gt;My Account&lt;/title&gt;</stringProp>
+        </collectionProp>
+        <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
+        <boolProp name="Assertion.assume_success">false</boolProp>
+        <intProp name="Assertion.test_type">2</intProp>
+      </ResponseAssertion>
+      <hashTree/>
+      <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract Address" enabled="true">
+        <stringProp name="RegexExtractor.useHeaders">false</stringProp>
+        <stringProp name="RegexExtractor.refname">addressId</stringProp>
+        <stringProp name="RegexExtractor.regex">customer/address/edit/id/([^'"]+)/</stringProp>
+        <stringProp name="RegexExtractor.template">$1$</stringProp>
+        <stringProp name="RegexExtractor.default"/>
+        <stringProp name="RegexExtractor.match_number">1</stringProp>
+      </RegexExtractor>
+      <hashTree/>
+      <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert addressId extracted" enabled="true">
+        <collectionProp name="Asserion.test_strings">
+          <stringProp name="2845929">^.+$</stringProp>
+        </collectionProp>
+        <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
+        <boolProp name="Assertion.assume_success">false</boolProp>
+        <intProp name="Assertion.test_type">1</intProp>
+        <stringProp name="Assertion.scope">variable</stringProp>
+        <stringProp name="Scope.variable">addressId</stringProp>
+      </ResponseAssertion>
+      <hashTree/>
+    </hashTree>
+    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Load Customer Private Data" enabled="true">
+      <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
+        <collectionProp name="Arguments.arguments">
+          <elementProp name="sections" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value"/>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">sections</stringProp>
+          </elementProp>
+          <elementProp name="update_section_id" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">false</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">update_section_id</stringProp>
+          </elementProp>
+          <elementProp name="_" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">${__time()}${__Random(1,1000000)}</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">_</stringProp>
+          </elementProp>
+        </collectionProp>
+      </elementProp>
+      <stringProp name="HTTPSampler.domain"/>
+      <stringProp name="HTTPSampler.port"/>
+      <stringProp name="HTTPSampler.connect_timeout"/>
+      <stringProp name="HTTPSampler.response_timeout"/>
+      <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
+      <stringProp name="HTTPSampler.contentEncoding"/>
+      <stringProp name="HTTPSampler.path">${base_path}customer/section/load/</stringProp>
+      <stringProp name="HTTPSampler.method">GET</stringProp>
+      <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
+      <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
+      <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
+      <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
+      <boolProp name="HTTPSampler.monitor">false</boolProp>
+      <stringProp name="HTTPSampler.embedded_url_re"/>
+    </HTTPSamplerProxy>
+    <hashTree/>
+  
+    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="My Orders" enabled="true">
+      <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
+        <collectionProp name="Arguments.arguments"/>
+      </elementProp>
+      <stringProp name="HTTPSampler.domain"/>
+      <stringProp name="HTTPSampler.port"/>
+      <stringProp name="HTTPSampler.connect_timeout"/>
+      <stringProp name="HTTPSampler.response_timeout"/>
+      <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
+      <stringProp name="HTTPSampler.contentEncoding"/>
+      <stringProp name="HTTPSampler.path">${base_path}sales/order/history/</stringProp>
+      <stringProp name="HTTPSampler.method">GET</stringProp>
+      <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
+      <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
+      <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
+      <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
+      <boolProp name="HTTPSampler.monitor">false</boolProp>
+      <stringProp name="HTTPSampler.embedded_url_re"/>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/account_management/my_orders.jmx</stringProp></HTTPSamplerProxy>
+    <hashTree>
+      <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Response Assertion" enabled="true">
+        <collectionProp name="Asserion.test_strings">
+          <stringProp name="220295440">&lt;title&gt;My Orders&lt;/title&gt;</stringProp>
+        </collectionProp>
+        <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
+        <boolProp name="Assertion.assume_success">false</boolProp>
+        <intProp name="Assertion.test_type">2</intProp>
+      </ResponseAssertion>
+      <hashTree/>
+      <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract orderId" enabled="true">
+        <stringProp name="RegexExtractor.useHeaders">false</stringProp>
+        <stringProp name="RegexExtractor.refname">orderId</stringProp>
+        <stringProp name="RegexExtractor.regex">sales/order/view/order_id/(\d+)/</stringProp>
+        <stringProp name="RegexExtractor.template">$1$</stringProp>
+        <stringProp name="RegexExtractor.default">NOT_FOUND</stringProp>
+        <stringProp name="RegexExtractor.match_number">1</stringProp>
+      </RegexExtractor>
+      <hashTree/>
+    </hashTree>
+  
+    <IfController guiclass="IfControllerPanel" testclass="IfController" testname="If Orders Controller" enabled="true">
+      <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/account_management/if_orders.jmx</stringProp>
+      <stringProp name="IfController.condition">"${orderId}" != "NOT_FOUND"</stringProp>
+      <boolProp name="IfController.evaluateAll">false</boolProp>
+    </IfController>
+    <hashTree>
+      <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="View Order" enabled="true">
         <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
-          <collectionProp name="Arguments.arguments">
-            <elementProp name="form_key" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.name">form_key</stringProp>
-              <stringProp name="Argument.value">${admin_form_key}</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            </elementProp>
-            <elementProp name="shipment[items][${order_item_1}]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.name">shipment[items][${order_item_1}]</stringProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            </elementProp>
-            <elementProp name="shipment[items][${order_item_2}]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.name">shipment[items][${order_item_2}]</stringProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            </elementProp>
-            <elementProp name="shipment[items][${order_item_3}]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.name">shipment[items][${order_item_3}]</stringProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            </elementProp>
-            <elementProp name="shipment[comment_text]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.name">shipment[comment_text]</stringProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            </elementProp>
-          </collectionProp>
+          <collectionProp name="Arguments.arguments"/>
         </elementProp>
         <stringProp name="HTTPSampler.domain"/>
         <stringProp name="HTTPSampler.port"/>
@@ -22806,41 +10010,416 @@ catch (java.lang.Exception e) {
         <stringProp name="HTTPSampler.response_timeout"/>
         <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
         <stringProp name="HTTPSampler.contentEncoding"/>
-        <stringProp name="HTTPSampler.path">${base_path}${admin_path}/admin/order_shipment/save/order_id/${order_id}/</stringProp>
-        <stringProp name="HTTPSampler.method">POST</stringProp>
+        <stringProp name="HTTPSampler.path">${base_path}sales/order/view/order_id/${orderId}</stringProp>
+        <stringProp name="HTTPSampler.method">GET</stringProp>
         <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
         <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
         <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
         <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
         <boolProp name="HTTPSampler.monitor">false</boolProp>
         <stringProp name="HTTPSampler.embedded_url_re"/>
-        <stringProp name="TestPlan.comments">Detected the start of a redirect chain</stringProp>
       </HTTPSamplerProxy>
       <hashTree>
-        <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert Shipment Created" enabled="true">
+        <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Response Assertion" enabled="true">
           <collectionProp name="Asserion.test_strings">
-            <stringProp name="-348539683">The shipment has been created.</stringProp>
+            <stringProp name="1956770127">&lt;title&gt;Order #</stringProp>
           </collectionProp>
           <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
           <boolProp name="Assertion.assume_success">false</boolProp>
           <intProp name="Assertion.test_type">2</intProp>
         </ResponseAssertion>
         <hashTree/>
+        <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract shipment tab" enabled="true">
+          <stringProp name="RegexExtractor.useHeaders">false</stringProp>
+          <stringProp name="RegexExtractor.refname">shipment_tab</stringProp>
+          <stringProp name="RegexExtractor.regex">sales/order/shipment/order_id/(\d+)..Order Shipments</stringProp>
+          <stringProp name="RegexExtractor.template">$1$</stringProp>
+          <stringProp name="RegexExtractor.default">NOT_FOUND</stringProp>
+          <stringProp name="RegexExtractor.match_number">1</stringProp>
+        </RegexExtractor>
+        <hashTree/>
+      </hashTree>
+      <IfController guiclass="IfControllerPanel" testclass="IfController" testname="If Shipments Controller" enabled="true">
+        <stringProp name="TestPlan.comments">May not have shipped</stringProp>
+        <stringProp name="IfController.condition">"${shipment_tab}" != "NOT_FOUND"</stringProp>
+        <boolProp name="IfController.evaluateAll">false</boolProp>
+      </IfController>
+      <hashTree>
+        <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="View Order Shipments" enabled="true">
+          <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
+            <collectionProp name="Arguments.arguments"/>
+          </elementProp>
+          <stringProp name="HTTPSampler.domain"/>
+          <stringProp name="HTTPSampler.port"/>
+          <stringProp name="HTTPSampler.connect_timeout"/>
+          <stringProp name="HTTPSampler.response_timeout"/>
+          <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
+          <stringProp name="HTTPSampler.contentEncoding"/>
+          <stringProp name="HTTPSampler.path">${base_path}sales/order/shipment/order_id/${orderId}</stringProp>
+          <stringProp name="HTTPSampler.method">GET</stringProp>
+          <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
+          <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
+          <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
+          <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
+          <boolProp name="HTTPSampler.monitor">false</boolProp>
+          <stringProp name="HTTPSampler.embedded_url_re"/>
+        </HTTPSamplerProxy>
+        <hashTree>
+          <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Response Assertion" enabled="true">
+            <collectionProp name="Asserion.test_strings">
+              <stringProp name="120578727">Track this shipment</stringProp>
+            </collectionProp>
+            <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
+            <boolProp name="Assertion.assume_success">false</boolProp>
+            <intProp name="Assertion.test_type">2</intProp>
+          </ResponseAssertion>
+          <hashTree/>
+          <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract popup link" enabled="true">
+            <stringProp name="RegexExtractor.useHeaders">false</stringProp>
+            <stringProp name="RegexExtractor.refname">popupLink</stringProp>
+            <stringProp name="RegexExtractor.regex">popupWindow": {"windowURL":"([^'"]+)",</stringProp>
+            <stringProp name="RegexExtractor.template">$1$</stringProp>
+            <stringProp name="RegexExtractor.default"/>
+            <stringProp name="RegexExtractor.match_number">1</stringProp>
+          </RegexExtractor>
+          <hashTree/>
+        </hashTree>
+        <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Track Shipment" enabled="true">
+          <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
+            <collectionProp name="Arguments.arguments"/>
+          </elementProp>
+          <stringProp name="HTTPSampler.domain"/>
+          <stringProp name="HTTPSampler.port"/>
+          <stringProp name="HTTPSampler.connect_timeout"/>
+          <stringProp name="HTTPSampler.response_timeout"/>
+          <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
+          <stringProp name="HTTPSampler.contentEncoding"/>
+          <stringProp name="HTTPSampler.path">${popupLink}</stringProp>
+          <stringProp name="HTTPSampler.method">GET</stringProp>
+          <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
+          <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
+          <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
+          <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
+          <boolProp name="HTTPSampler.monitor">false</boolProp>
+          <stringProp name="HTTPSampler.embedded_url_re"/>
+        </HTTPSamplerProxy>
+        <hashTree>
+          <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Response Assertion" enabled="true">
+            <collectionProp name="Asserion.test_strings">
+              <stringProp name="-760430210">&lt;title&gt;Tracking Information&lt;/title&gt;</stringProp>
+            </collectionProp>
+            <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
+            <boolProp name="Assertion.assume_success">false</boolProp>
+            <intProp name="Assertion.test_type">2</intProp>
+          </ResponseAssertion>
+          <hashTree/>
+        </hashTree>
       </hashTree>
     </hashTree>
+  
+    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="My Downloadable Products" enabled="true">
+      <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
+        <collectionProp name="Arguments.arguments"/>
+      </elementProp>
+      <stringProp name="HTTPSampler.domain"/>
+      <stringProp name="HTTPSampler.port"/>
+      <stringProp name="HTTPSampler.connect_timeout"/>
+      <stringProp name="HTTPSampler.response_timeout"/>
+      <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
+      <stringProp name="HTTPSampler.contentEncoding"/>
+      <stringProp name="HTTPSampler.path">${base_path}downloadable/customer/products</stringProp>
+      <stringProp name="HTTPSampler.method">GET</stringProp>
+      <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
+      <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
+      <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
+      <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
+      <boolProp name="HTTPSampler.monitor">false</boolProp>
+      <stringProp name="HTTPSampler.embedded_url_re"/>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/account_management/my_downloadable_products.jmx</stringProp></HTTPSamplerProxy>
+    <hashTree>
+      <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Response Assertion" enabled="true">
+        <collectionProp name="Asserion.test_strings">
+          <stringProp name="358050505">&lt;title&gt;My Downloadable Products&lt;/title&gt;</stringProp>
+        </collectionProp>
+        <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
+        <boolProp name="Assertion.assume_success">false</boolProp>
+        <intProp name="Assertion.test_type">2</intProp>
+      </ResponseAssertion>
+      <hashTree/>
+      <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract orderId" enabled="true">
+        <stringProp name="RegexExtractor.useHeaders">false</stringProp>
+        <stringProp name="RegexExtractor.refname">orderId</stringProp>
+        <stringProp name="RegexExtractor.regex">sales/order/view/order_id/(\d+)/</stringProp>
+        <stringProp name="RegexExtractor.template">$1$</stringProp>
+        <stringProp name="RegexExtractor.default">NOT_FOUND</stringProp>
+        <stringProp name="RegexExtractor.match_number">1</stringProp>
+      </RegexExtractor>
+      <hashTree/>
+      <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract linkId" enabled="true">
+        <stringProp name="RegexExtractor.useHeaders">false</stringProp>
+        <stringProp name="RegexExtractor.refname">linkId</stringProp>
+        <stringProp name="RegexExtractor.regex">downloadable/download/link/id/(\d+)/</stringProp>
+        <stringProp name="RegexExtractor.template">$1$</stringProp>
+        <stringProp name="RegexExtractor.default"/>
+        <stringProp name="RegexExtractor.match_number">1</stringProp>
+      </RegexExtractor>
+      <hashTree/>
+    </hashTree>
+  
+    <IfController guiclass="IfControllerPanel" testclass="IfController" testname="If Downloadables Controller" enabled="true">
+      <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/account_management/if_downloadables.jmx</stringProp>
+      <stringProp name="IfController.condition">"${orderId}" != "NOT_FOUND"</stringProp>
+      <boolProp name="IfController.evaluateAll">false</boolProp>
+    </IfController>
+    <hashTree>
+    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="View Downloadable Product" enabled="true">
+      <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
+        <collectionProp name="Arguments.arguments"/>
+      </elementProp>
+      <stringProp name="HTTPSampler.domain"/>
+      <stringProp name="HTTPSampler.port"/>
+      <stringProp name="HTTPSampler.connect_timeout"/>
+      <stringProp name="HTTPSampler.response_timeout"/>
+      <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
+      <stringProp name="HTTPSampler.contentEncoding"/>
+      <stringProp name="HTTPSampler.path">${base_path}sales/order/view/order_id/${orderId}</stringProp>
+      <stringProp name="HTTPSampler.method">GET</stringProp>
+      <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
+      <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
+      <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
+      <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
+      <boolProp name="HTTPSampler.monitor">false</boolProp>
+      <stringProp name="HTTPSampler.embedded_url_re"/>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/account_management/view_downloadable_products.jmx</stringProp></HTTPSamplerProxy>
+    <hashTree>
+      <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Response Assertion" enabled="true">
+        <collectionProp name="Asserion.test_strings">
+          <stringProp name="1956770127">&lt;title&gt;Order #</stringProp>
+        </collectionProp>
+        <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
+        <boolProp name="Assertion.assume_success">false</boolProp>
+        <intProp name="Assertion.test_type">2</intProp>
+      </ResponseAssertion>
+      <hashTree/>
+    </hashTree>
+  
+    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Download Product" enabled="true">
+      <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
+        <collectionProp name="Arguments.arguments"/>
+      </elementProp>
+      <stringProp name="HTTPSampler.domain"/>
+      <stringProp name="HTTPSampler.port"/>
+      <stringProp name="HTTPSampler.connect_timeout"/>
+      <stringProp name="HTTPSampler.response_timeout"/>
+      <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
+      <stringProp name="HTTPSampler.contentEncoding"/>
+      <stringProp name="HTTPSampler.path">${base_path}downloadable/download/link/id/${linkId}</stringProp>
+      <stringProp name="HTTPSampler.method">GET</stringProp>
+      <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
+      <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
+      <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
+      <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
+      <boolProp name="HTTPSampler.monitor">false</boolProp>
+      <stringProp name="HTTPSampler.embedded_url_re"/>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/account_management/download_product.jmx</stringProp></HTTPSamplerProxy>
+    <hashTree/>
+  </hashTree>
+  
+    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="My Wish List" enabled="true">
+      <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
+        <collectionProp name="Arguments.arguments"/>
+      </elementProp>
+      <stringProp name="HTTPSampler.domain"/>
+      <stringProp name="HTTPSampler.port"/>
+      <stringProp name="HTTPSampler.connect_timeout"/>
+      <stringProp name="HTTPSampler.response_timeout"/>
+      <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
+      <stringProp name="HTTPSampler.contentEncoding"/>
+      <stringProp name="HTTPSampler.path">${base_path}wishlist</stringProp>
+      <stringProp name="HTTPSampler.method">GET</stringProp>
+      <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
+      <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
+      <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
+      <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
+      <boolProp name="HTTPSampler.monitor">false</boolProp>
+      <stringProp name="HTTPSampler.embedded_url_re"/>
+    </HTTPSamplerProxy>
+    <hashTree>
+      <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Response Assertion" enabled="true">
+        <collectionProp name="Asserion.test_strings">
+          <stringProp name="-1907714722">&lt;title&gt;My Wish List&lt;/title&gt;</stringProp>
+        </collectionProp>
+        <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
+        <boolProp name="Assertion.assume_success">false</boolProp>
+        <intProp name="Assertion.test_type">2</intProp>
+      </ResponseAssertion>
+      <hashTree/>
+      <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract wishlistId" enabled="true">
+        <stringProp name="RegexExtractor.useHeaders">false</stringProp>
+        <stringProp name="RegexExtractor.refname">wishlistId</stringProp>
+        <stringProp name="RegexExtractor.regex">wishlist/index/update/wishlist_id/([^'"]+)/</stringProp>
+        <stringProp name="RegexExtractor.template">$1$</stringProp>
+        <stringProp name="RegexExtractor.default"/>
+        <stringProp name="RegexExtractor.match_number">1</stringProp>
+        <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/account_management/my_wish_list.jmx</stringProp>
+      </RegexExtractor>
+      <hashTree/>
+      <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Verify that there are items in the wishlist" enabled="true">
+        <stringProp name="RegexExtractor.useHeaders">false</stringProp>
+        <stringProp name="RegexExtractor.refname">buttonTitle</stringProp>
+        <stringProp name="RegexExtractor.regex">Update Wish List</stringProp>
+        <stringProp name="RegexExtractor.template">FOUND</stringProp>
+        <stringProp name="RegexExtractor.default">NOT_FOUND</stringProp>
+        <stringProp name="RegexExtractor.match_number">1</stringProp>
+      </RegexExtractor>
+      <hashTree/>
+    </hashTree>
+  
+    <IfController guiclass="IfControllerPanel" testclass="IfController" testname="If Wish List Controller" enabled="true">
+      <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/account_management/if_wishlist.jmx</stringProp>
+      <stringProp name="IfController.condition">"${buttonTitle}" === "FOUND"</stringProp>
+      <boolProp name="IfController.evaluateAll">false</boolProp>
+    </IfController>
+    <hashTree>
+    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Share Wish List" enabled="true">
+      <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
+        <collectionProp name="Arguments.arguments"/>
+      </elementProp>
+      <stringProp name="HTTPSampler.domain"/>
+      <stringProp name="HTTPSampler.port"/>
+      <stringProp name="HTTPSampler.connect_timeout"/>
+      <stringProp name="HTTPSampler.response_timeout"/>
+      <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
+      <stringProp name="HTTPSampler.contentEncoding"/>
+      <stringProp name="HTTPSampler.path">${base_path}wishlist/index/share/wishlist_id/${wishlistId}/</stringProp>
+      <stringProp name="HTTPSampler.method">GET</stringProp>
+      <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
+      <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
+      <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
+      <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
+      <boolProp name="HTTPSampler.monitor">false</boolProp>
+      <stringProp name="HTTPSampler.embedded_url_re"/>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/account_management/share_wish_list.jmx</stringProp></HTTPSamplerProxy>
+    <hashTree>
+      <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Response Assertion" enabled="true">
+        <collectionProp name="Asserion.test_strings">
+          <stringProp name="1257102154">&lt;title&gt;Wish List Sharing&lt;/title&gt;</stringProp>
+        </collectionProp>
+        <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
+        <boolProp name="Assertion.assume_success">false</boolProp>
+        <intProp name="Assertion.test_type">2</intProp>
+      </ResponseAssertion>
+      <hashTree/>
+    </hashTree>
+  
+    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Send Wish List" enabled="true">
+      <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
+        <collectionProp name="Arguments.arguments">
+          <elementProp name="form_key" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">${form_key}</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">form_key</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
+          </elementProp>
+          <elementProp name="emails" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">${customer_email}</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">emails</stringProp>
+          </elementProp>
+          <elementProp name="message" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">[TEST] See my wishlist!!!</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">message</stringProp>
+          </elementProp>
+        </collectionProp>
+      </elementProp>
+      <stringProp name="HTTPSampler.domain"/>
+      <stringProp name="HTTPSampler.port"/>
+      <stringProp name="HTTPSampler.connect_timeout"/>
+      <stringProp name="HTTPSampler.response_timeout"/>
+      <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
+      <stringProp name="HTTPSampler.contentEncoding"/>
+      <stringProp name="HTTPSampler.path">${base_path}wishlist/index/send/wishlist_id/${wishlistId}/</stringProp>
+      <stringProp name="HTTPSampler.method">POST</stringProp>
+      <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
+      <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
+      <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
+      <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
+      <boolProp name="HTTPSampler.monitor">false</boolProp>
+      <stringProp name="HTTPSampler.embedded_url_re"/>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/account_management/send_wish_list.jmx</stringProp></HTTPSamplerProxy>
+    <hashTree>
+      <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Response Assertion" enabled="true">
+        <collectionProp name="Asserion.test_strings">
+          <stringProp name="-1907714722">&lt;title&gt;My Wish List&lt;/title&gt;</stringProp>
+        </collectionProp>
+        <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
+        <boolProp name="Assertion.assume_success">false</boolProp>
+        <intProp name="Assertion.test_type">2</intProp>
+      </ResponseAssertion>
+      <hashTree/>
+    </hashTree>
+  </hashTree>
+  
+    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Logout" enabled="true">
+      <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
+        <collectionProp name="Arguments.arguments"/>
+      </elementProp>
+      <stringProp name="HTTPSampler.domain"/>
+      <stringProp name="HTTPSampler.port"/>
+      <stringProp name="HTTPSampler.connect_timeout"/>
+      <stringProp name="HTTPSampler.response_timeout"/>
+      <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
+      <stringProp name="HTTPSampler.contentEncoding"/>
+      <stringProp name="HTTPSampler.path">${base_path}customer/account/logout/</stringProp>
+      <stringProp name="HTTPSampler.method">GET</stringProp>
+      <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
+      <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
+      <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
+      <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
+      <boolProp name="HTTPSampler.monitor">false</boolProp>
+      <stringProp name="HTTPSampler.embedded_url_re"/>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/common/logout.jmx</stringProp></HTTPSamplerProxy>
+    <hashTree>
+      <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert success" enabled="true">
+        <collectionProp name="Asserion.test_strings">
+          <stringProp name="1723813687">You are signed out.</stringProp>
+        </collectionProp>
+        <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
+        <boolProp name="Assertion.assume_success">false</boolProp>
+        <intProp name="Assertion.test_type">2</intProp>
+      </ResponseAssertion>
+      <hashTree/>
+    
+    <BeanShellPostProcessor guiclass="TestBeanGUI" testclass="BeanShellPostProcessor" testname="Return Customer to Pool" enabled="true">
+        <boolProp name="resetInterpreter">false</boolProp>
+        <stringProp name="parameters"/>
+        <stringProp name="filename"/>
+        <stringProp name="script">
+customerUserList = props.get("customer_emails_list");
+customerUserList.add(vars.get("customer_email"));
+        </stringProp>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/common/return_email_to_pool.jmx</stringProp></BeanShellPostProcessor>
+    <hashTree/>
   </hashTree>
   </hashTree>
 
   </hashTree>
 
     
-        <ThreadGroup guiclass="ThreadGroupGui" testclass="ThreadGroup" testname="Others" enabled="true">
+        <ThreadGroup guiclass="ThreadGroupGui" testclass="ThreadGroup" testname="Admin Pool" enabled="true">
             <stringProp name="ThreadGroup.on_sample_error">continue</stringProp>
             <elementProp name="ThreadGroup.main_controller" elementType="LoopController" guiclass="LoopControlPanel" testclass="LoopController" testname="Loop Controller" enabled="true">
                 <boolProp name="LoopController.continue_forever">false</boolProp>
                 <stringProp name="LoopController.loops">${loops}</stringProp>
             </elementProp>
-            <stringProp name="ThreadGroup.num_threads">${othersPoolUsers}</stringProp>
+            <stringProp name="ThreadGroup.num_threads">${adminPoolUsers}</stringProp>
             <stringProp name="ThreadGroup.ramp_time">${ramp_period}</stringProp>
             <longProp name="ThreadGroup.start_time">1505803944000</longProp>
             <longProp name="ThreadGroup.end_time">1505803944000</longProp>
@@ -22849,11 +10428,11 @@ catch (java.lang.Exception e) {
             <stringProp name="ThreadGroup.delay"/>
         <stringProp name="TestPlan.comments">mpaf/tool/fragments/_system/thread_group.jmx</stringProp></ThreadGroup>
         <hashTree>
-    <ThroughputController guiclass="ThroughputControllerGui" testclass="ThroughputController" testname="Admin Customer Management" enabled="true">
+    <ThroughputController guiclass="ThroughputControllerGui" testclass="ThroughputController" testname="Admin CMS Management" enabled="true">
       <intProp name="ThroughputController.style">1</intProp>
       <boolProp name="ThroughputController.perThread">false</boolProp>
       <intProp name="ThroughputController.maxThroughput">1</intProp>
-      <stringProp name="ThroughputController.percentThroughput">${adminCustomerManagementPercentage}</stringProp>
+      <stringProp name="ThroughputController.percentThroughput">${adminCMSManagementPercentage}</stringProp>
     <stringProp name="TestPlan.comments">mpaf/tool/fragments/_system/scenario_controller_tmpl.jmx</stringProp></ThroughputController>
     <hashTree>
         <JSR223PreProcessor guiclass="TestBeanGUI" testclass="JSR223PreProcessor" testname="Set Test Label" enabled="true">
@@ -22874,7 +10453,7 @@ if (testLabel
         <hashTree/>
         <BeanShellSampler guiclass="BeanShellSamplerGui" testclass="BeanShellSampler" testname="SetUp - Set Label" enabled="true">
             <stringProp name="BeanShellSampler.query">
-                vars.put("testLabel", "Admin Customer Management");
+                vars.put("testLabel", "Admin CMS Management");
             </stringProp>
             <boolProp name="BeanShellSampler.resetInterpreter">true</boolProp>
         </BeanShellSampler>
@@ -22934,10 +10513,36 @@ if (testLabel
     <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/http_cookie_manager_without_clear_each_iteration.jmx</stringProp></CookieManager>
     <hashTree/>
   
-    <OnceOnlyController guiclass="OnceOnlyControllerGui" testclass="OnceOnlyController" testname="Once Only Controller" enabled="true">
-  <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/once_only_controller.jmx</stringProp>
-</OnceOnlyController>
+    <GenericController guiclass="LogicControllerGui" testclass="GenericController" testname="Admin Login" enabled="true">
+  <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/simple_controller.jmx</stringProp>
+</GenericController>
     <hashTree>
+    <CriticalSectionController guiclass="CriticalSectionControllerGui" testclass="CriticalSectionController" testname="Admin Login Lock" enabled="true">
+        <stringProp name="CriticalSectionController.lockName">get-admin-email</stringProp>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/lock_controller.jmx</stringProp></CriticalSectionController>
+    <hashTree>
+    
+    <BeanShellSampler guiclass="BeanShellSamplerGui" testclass="BeanShellSampler" testname="SetUp - Get Admin Email" enabled="true">
+      <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/get_admin_email.jmx</stringProp>
+      <stringProp name="BeanShellSampler.query">
+adminUserList = props.get("adminUserList");
+adminUser = adminUserList.poll();
+if (adminUser == null) {
+  SampleResult.setResponseMessage("adminUser list is empty");
+  SampleResult.setResponseData("adminUser list is empty","UTF-8");
+  IsSuccess=false;
+  SampleResult.setSuccessful(false);
+  SampleResult.setStopThread(true);
+}
+vars.put("admin_user", adminUser);
+      </stringProp>
+      <stringProp name="BeanShellSampler.filename"/>
+      <stringProp name="BeanShellSampler.parameters"/>
+      <boolProp name="BeanShellSampler.resetInterpreter">true</boolProp>
+    </BeanShellSampler>
+    <hashTree/>
+  </hashTree>
+  
     <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="SetUp - Login" enabled="true">
       <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
         <collectionProp name="Arguments.arguments"/>
@@ -23051,118 +10656,19 @@ if (testLabel
         <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_login/admin_retrieve_form_key.jmx</stringProp></RegexExtractor>
         <hashTree/>
     </hashTree>
-  </hashTree>
-  
-    <GenericController guiclass="LogicControllerGui" testclass="GenericController" testname="Simple Controller" enabled="true">
-  <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/simple_controller.jmx</stringProp>
-</GenericController>
-    <hashTree>
-    <TestFragmentController guiclass="TestFragmentControllerGui" testclass="TestFragmentController" testname="Admin Customer Management" enabled="true">
-  <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_customer_management/admin_customer_management.jmx</stringProp>
-</TestFragmentController>
-    <hashTree>
-      <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Landing Page" enabled="true">
-        <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
-          <collectionProp name="Arguments.arguments"/>
-        </elementProp>
-        <stringProp name="HTTPSampler.domain"/>
-        <stringProp name="HTTPSampler.port"/>
-        <stringProp name="HTTPSampler.connect_timeout"/>
-        <stringProp name="HTTPSampler.response_timeout"/>
-        <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
-        <stringProp name="HTTPSampler.contentEncoding"/>
-        <stringProp name="HTTPSampler.path">${base_path}${admin_path}/customer/index</stringProp>
-        <stringProp name="HTTPSampler.method">GET</stringProp>
-        <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
-        <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
-        <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
-        <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
-        <boolProp name="HTTPSampler.monitor">false</boolProp>
-        <stringProp name="HTTPSampler.embedded_url_re"/>
-      </HTTPSamplerProxy>
-      <hashTree>
-        <HeaderManager guiclass="HeaderPanel" testclass="HeaderManager" testname="HTTP Header Manager" enabled="true">
-          <collectionProp name="HeaderManager.headers">
-            <elementProp name="Accept-Language" elementType="Header">
-              <stringProp name="Header.name">Accept-Language</stringProp>
-              <stringProp name="Header.value">en-US,en;q=0.5</stringProp>
-            </elementProp>
-            <elementProp name="Accept" elementType="Header">
-              <stringProp name="Header.name">Accept</stringProp>
-              <stringProp name="Header.value">text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8</stringProp>
-            </elementProp>
-            <elementProp name="User-Agent" elementType="Header">
-              <stringProp name="Header.name">User-Agent</stringProp>
-              <stringProp name="Header.value">Mozilla/5.0 (Windows NT 6.1; WOW64; rv:27.0) Gecko/20100101 Firefox/27.0</stringProp>
-            </elementProp>
-            <elementProp name="Accept-Encoding" elementType="Header">
-              <stringProp name="Header.name">Accept-Encoding</stringProp>
-              <stringProp name="Header.value">gzip, deflate</stringProp>
-            </elementProp>
-          </collectionProp>
-        </HeaderManager>
-        <hashTree/>
-      </hashTree>
-      <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Render" enabled="true">
-        <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
-          <collectionProp name="Arguments.arguments">
-            <elementProp name="namespace" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">customer_listing</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">namespace</stringProp>
-            </elementProp>
-            <elementProp name="search" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">search</stringProp>
-            </elementProp>
-            <elementProp name="filters[placeholder]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">true</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">filters[placeholder]</stringProp>
-            </elementProp>
-            <elementProp name="paging[pageSize]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">20</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">paging[pageSize]</stringProp>
-            </elementProp>
-            <elementProp name="paging[current]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">paging[current]</stringProp>
-            </elementProp>
-            <elementProp name="sorting[field]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">entity_id</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">sorting[field]</stringProp>
-            </elementProp>
-            <elementProp name="sorting[direction]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">asc</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">sorting[direction]</stringProp>
-            </elementProp>
-            <elementProp name="isAjax" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">true</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">isAjax</stringProp>
-            </elementProp>
-          </collectionProp>
+  </hashTree>
+  
+    <GenericController guiclass="LogicControllerGui" testclass="GenericController" testname="Simple Controller" enabled="true">
+  <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/simple_controller.jmx</stringProp>
+</GenericController>
+    <hashTree>
+    <TestFragmentController guiclass="TestFragmentControllerGui" testclass="TestFragmentController" testname="Admin CMS Management" enabled="true">
+  <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_cms_management/admin_cms_management.jmx</stringProp>
+</TestFragmentController>
+    <hashTree>
+      <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Landing Page" enabled="true">
+        <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
+          <collectionProp name="Arguments.arguments"/>
         </elementProp>
         <stringProp name="HTTPSampler.domain"/>
         <stringProp name="HTTPSampler.port"/>
@@ -23170,7 +10676,7 @@ if (testLabel
         <stringProp name="HTTPSampler.response_timeout"/>
         <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
         <stringProp name="HTTPSampler.contentEncoding"/>
-        <stringProp name="HTTPSampler.path">${base_path}${admin_path}/mui/index/render/</stringProp>
+        <stringProp name="HTTPSampler.path">${base_path}${admin_path}/cms/page/</stringProp>
         <stringProp name="HTTPSampler.method">GET</stringProp>
         <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
         <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
@@ -23179,1238 +10685,3998 @@ if (testLabel
         <boolProp name="HTTPSampler.monitor">false</boolProp>
         <stringProp name="HTTPSampler.embedded_url_re"/>
       </HTTPSamplerProxy>
-      <hashTree>
-        <HeaderManager guiclass="HeaderPanel" testclass="HeaderManager" testname="HTTP Header Manager" enabled="true">
-          <collectionProp name="HeaderManager.headers">
-            <elementProp name="" elementType="Header">
-              <stringProp name="Header.name">X-Requested-With</stringProp>
-              <stringProp name="Header.value">XMLHttpRequest</stringProp>
-            </elementProp>
-          </collectionProp>
-        </HeaderManager>
-        <hashTree/>
-      </hashTree>
-      <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Search Render" enabled="true">
+      <hashTree/>
+      <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Create New" enabled="true">
+        <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
+          <collectionProp name="Arguments.arguments"/>
+        </elementProp>
+        <stringProp name="HTTPSampler.domain"/>
+        <stringProp name="HTTPSampler.port"/>
+        <stringProp name="HTTPSampler.connect_timeout"/>
+        <stringProp name="HTTPSampler.response_timeout"/>
+        <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
+        <stringProp name="HTTPSampler.contentEncoding"/>
+        <stringProp name="HTTPSampler.path">${base_path}${admin_path}/cms/page/new</stringProp>
+        <stringProp name="HTTPSampler.method">GET</stringProp>
+        <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
+        <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
+        <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
+        <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
+        <boolProp name="HTTPSampler.monitor">false</boolProp>
+        <stringProp name="HTTPSampler.embedded_url_re"/>
+      </HTTPSamplerProxy>
+      <hashTree/>
+      <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Save" enabled="true">
         <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
           <collectionProp name="Arguments.arguments">
-            <elementProp name="namespace" elementType="HTTPArgument">
+            <elementProp name="content" elementType="HTTPArgument">
               <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">customer_listing</stringProp>
+              <stringProp name="Argument.value">&lt;p&gt;CMS Content ${__time(YMDHMS)}-${__threadNum}-${__Random(1,1000000)}&lt;/p&gt;</stringProp>
               <stringProp name="Argument.metadata">=</stringProp>
               <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">namespace</stringProp>
+              <stringProp name="Argument.name">content</stringProp>
             </elementProp>
-            <elementProp name="search" elementType="HTTPArgument">
+            <elementProp name="content_heading" elementType="HTTPArgument">
               <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">Lastname</stringProp>
+              <stringProp name="Argument.value"/>
               <stringProp name="Argument.metadata">=</stringProp>
               <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">search</stringProp>
+              <stringProp name="Argument.name">content_heading</stringProp>
             </elementProp>
-            <elementProp name="filters[placeholder]" elementType="HTTPArgument">
+            <elementProp name="form_key" elementType="HTTPArgument">
               <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">true</stringProp>
+              <stringProp name="Argument.value">${admin_form_key}</stringProp>
               <stringProp name="Argument.metadata">=</stringProp>
               <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">filters[placeholder]</stringProp>
+              <stringProp name="Argument.name">form_key</stringProp>
             </elementProp>
-            <elementProp name="paging[pageSize]" elementType="HTTPArgument">
+            <elementProp name="identifier" elementType="HTTPArgument">
               <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">20</stringProp>
+              <stringProp name="Argument.value"/>
               <stringProp name="Argument.metadata">=</stringProp>
               <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">paging[pageSize]</stringProp>
+              <stringProp name="Argument.name">identifier</stringProp>
             </elementProp>
-            <elementProp name="paging[current]" elementType="HTTPArgument">
+            <elementProp name="is_active" elementType="HTTPArgument">
               <boolProp name="HTTPArgument.always_encode">true</boolProp>
               <stringProp name="Argument.value">1</stringProp>
               <stringProp name="Argument.metadata">=</stringProp>
               <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">paging[current]</stringProp>
+              <stringProp name="Argument.name">is_active</stringProp>
             </elementProp>
-            <elementProp name="sorting[field]" elementType="HTTPArgument">
+            <elementProp name="layout_update_xml" elementType="HTTPArgument">
               <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">entity_id</stringProp>
+              <stringProp name="Argument.value"/>
               <stringProp name="Argument.metadata">=</stringProp>
               <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">sorting[field]</stringProp>
+              <stringProp name="Argument.name">layout_update_xml</stringProp>
             </elementProp>
-            <elementProp name="sorting[direction]" elementType="HTTPArgument">
+            <elementProp name="meta_description" elementType="HTTPArgument">
               <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">asc</stringProp>
+              <stringProp name="Argument.value"/>
               <stringProp name="Argument.metadata">=</stringProp>
               <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">sorting[direction]</stringProp>
+              <stringProp name="Argument.name">meta_description</stringProp>
             </elementProp>
-            <elementProp name="isAjax" elementType="HTTPArgument">
+            <elementProp name="meta_keywords" elementType="HTTPArgument">
               <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">true</stringProp>
+              <stringProp name="Argument.value"/>
               <stringProp name="Argument.metadata">=</stringProp>
               <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">isAjax</stringProp>
-            </elementProp>
-          </collectionProp>
-        </elementProp>
-        <stringProp name="HTTPSampler.domain"/>
-        <stringProp name="HTTPSampler.port"/>
-        <stringProp name="HTTPSampler.connect_timeout"/>
-        <stringProp name="HTTPSampler.response_timeout"/>
-        <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
-        <stringProp name="HTTPSampler.contentEncoding"/>
-        <stringProp name="HTTPSampler.path">${base_path}${admin_path}/mui/index/render/</stringProp>
-        <stringProp name="HTTPSampler.method">GET</stringProp>
-        <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
-        <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
-        <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
-        <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
-        <boolProp name="HTTPSampler.monitor">false</boolProp>
-        <stringProp name="HTTPSampler.embedded_url_re"/>
-      </HTTPSamplerProxy>
-      <hashTree>
-        <HeaderManager guiclass="HeaderPanel" testclass="HeaderManager" testname="HTTP Header Manager" enabled="true">
-          <collectionProp name="HeaderManager.headers">
-            <elementProp name="" elementType="Header">
-              <stringProp name="Header.name">X-Requested-With</stringProp>
-              <stringProp name="Header.value">XMLHttpRequest</stringProp>
+              <stringProp name="Argument.name">meta_keywords</stringProp>
+            </elementProp>
+            <elementProp name="meta_title" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value"/>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">meta_title</stringProp>
+            </elementProp>
+            <elementProp name="nodes_data" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">false</boolProp>
+              <stringProp name="Argument.value">{}</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">nodes_data</stringProp>
+            </elementProp>
+            <elementProp name="node_ids" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value"/>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">node_ids</stringProp>
+            </elementProp>
+            <elementProp name="page_id" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value"/>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">page_id</stringProp>
+            </elementProp>
+            <elementProp name="page_layout" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">1column</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">page_layout</stringProp>
+            </elementProp>
+            <elementProp name="store_id[0]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">0</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">store_id[0]</stringProp>
+            </elementProp>
+            <elementProp name="title" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">CMS Title ${__time(YMDHMS)}-${__threadNum}-${__Random(1,1000000)}</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">title</stringProp>
+            </elementProp>
+            <elementProp name="website_root" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">0</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">website_root</stringProp>
             </elementProp>
           </collectionProp>
-        </HeaderManager>
-        <hashTree/>
-        <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract customer edit url" enabled="true">
-          <stringProp name="RegexExtractor.useHeaders">false</stringProp>
-          <stringProp name="RegexExtractor.refname">customer_edit_url_path</stringProp>
-          <stringProp name="RegexExtractor.regex">actions":\{"edit":\{"href":"(?:http|https):\\/\\/(.*?)\\/customer\\/index\\/edit\\/id\\/(\d+)\\/",</stringProp>
-          <stringProp name="RegexExtractor.template">/customer/index/edit/id/$2$/</stringProp>
-          <stringProp name="RegexExtractor.default"/>
-          <stringProp name="RegexExtractor.match_number">0</stringProp>
-        </RegexExtractor>
-        <hashTree/>
-        <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert customer edit url" enabled="true">
-          <collectionProp name="Asserion.test_strings">
-            <stringProp name="2845929">^.+$</stringProp>
-          </collectionProp>
-          <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
-          <boolProp name="Assertion.assume_success">false</boolProp>
-          <intProp name="Assertion.test_type">1</intProp>
-          <stringProp name="Assertion.scope">variable</stringProp>
-          <stringProp name="Scope.variable">customer_edit_url_path</stringProp>
-        </ResponseAssertion>
-        <hashTree/>
-      </hashTree>
-      <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Edit Customer" enabled="true">
-        <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
-          <collectionProp name="Arguments.arguments"/>
-        </elementProp>
-        <stringProp name="HTTPSampler.domain"/>
-        <stringProp name="HTTPSampler.port"/>
-        <stringProp name="HTTPSampler.connect_timeout"/>
-        <stringProp name="HTTPSampler.response_timeout"/>
-        <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
-        <stringProp name="HTTPSampler.contentEncoding"/>
-        <stringProp name="HTTPSampler.path">${base_path}${admin_path}${customer_edit_url_path}</stringProp>
-        <stringProp name="HTTPSampler.method">GET</stringProp>
-        <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
-        <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
-        <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
-        <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
-        <boolProp name="HTTPSampler.monitor">false</boolProp>
-        <stringProp name="HTTPSampler.embedded_url_re"/>
-      </HTTPSamplerProxy>
-      <hashTree>
-        <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert edit customer page" enabled="true">
-          <collectionProp name="Asserion.test_strings">
-            <stringProp name="-1422614550">Customer Information</stringProp>
-          </collectionProp>
-          <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
-          <boolProp name="Assertion.assume_success">false</boolProp>
-          <intProp name="Assertion.test_type">2</intProp>
-        </ResponseAssertion>
-        <hashTree/>
-        <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract customer entity_id" enabled="true">
-          <stringProp name="RegexExtractor.useHeaders">false</stringProp>
-          <stringProp name="RegexExtractor.refname">admin_customer_entity_id</stringProp>
-          <stringProp name="RegexExtractor.regex">"entity_id":"(\d+)"</stringProp>
-          <stringProp name="RegexExtractor.template">$1$</stringProp>
-          <stringProp name="RegexExtractor.default"/>
-          <stringProp name="RegexExtractor.match_number">1</stringProp>
-        </RegexExtractor>
-        <hashTree/>
-        <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract website_id" enabled="true">
-          <stringProp name="RegexExtractor.useHeaders">false</stringProp>
-          <stringProp name="RegexExtractor.refname">admin_customer_website_id</stringProp>
-          <stringProp name="RegexExtractor.regex">"website_id":"(\d+)"</stringProp>
-          <stringProp name="RegexExtractor.template">$1$</stringProp>
-          <stringProp name="RegexExtractor.default"/>
-          <stringProp name="RegexExtractor.match_number">1</stringProp>
-        </RegexExtractor>
-        <hashTree/>
-        <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract customer firstname" enabled="true">
-          <stringProp name="RegexExtractor.useHeaders">false</stringProp>
-          <stringProp name="RegexExtractor.refname">admin_customer_firstname</stringProp>
-          <stringProp name="RegexExtractor.regex">"firstname":"([^"]+)"</stringProp>
-          <stringProp name="RegexExtractor.template">$1$</stringProp>
-          <stringProp name="RegexExtractor.default"/>
-          <stringProp name="RegexExtractor.match_number">1</stringProp>
-        </RegexExtractor>
-        <hashTree/>
-        <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract customer lastname" enabled="true">
-          <stringProp name="RegexExtractor.useHeaders">false</stringProp>
-          <stringProp name="RegexExtractor.refname">admin_customer_lastname</stringProp>
-          <stringProp name="RegexExtractor.regex">"lastname":"([^"]+)"</stringProp>
-          <stringProp name="RegexExtractor.template">$1$</stringProp>
-          <stringProp name="RegexExtractor.default"/>
-          <stringProp name="RegexExtractor.match_number">1</stringProp>
-        </RegexExtractor>
-        <hashTree/>
-        <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract customer email" enabled="true">
-          <stringProp name="RegexExtractor.useHeaders">false</stringProp>
-          <stringProp name="RegexExtractor.refname">admin_customer_email</stringProp>
-          <stringProp name="RegexExtractor.regex">"email":"([^\@]+@[^.]+.[^"]+)"</stringProp>
-          <stringProp name="RegexExtractor.template">$1$</stringProp>
-          <stringProp name="RegexExtractor.default"/>
-          <stringProp name="RegexExtractor.match_number">1</stringProp>
-        </RegexExtractor>
-        <hashTree/>
-        <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract group_id" enabled="true">
-          <stringProp name="RegexExtractor.useHeaders">false</stringProp>
-          <stringProp name="RegexExtractor.refname">admin_customer_group_id</stringProp>
-          <stringProp name="RegexExtractor.regex">"group_id":"(\d+)"</stringProp>
-          <stringProp name="RegexExtractor.template">$1$</stringProp>
-          <stringProp name="RegexExtractor.default"/>
-          <stringProp name="RegexExtractor.match_number">1</stringProp>
-        </RegexExtractor>
-        <hashTree/>
-        <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract store_id" enabled="true">
-          <stringProp name="RegexExtractor.useHeaders">false</stringProp>
-          <stringProp name="RegexExtractor.refname">admin_customer_store_id</stringProp>
-          <stringProp name="RegexExtractor.regex">"store_id":"(\d+)"</stringProp>
-          <stringProp name="RegexExtractor.template">$1$</stringProp>
-          <stringProp name="RegexExtractor.default"/>
-          <stringProp name="RegexExtractor.match_number">1</stringProp>
-        </RegexExtractor>
-        <hashTree/>
-        <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extact created_at" enabled="true">
-          <stringProp name="RegexExtractor.useHeaders">false</stringProp>
-          <stringProp name="RegexExtractor.refname">admin_customer_created_at</stringProp>
-          <stringProp name="RegexExtractor.regex">"created_at":"([^"]+)"</stringProp>
-          <stringProp name="RegexExtractor.template">$1$</stringProp>
-          <stringProp name="RegexExtractor.default"/>
-          <stringProp name="RegexExtractor.match_number">1</stringProp>
-        </RegexExtractor>
-        <hashTree/>
-        <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract updated_at" enabled="true">
-          <stringProp name="RegexExtractor.useHeaders">false</stringProp>
-          <stringProp name="RegexExtractor.refname">admin_customer_updated_at</stringProp>
-          <stringProp name="RegexExtractor.regex">"updated_at":"([^"]+)"</stringProp>
-          <stringProp name="RegexExtractor.template">$1$</stringProp>
-          <stringProp name="RegexExtractor.default"/>
-          <stringProp name="RegexExtractor.match_number">1</stringProp>
-        </RegexExtractor>
-        <hashTree/>
-        <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract is_active" enabled="true">
-          <stringProp name="RegexExtractor.useHeaders">false</stringProp>
-          <stringProp name="RegexExtractor.refname">admin_customer_is_active</stringProp>
-          <stringProp name="RegexExtractor.regex">"is_active":"(\d+)"</stringProp>
-          <stringProp name="RegexExtractor.template">$1$</stringProp>
-          <stringProp name="RegexExtractor.default"/>
-          <stringProp name="RegexExtractor.match_number">1</stringProp>
-        </RegexExtractor>
-        <hashTree/>
-        <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract disable_auto_group_change" enabled="true">
-          <stringProp name="RegexExtractor.useHeaders">false</stringProp>
-          <stringProp name="RegexExtractor.refname">admin_customer_disable_auto_group_change</stringProp>
-          <stringProp name="RegexExtractor.regex">"disable_auto_group_change":"(\d+)"</stringProp>
-          <stringProp name="RegexExtractor.template">$1$</stringProp>
-          <stringProp name="RegexExtractor.default"/>
-          <stringProp name="RegexExtractor.match_number">1</stringProp>
-        </RegexExtractor>
-        <hashTree/>
-        <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract created_in" enabled="true">
-          <stringProp name="RegexExtractor.useHeaders">false</stringProp>
-          <stringProp name="RegexExtractor.refname">admin_customer_created_in</stringProp>
-          <stringProp name="RegexExtractor.regex">"created_in":"([^"]+)"</stringProp>
-          <stringProp name="RegexExtractor.template">$1$</stringProp>
-          <stringProp name="RegexExtractor.default"/>
-          <stringProp name="RegexExtractor.match_number">1</stringProp>
-        </RegexExtractor>
-        <hashTree/>
-        <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract dob" enabled="true">
-          <stringProp name="RegexExtractor.useHeaders">false</stringProp>
-          <stringProp name="RegexExtractor.refname">admin_customer_dob</stringProp>
-          <stringProp name="RegexExtractor.regex">"dob":"(\d+)-(\d+)-(\d+)"</stringProp>
-          <stringProp name="RegexExtractor.template">$2$/$3$/$1$</stringProp>
-          <stringProp name="RegexExtractor.default"/>
-          <stringProp name="RegexExtractor.match_number">1</stringProp>
-        </RegexExtractor>
-        <hashTree/>
-        <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract default_billing" enabled="true">
-          <stringProp name="RegexExtractor.useHeaders">false</stringProp>
-          <stringProp name="RegexExtractor.refname">admin_customer_default_billing</stringProp>
-          <stringProp name="RegexExtractor.regex">"default_billing":"(\d+)"</stringProp>
-          <stringProp name="RegexExtractor.template">$1$</stringProp>
-          <stringProp name="RegexExtractor.default"/>
-          <stringProp name="RegexExtractor.match_number">1</stringProp>
-        </RegexExtractor>
-        <hashTree/>
-        <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract default_shipping" enabled="true">
-          <stringProp name="RegexExtractor.useHeaders">false</stringProp>
-          <stringProp name="RegexExtractor.refname">admin_customer_default_shipping</stringProp>
-          <stringProp name="RegexExtractor.regex">"default_shipping":"(\d+)"</stringProp>
-          <stringProp name="RegexExtractor.template">$1$</stringProp>
-          <stringProp name="RegexExtractor.default"/>
-          <stringProp name="RegexExtractor.match_number">1</stringProp>
-        </RegexExtractor>
-        <hashTree/>
-        <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract gender" enabled="true">
-          <stringProp name="RegexExtractor.useHeaders">false</stringProp>
-          <stringProp name="RegexExtractor.refname">admin_customer_gender</stringProp>
-          <stringProp name="RegexExtractor.regex">"gender":"(\d+)"</stringProp>
-          <stringProp name="RegexExtractor.template">$1$</stringProp>
-          <stringProp name="RegexExtractor.default"/>
-          <stringProp name="RegexExtractor.match_number">1</stringProp>
-        </RegexExtractor>
-        <hashTree/>
-        <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract failures_num" enabled="true">
-          <stringProp name="RegexExtractor.useHeaders">false</stringProp>
-          <stringProp name="RegexExtractor.refname">admin_customer_failures_num</stringProp>
-          <stringProp name="RegexExtractor.regex">"failures_num":"(\d+)"</stringProp>
-          <stringProp name="RegexExtractor.template">$1$</stringProp>
-          <stringProp name="RegexExtractor.default"/>
-          <stringProp name="RegexExtractor.match_number">1</stringProp>
-        </RegexExtractor>
-        <hashTree/>
-        <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract address_entity_id" enabled="true">
-          <stringProp name="RegexExtractor.useHeaders">false</stringProp>
-          <stringProp name="RegexExtractor.refname">admin_customer_address_entity_id</stringProp>
-          <stringProp name="RegexExtractor.regex">"address":\{"\d+":{"entity_id":"(\d+)".+?"parent_id":"${admin_customer_entity_id}"</stringProp>
-          <stringProp name="RegexExtractor.template">$1$</stringProp>
-          <stringProp name="RegexExtractor.default"/>
-          <stringProp name="RegexExtractor.match_number">1</stringProp>
-        </RegexExtractor>
-        <hashTree/>
-       <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract address_created_at" enabled="true">
-          <stringProp name="RegexExtractor.useHeaders">false</stringProp>
-          <stringProp name="RegexExtractor.refname">admin_customer_address_created_at</stringProp>
-          <stringProp name="RegexExtractor.regex">"address":\{"\d+":{.+?"parent_id":"${admin_customer_entity_id}".+?"created_at":"([^"]+)"</stringProp>
-          <stringProp name="RegexExtractor.template">$1$</stringProp>
-          <stringProp name="RegexExtractor.default"/>
-          <stringProp name="RegexExtractor.match_number">1</stringProp>
-        </RegexExtractor>
-        <hashTree/>
-        <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract address_updated_at" enabled="true">
-          <stringProp name="RegexExtractor.useHeaders">false</stringProp>
-          <stringProp name="RegexExtractor.refname">admin_customer_address_updated_at</stringProp>
-          <stringProp name="RegexExtractor.regex">"address":\{"\d+":{.+?"parent_id":"${admin_customer_entity_id}".+?"updated_at":"([^"]+)"</stringProp>
-          <stringProp name="RegexExtractor.template">$1$</stringProp>
-          <stringProp name="RegexExtractor.default"/>
-          <stringProp name="RegexExtractor.match_number">1</stringProp>
-        </RegexExtractor>
-        <hashTree/>
-        <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract address_is_active" enabled="true">
-          <stringProp name="RegexExtractor.useHeaders">false</stringProp>
-          <stringProp name="RegexExtractor.refname">admin_customer_address_is_active</stringProp>
-          <stringProp name="RegexExtractor.regex">"address":\{"\d+":{.+?"parent_id":"${admin_customer_entity_id}".+?"is_active":"(\d+)"</stringProp>
-          <stringProp name="RegexExtractor.template">$1$</stringProp>
-          <stringProp name="RegexExtractor.default"/>
-          <stringProp name="RegexExtractor.match_number">1</stringProp>
-        </RegexExtractor>
-        <hashTree/>
-        <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract address_city" enabled="true">
-          <stringProp name="RegexExtractor.useHeaders">false</stringProp>
-          <stringProp name="RegexExtractor.refname">admin_customer_address_city</stringProp>
-          <stringProp name="RegexExtractor.regex">"address":\{"\d+":{.+?"parent_id":"${admin_customer_entity_id}".+?"city":"([^"]+)"</stringProp>
-          <stringProp name="RegexExtractor.template">$1$</stringProp>
-          <stringProp name="RegexExtractor.default"/>
-          <stringProp name="RegexExtractor.match_number">1</stringProp>
-        </RegexExtractor>
-        <hashTree/>
-        <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract address_country_id" enabled="true">
-          <stringProp name="RegexExtractor.useHeaders">false</stringProp>
-          <stringProp name="RegexExtractor.refname">admin_customer_address_country_id</stringProp>
-          <stringProp name="RegexExtractor.regex">"address":\{"\d+":{.+?"parent_id":"${admin_customer_entity_id}".+?"country_id":"([^"]+)"</stringProp>
-          <stringProp name="RegexExtractor.template">$1$</stringProp>
-          <stringProp name="RegexExtractor.default"/>
-          <stringProp name="RegexExtractor.match_number">1</stringProp>
-        </RegexExtractor>
-        <hashTree/>
-        <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract address_firstname" enabled="true">
-          <stringProp name="RegexExtractor.useHeaders">false</stringProp>
-          <stringProp name="RegexExtractor.refname">admin_customer_address_firstname</stringProp>
-          <stringProp name="RegexExtractor.regex">"address":\{"\d+":{.+?"parent_id":"${admin_customer_entity_id}".+?"firstname":"([^"]+)"</stringProp>
-          <stringProp name="RegexExtractor.template">$1$</stringProp>
-          <stringProp name="RegexExtractor.default"/>
-          <stringProp name="RegexExtractor.match_number">1</stringProp>
-        </RegexExtractor>
-        <hashTree/>
-        <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract address_lastname" enabled="true">
-          <stringProp name="RegexExtractor.useHeaders">false</stringProp>
-          <stringProp name="RegexExtractor.refname">admin_customer_address_lastname</stringProp>
-          <stringProp name="RegexExtractor.regex">"address":\{"\d+":{.+?"parent_id":"${admin_customer_entity_id}".+?"lastname":"([^"]+)"</stringProp>
-          <stringProp name="RegexExtractor.template">$1$</stringProp>
-          <stringProp name="RegexExtractor.default"/>
-          <stringProp name="RegexExtractor.match_number">1</stringProp>
-        </RegexExtractor>
-        <hashTree/>
-        <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract address_postcode" enabled="true">
-          <stringProp name="RegexExtractor.useHeaders">false</stringProp>
-          <stringProp name="RegexExtractor.refname">admin_customer_address_postcode</stringProp>
-          <stringProp name="RegexExtractor.regex">"address":\{"\d+":{.+?"parent_id":"${admin_customer_entity_id}".+?"postcode":"([^"]+)"</stringProp>
-          <stringProp name="RegexExtractor.template">$1$</stringProp>
-          <stringProp name="RegexExtractor.default"/>
-          <stringProp name="RegexExtractor.match_number">1</stringProp>
-        </RegexExtractor>
-        <hashTree/>
-        <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract address_region" enabled="true">
-          <stringProp name="RegexExtractor.useHeaders">false</stringProp>
-          <stringProp name="RegexExtractor.refname">admin_customer_address_region</stringProp>
-          <stringProp name="RegexExtractor.regex">"address":\{"\d+":{.+?"parent_id":"${admin_customer_entity_id}".+?"region":"([^"]+)"</stringProp>
-          <stringProp name="RegexExtractor.template">$1$</stringProp>
-          <stringProp name="RegexExtractor.default"/>
-          <stringProp name="RegexExtractor.match_number">1</stringProp>
-        </RegexExtractor>
-        <hashTree/>
-        <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract address_region_id" enabled="true">
-          <stringProp name="RegexExtractor.useHeaders">false</stringProp>
-          <stringProp name="RegexExtractor.refname">admin_customer_address_region_id</stringProp>
-          <stringProp name="RegexExtractor.regex">"address":\{"\d+":{.+?"parent_id":"${admin_customer_entity_id}".+?"region_id":"([^"]+)"</stringProp>
-          <stringProp name="RegexExtractor.template">$1$</stringProp>
-          <stringProp name="RegexExtractor.default"/>
-          <stringProp name="RegexExtractor.match_number">1</stringProp>
-        </RegexExtractor>
-        <hashTree/>
-        <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract address street" enabled="true">
-          <stringProp name="RegexExtractor.useHeaders">false</stringProp>
-          <stringProp name="RegexExtractor.refname">admin_customer_address_street</stringProp>
-          <stringProp name="RegexExtractor.regex">"address":\{"\d+":{.+?"parent_id":"${admin_customer_entity_id}".+?"street":\["([^"]+)"\]</stringProp>
-          <stringProp name="RegexExtractor.template">$1$</stringProp>
-          <stringProp name="RegexExtractor.default"/>
-          <stringProp name="RegexExtractor.match_number">1</stringProp>
-        </RegexExtractor>
-        <hashTree/>
-        <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract address_telephone" enabled="true">
-          <stringProp name="RegexExtractor.useHeaders">false</stringProp>
-          <stringProp name="RegexExtractor.refname">admin_customer_address_telephone</stringProp>
-          <stringProp name="RegexExtractor.regex">"address":\{"\d+":{.+?"parent_id":"${admin_customer_entity_id}".+?"telephone":"([^"]+)"</stringProp>
-          <stringProp name="RegexExtractor.template">$1$</stringProp>
-          <stringProp name="RegexExtractor.default"/>
-          <stringProp name="RegexExtractor.match_number">1</stringProp>
-        </RegexExtractor>
-        <hashTree/>
-        <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract address_customer_id" enabled="true">
-          <stringProp name="RegexExtractor.useHeaders">false</stringProp>
-          <stringProp name="RegexExtractor.refname">admin_customer_address_customer_id</stringProp>
-          <stringProp name="RegexExtractor.regex">"address":\{"\d+":{.+?"parent_id":"${admin_customer_entity_id}".+?"customer_id":"([^"]+)"</stringProp>
-          <stringProp name="RegexExtractor.template">$1$</stringProp>
-          <stringProp name="RegexExtractor.default"/>
-          <stringProp name="RegexExtractor.match_number">1</stringProp>
-        </RegexExtractor>
-        <hashTree/>
-        <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert customer entity_id" enabled="true">
-          <collectionProp name="Asserion.test_strings">
-            <stringProp name="89649215">^\d+$</stringProp>
-          </collectionProp>
-          <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
-          <boolProp name="Assertion.assume_success">false</boolProp>
-          <intProp name="Assertion.test_type">1</intProp>
-          <stringProp name="Assertion.scope">variable</stringProp>
-          <stringProp name="Scope.variable">admin_customer_entity_id</stringProp>
-        </ResponseAssertion>
-        <hashTree/>
-        <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert website_id" enabled="true">
-          <collectionProp name="Asserion.test_strings">
-            <stringProp name="89649215">^\d+$</stringProp>
-          </collectionProp>
-          <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
-          <boolProp name="Assertion.assume_success">false</boolProp>
-          <intProp name="Assertion.test_type">1</intProp>
-          <stringProp name="Assertion.scope">variable</stringProp>
-          <stringProp name="Scope.variable">admin_customer_website_id</stringProp>
-        </ResponseAssertion>
-        <hashTree/>
-        <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert customer firstname" enabled="true">
-          <collectionProp name="Asserion.test_strings">
-            <stringProp name="2845929">^.+$</stringProp>
-          </collectionProp>
-          <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
-          <boolProp name="Assertion.assume_success">false</boolProp>
-          <intProp name="Assertion.test_type">1</intProp>
-          <stringProp name="Assertion.scope">variable</stringProp>
-          <stringProp name="Scope.variable">admin_customer_firstname</stringProp>
-        </ResponseAssertion>
-        <hashTree/>
-        <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert customer lastname" enabled="true">
-          <collectionProp name="Asserion.test_strings">
-            <stringProp name="2845929">^.+$</stringProp>
-          </collectionProp>
-          <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
-          <boolProp name="Assertion.assume_success">false</boolProp>
-          <intProp name="Assertion.test_type">1</intProp>
-          <stringProp name="Assertion.scope">variable</stringProp>
-          <stringProp name="Scope.variable">admin_customer_lastname</stringProp>
-        </ResponseAssertion>
-        <hashTree/>
-        <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert customer email" enabled="true">
-          <collectionProp name="Asserion.test_strings">
-            <stringProp name="2845929">^.+$</stringProp>
-          </collectionProp>
-          <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
-          <boolProp name="Assertion.assume_success">false</boolProp>
-          <intProp name="Assertion.test_type">1</intProp>
-          <stringProp name="Assertion.scope">variable</stringProp>
-          <stringProp name="Scope.variable">admin_customer_email</stringProp>
-        </ResponseAssertion>
-        <hashTree/>
-        <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert customer group_id" enabled="true">
-          <collectionProp name="Asserion.test_strings">
-            <stringProp name="89649215">^\d+$</stringProp>
-          </collectionProp>
-          <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
-          <boolProp name="Assertion.assume_success">false</boolProp>
-          <intProp name="Assertion.test_type">1</intProp>
-          <stringProp name="Assertion.scope">variable</stringProp>
-          <stringProp name="Scope.variable">admin_customer_group_id</stringProp>
-        </ResponseAssertion>
-        <hashTree/>
-        <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert customer store_id" enabled="true">
+        </elementProp>
+        <stringProp name="HTTPSampler.domain"/>
+        <stringProp name="HTTPSampler.port"/>
+        <stringProp name="HTTPSampler.connect_timeout"/>
+        <stringProp name="HTTPSampler.response_timeout"/>
+        <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
+        <stringProp name="HTTPSampler.contentEncoding"/>
+        <stringProp name="HTTPSampler.path">${base_path}${admin_path}/cms/page/save/</stringProp>
+        <stringProp name="HTTPSampler.method">POST</stringProp>
+        <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
+        <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
+        <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
+        <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
+        <boolProp name="HTTPSampler.monitor">false</boolProp>
+        <stringProp name="HTTPSampler.embedded_url_re"/>
+      </HTTPSamplerProxy>
+      <hashTree>
+        <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Response Assertion" enabled="true">
           <collectionProp name="Asserion.test_strings">
-            <stringProp name="89649215">^\d+$</stringProp>
+            <stringProp name="-398886250">You saved the page.</stringProp>
           </collectionProp>
           <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
           <boolProp name="Assertion.assume_success">false</boolProp>
-          <intProp name="Assertion.test_type">1</intProp>
-          <stringProp name="Assertion.scope">variable</stringProp>
-          <stringProp name="Scope.variable">admin_customer_store_id</stringProp>
+          <intProp name="Assertion.test_type">16</intProp>
         </ResponseAssertion>
         <hashTree/>
-        <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert customer created_at" enabled="true">
-          <collectionProp name="Asserion.test_strings">
-            <stringProp name="2845929">^.+$</stringProp>
-          </collectionProp>
-          <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
-          <boolProp name="Assertion.assume_success">false</boolProp>
-          <intProp name="Assertion.test_type">1</intProp>
-          <stringProp name="Assertion.scope">variable</stringProp>
-          <stringProp name="Scope.variable">admin_customer_created_at</stringProp>
-        </ResponseAssertion>
+      </hashTree>
+      <TestAction guiclass="TestActionGui" testclass="TestAction" testname="Pause" enabled="true">
+        <intProp name="ActionProcessor.action">1</intProp>
+        <intProp name="ActionProcessor.target">0</intProp>
+        <stringProp name="ActionProcessor.duration">${__javaScript(Math.round(${adminCMSManagementDelay}*1000))}</stringProp>
+      </TestAction>
+      <hashTree/>
+    </hashTree>
+  </hashTree>
+  
+    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Logout" enabled="true">
+      <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
+        <collectionProp name="Arguments.arguments"/>
+      </elementProp>
+      <stringProp name="HTTPSampler.domain"/>
+      <stringProp name="HTTPSampler.port"/>
+      <stringProp name="HTTPSampler.connect_timeout"/>
+      <stringProp name="HTTPSampler.response_timeout"/>
+      <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
+      <stringProp name="HTTPSampler.contentEncoding"/>
+      <stringProp name="HTTPSampler.path">${base_path}${admin_path}/admin/auth/logout/</stringProp>
+      <stringProp name="HTTPSampler.method">GET</stringProp>
+      <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
+      <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
+      <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
+      <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
+      <boolProp name="HTTPSampler.monitor">false</boolProp>
+      <stringProp name="HTTPSampler.embedded_url_re"/>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/setup/admin_logout.jmx</stringProp></HTTPSamplerProxy>
+    <hashTree>
+    
+    <BeanShellPostProcessor guiclass="TestBeanGUI" testclass="BeanShellPostProcessor" testname="Return Admin to Pool" enabled="true">
+        <boolProp name="resetInterpreter">false</boolProp>
+        <stringProp name="parameters"/>
+        <stringProp name="filename"/>
+        <stringProp name="script">
+adminUserList = props.get("adminUserList");
+adminUserList.add(vars.get("admin_user"));
+        </stringProp>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/common/return_admin_email_to_pool.jmx</stringProp></BeanShellPostProcessor>
+    <hashTree/>
+  </hashTree>
+  </hashTree>
+
+  
+    <ThroughputController guiclass="ThroughputControllerGui" testclass="ThroughputController" testname="Browse Product Grid" enabled="true">
+      <intProp name="ThroughputController.style">1</intProp>
+      <boolProp name="ThroughputController.perThread">false</boolProp>
+      <intProp name="ThroughputController.maxThroughput">1</intProp>
+      <stringProp name="ThroughputController.percentThroughput">${browseProductGridPercentage}</stringProp>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/_system/scenario_controller_tmpl.jmx</stringProp></ThroughputController>
+    <hashTree>
+        <JSR223PreProcessor guiclass="TestBeanGUI" testclass="JSR223PreProcessor" testname="Set Test Label" enabled="true">
+            <stringProp name="script">
+var testLabel = "${testLabel}" ? " (${testLabel})" : "";
+if (testLabel
+    &amp;&amp; sampler.getClass().getName() == 'org.apache.jmeter.protocol.http.sampler.HTTPSamplerProxy'
+) {
+    if (sampler.getName().indexOf(testLabel) == -1) {
+       sampler.setName(sampler.getName() + testLabel);
+    }
+} else if (sampler.getName().indexOf("SetUp - ") == -1) {
+    sampler.setName("SetUp - " + sampler.getName());
+}
+            </stringProp>
+            <stringProp name="scriptLanguage">javascript</stringProp>
+        <stringProp name="TestPlan.comments">mpaf/tool/fragments/_system/setup_label.jmx</stringProp></JSR223PreProcessor>
         <hashTree/>
-        <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert customer updated_at" enabled="true">
-          <collectionProp name="Asserion.test_strings">
-            <stringProp name="2845929">^.+$</stringProp>
-          </collectionProp>
-          <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
-          <boolProp name="Assertion.assume_success">false</boolProp>
-          <intProp name="Assertion.test_type">1</intProp>
-          <stringProp name="Assertion.scope">variable</stringProp>
-          <stringProp name="Scope.variable">admin_customer_updated_at</stringProp>
-        </ResponseAssertion>
+        <BeanShellSampler guiclass="BeanShellSamplerGui" testclass="BeanShellSampler" testname="SetUp - Set Label" enabled="true">
+            <stringProp name="BeanShellSampler.query">
+                vars.put("testLabel", "Browse Product Grid");
+            </stringProp>
+            <boolProp name="BeanShellSampler.resetInterpreter">true</boolProp>
+        </BeanShellSampler>
         <hashTree/>
-        <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert customer is_active" enabled="true">
-          <collectionProp name="Asserion.test_strings">
-            <stringProp name="89649215">^\d+$</stringProp>
-          </collectionProp>
-          <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
-          <boolProp name="Assertion.assume_success">false</boolProp>
-          <intProp name="Assertion.test_type">1</intProp>
-          <stringProp name="Assertion.scope">variable</stringProp>
-          <stringProp name="Scope.variable">admin_customer_is_active</stringProp>
-        </ResponseAssertion>
+    
+        <JSR223PostProcessor guiclass="TestBeanGUI" testclass="JSR223PostProcessor" testname="Get admin form key PostProcessor" enabled="true">
+        <stringProp name="script">
+        function getFormKeyFromResponse()
+        {
+            var url = prev.getUrlAsString(),
+            responseCode =  prev.getResponseCode(),
+            formKey = null;
+            searchPattern = /var FORM_KEY = '(.+)'/;
+            if (responseCode == "200" &amp;&amp; url) {
+                response = prev.getResponseDataAsString();
+                formKey = response  &amp;&amp; response.match(searchPattern) ? response.match(searchPattern)[1] : null;
+            }
+            return formKey;
+        }
+
+        formKey = vars.get("form_key_storage");
+
+	   currentFormKey = getFormKeyFromResponse();
+
+	   if (currentFormKey != null &amp;&amp; currentFormKey != formKey) {
+		  vars.put("form_key_storage", currentFormKey);
+	   }
+        </stringProp>
+        <stringProp name="scriptLanguage">javascript</stringProp>
+        <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin/handle_admin_form_key.jmx</stringProp></JSR223PostProcessor>
         <hashTree/>
-        <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert customer disable_auto_group_change" enabled="true">
-          <collectionProp name="Asserion.test_strings">
-            <stringProp name="89649215">^\d+$</stringProp>
-          </collectionProp>
-          <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
-          <boolProp name="Assertion.assume_success">false</boolProp>
-          <intProp name="Assertion.test_type">1</intProp>
-          <stringProp name="Assertion.scope">variable</stringProp>
-          <stringProp name="Scope.variable">admin_customer_disable_auto_group_change</stringProp>
-        </ResponseAssertion>
+        <JSR223PreProcessor guiclass="TestBeanGUI" testclass="JSR223PreProcessor" testname="Set admin form key PreProcessor" enabled="true">
+            <stringProp name="script">
+                formKey =  vars.get("form_key_storage");
+                if (formKey
+                    &amp;&amp; sampler.getClass().getName() == 'org.apache.jmeter.protocol.http.sampler.HTTPSamplerProxy'
+                    &amp;&amp; sampler.getMethod() == "POST")
+                    {
+                        arguments = sampler.getArguments();
+                        for (i=0; i&lt;arguments.getArgumentCount(); i++)
+                        {
+                            argument = arguments.getArgument(i);
+                            if (argument.getName() == 'form_key' &amp;&amp; argument.getValue() != formKey) {
+                            log.info("admin form key updated: " + argument.getValue() + " =&gt; " + formKey);
+                            argument.setValue(formKey);
+                        }
+                    }
+                }
+            </stringProp>
+            <stringProp name="scriptLanguage">javascript</stringProp>
+        </JSR223PreProcessor>
         <hashTree/>
-        <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert customer created_in" enabled="true">
-          <collectionProp name="Asserion.test_strings">
-            <stringProp name="2845929">^.+$</stringProp>
-          </collectionProp>
-          <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
-          <boolProp name="Assertion.assume_success">false</boolProp>
-          <intProp name="Assertion.test_type">1</intProp>
-          <stringProp name="Assertion.scope">variable</stringProp>
-          <stringProp name="Scope.variable">admin_customer_created_in</stringProp>
-        </ResponseAssertion>
+    
+    <CookieManager guiclass="CookiePanel" testclass="CookieManager" testname="HTTP Cookie Manager" enabled="true">
+      <collectionProp name="CookieManager.cookies"/>
+      <boolProp name="CookieManager.clearEachIteration">false</boolProp>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/http_cookie_manager_without_clear_each_iteration.jmx</stringProp></CookieManager>
+    <hashTree/>
+  
+    <GenericController guiclass="LogicControllerGui" testclass="GenericController" testname="Admin Login" enabled="true">
+  <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/simple_controller.jmx</stringProp>
+</GenericController>
+    <hashTree>
+    <CriticalSectionController guiclass="CriticalSectionControllerGui" testclass="CriticalSectionController" testname="Admin Login Lock" enabled="true">
+        <stringProp name="CriticalSectionController.lockName">get-admin-email</stringProp>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/lock_controller.jmx</stringProp></CriticalSectionController>
+    <hashTree>
+    
+    <BeanShellSampler guiclass="BeanShellSamplerGui" testclass="BeanShellSampler" testname="SetUp - Get Admin Email" enabled="true">
+      <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/get_admin_email.jmx</stringProp>
+      <stringProp name="BeanShellSampler.query">
+adminUserList = props.get("adminUserList");
+adminUser = adminUserList.poll();
+if (adminUser == null) {
+  SampleResult.setResponseMessage("adminUser list is empty");
+  SampleResult.setResponseData("adminUser list is empty","UTF-8");
+  IsSuccess=false;
+  SampleResult.setSuccessful(false);
+  SampleResult.setStopThread(true);
+}
+vars.put("admin_user", adminUser);
+      </stringProp>
+      <stringProp name="BeanShellSampler.filename"/>
+      <stringProp name="BeanShellSampler.parameters"/>
+      <boolProp name="BeanShellSampler.resetInterpreter">true</boolProp>
+    </BeanShellSampler>
+    <hashTree/>
+  </hashTree>
+  
+    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="SetUp - Login" enabled="true">
+      <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
+        <collectionProp name="Arguments.arguments"/>
+      </elementProp>
+      <stringProp name="HTTPSampler.domain"/>
+      <stringProp name="HTTPSampler.port"/>
+      <stringProp name="HTTPSampler.connect_timeout"/>
+      <stringProp name="HTTPSampler.response_timeout"/>
+      <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
+      <stringProp name="HTTPSampler.contentEncoding"/>
+      <stringProp name="HTTPSampler.path">${base_path}${admin_path}</stringProp>
+      <stringProp name="HTTPSampler.method">GET</stringProp>
+      <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
+      <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
+      <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
+      <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
+      <boolProp name="HTTPSampler.monitor">false</boolProp>
+      <stringProp name="HTTPSampler.embedded_url_re"/>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_login/admin_login.jmx</stringProp></HTTPSamplerProxy>
+    <hashTree>
+      <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert login form shown" enabled="true">
+        <collectionProp name="Asserion.test_strings">
+          <stringProp name="-1397214398">Welcome</stringProp>
+          <stringProp name="-515240035">&lt;title&gt;Magento Admin&lt;/title&gt;</stringProp>
+        </collectionProp>
+        <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
+        <boolProp name="Assertion.assume_success">false</boolProp>
+        <intProp name="Assertion.test_type">2</intProp>
+      </ResponseAssertion>
+      <hashTree/>
+      <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract form key" enabled="true">
+        <stringProp name="RegexExtractor.useHeaders">false</stringProp>
+        <stringProp name="RegexExtractor.refname">admin_form_key</stringProp>
+        <stringProp name="RegexExtractor.regex">&lt;input name="form_key" type="hidden" value="([^'"]+)" /&gt;</stringProp>
+        <stringProp name="RegexExtractor.template">$1$</stringProp>
+        <stringProp name="RegexExtractor.default"/>
+        <stringProp name="RegexExtractor.match_number">1</stringProp>
+      </RegexExtractor>
+      <hashTree/>
+      <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert form_key extracted" enabled="true">
+        <collectionProp name="Asserion.test_strings">
+          <stringProp name="2845929">^.+$</stringProp>
+        </collectionProp>
+        <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
+        <boolProp name="Assertion.assume_success">false</boolProp>
+        <intProp name="Assertion.test_type">1</intProp>
+        <stringProp name="Assertion.scope">variable</stringProp>
+        <stringProp name="Scope.variable">admin_form_key</stringProp>
+      </ResponseAssertion>
+      <hashTree/>
+    </hashTree>
+  
+    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="SetUp - Login Submit Form" enabled="true">
+      <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
+        <collectionProp name="Arguments.arguments">
+          <elementProp name="dummy" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value"/>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">dummy</stringProp>
+          </elementProp>
+          <elementProp name="form_key" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">${admin_form_key}</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">form_key</stringProp>
+          </elementProp>
+          <elementProp name="login[password]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">${admin_password}</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">login[password]</stringProp>
+          </elementProp>
+          <elementProp name="login[username]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">${admin_user}</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">login[username]</stringProp>
+          </elementProp>
+        </collectionProp>
+      </elementProp>
+      <stringProp name="HTTPSampler.domain"/>
+      <stringProp name="HTTPSampler.port"/>
+      <stringProp name="HTTPSampler.connect_timeout"/>
+      <stringProp name="HTTPSampler.response_timeout"/>
+      <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
+      <stringProp name="HTTPSampler.contentEncoding"/>
+      <stringProp name="HTTPSampler.path">${base_path}${admin_path}/admin/dashboard/</stringProp>
+      <stringProp name="HTTPSampler.method">POST</stringProp>
+      <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
+      <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
+      <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
+      <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
+      <stringProp name="HTTPSampler.implementation">Java</stringProp>
+      <boolProp name="HTTPSampler.monitor">false</boolProp>
+      <stringProp name="HTTPSampler.embedded_url_re"/>
+      <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_login/admin_login_submit_form.jmx</stringProp>
+    </HTTPSamplerProxy>
+    <hashTree>
+        <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract form key" enabled="true">
+            <stringProp name="RegexExtractor.useHeaders">false</stringProp>
+            <stringProp name="RegexExtractor.refname">admin_form_key</stringProp>
+            <stringProp name="RegexExtractor.regex">&lt;input name="form_key" type="hidden" value="([^'"]+)" /&gt;</stringProp>
+            <stringProp name="RegexExtractor.template">$1$</stringProp>
+            <stringProp name="RegexExtractor.default"/>
+            <stringProp name="RegexExtractor.match_number">1</stringProp>
+        <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_login/admin_retrieve_form_key.jmx</stringProp></RegexExtractor>
         <hashTree/>
-        <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert customer dob" enabled="true">
-          <collectionProp name="Asserion.test_strings">
-            <stringProp name="221072919">^\d+/\d+/\d+$</stringProp>
-          </collectionProp>
-          <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
-          <boolProp name="Assertion.assume_success">false</boolProp>
-          <intProp name="Assertion.test_type">1</intProp>
-          <stringProp name="Assertion.scope">variable</stringProp>
-          <stringProp name="Scope.variable">admin_customer_dob</stringProp>
-        </ResponseAssertion>
+    </hashTree>
+  </hashTree>
+  
+    <JSR223PostProcessor guiclass="TestBeanGUI" testclass="JSR223PreProcessor" testname="SetUp - Set Arguments" enabled="true">
+      <stringProp name="script">
+        vars.put("gridEntityType" , "Product");
+
+        pagesCount = parseInt(vars.get("products_page_size")) || 20;
+        vars.put("grid_entity_page_size" , pagesCount);
+        vars.put("grid_namespace" , "product_listing");
+        vars.put("grid_admin_browse_filter_text" , vars.get("admin_browse_product_filter_text"));
+        vars.put("grid_filter_field", "name");
+
+        // set sort fields and sort directions
+        vars.put("grid_sort_field_1", "name");
+        vars.put("grid_sort_field_2", "price");
+        vars.put("grid_sort_field_3", "attribute_set_id");
+        vars.put("grid_sort_order_1", "asc");
+        vars.put("grid_sort_order_2", "desc");
+      </stringProp>
+      <stringProp name="scriptLanguage">javascript</stringProp>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_browse_products_grid/setup.jmx</stringProp></JSR223PostProcessor>
+    <hashTree/>
+  
+    <GenericController guiclass="LogicControllerGui" testclass="GenericController" testname="Simple Controller" enabled="true">
+  <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/simple_controller.jmx</stringProp>
+</GenericController>
+    <hashTree>
+    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="SetUp - Set ${gridEntityType} Pages Count" enabled="true">
+      <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
+        <collectionProp name="Arguments.arguments">
+          <elementProp name="namespace" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">${grid_namespace}</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">namespace</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
+          </elementProp>
+          <elementProp name="search" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value"/>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">search</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
+          </elementProp>
+          <elementProp name="filters[placeholder]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">true</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">filters[placeholder]</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
+          </elementProp>
+          <elementProp name="paging[pageSize]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">${grid_entity_page_size}</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">paging[pageSize]</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
+          </elementProp>
+          <elementProp name="paging[current]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">1</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">paging[current]</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
+          </elementProp>
+          <elementProp name="sorting[field]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">entity_id</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">sorting[field]</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
+          </elementProp>
+          <elementProp name="sorting[direction]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">asc</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">sorting[direction]</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
+          </elementProp>
+          <elementProp name="isAjax" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">true</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">isAjax</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
+          </elementProp>
+        </collectionProp>
+      </elementProp>
+      <stringProp name="HTTPSampler.domain"/>
+      <stringProp name="HTTPSampler.port"/>
+      <stringProp name="HTTPSampler.connect_timeout"/>
+      <stringProp name="HTTPSampler.response_timeout"/>
+      <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
+      <stringProp name="HTTPSampler.contentEncoding"/>
+      <stringProp name="HTTPSampler.path">${base_path}${admin_path}/mui/index/render/</stringProp>
+      <stringProp name="HTTPSampler.method">GET</stringProp>
+      <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
+      <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
+      <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
+      <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
+      <boolProp name="HTTPSampler.monitor">false</boolProp>
+      <stringProp name="HTTPSampler.embedded_url_re"/>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_grid_browsing/set_pages_count.jmx</stringProp></HTTPSamplerProxy>
+    <hashTree>
+      <com.atlantbh.jmeter.plugins.jsonutils.jsonpathassertion.JSONPathAssertion guiclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathassertion.gui.JSONPathAssertionGui" testclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathassertion.JSONPathAssertion" testname="Assert total records is not 0" enabled="true">
+        <stringProp name="JSON_PATH">$.totalRecords</stringProp>
+        <stringProp name="EXPECTED_VALUE">0</stringProp>
+        <boolProp name="JSONVALIDATION">true</boolProp>
+        <boolProp name="EXPECT_NULL">false</boolProp>
+        <boolProp name="INVERT">true</boolProp>
+      </com.atlantbh.jmeter.plugins.jsonutils.jsonpathassertion.JSONPathAssertion>
+      <hashTree/>
+      <com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor guiclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.gui.JSONPathExtractorGui" testclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor" testname="Extract total records" enabled="true">
+        <stringProp name="VAR">entity_total_records</stringProp>
+        <stringProp name="JSONPATH">$.totalRecords</stringProp>
+        <stringProp name="DEFAULT"/>
+        <stringProp name="VARIABLE"/>
+        <stringProp name="SUBJECT">BODY</stringProp>
+      </com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor>
+      <hashTree/>
+      <JSR223PostProcessor guiclass="TestBeanGUI" testclass="JSR223PreProcessor" testname="SetUp - Calculate ${gridEntityType} pages count" enabled="true">
+        <stringProp name="cacheKey"/>
+        <stringProp name="filename"/>
+        <stringProp name="parameters"/>
+        <stringProp name="script">
+          var pageSize = parseInt(vars.get("grid_entity_page_size")) || 20;
+          var totalsRecord = parseInt(vars.get("entity_total_records"));
+          var pageCount = Math.round(totalsRecord/pageSize);
+
+          vars.put("grid_pages_count", pageCount);
+        </stringProp>
+        <stringProp name="scriptLanguage">javascript</stringProp>
+      </JSR223PostProcessor>
+      <hashTree/>
+    </hashTree>
+  
+    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="SetUp - Set ${gridEntityType} Filtered Pages Count" enabled="true">
+      <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
+        <collectionProp name="Arguments.arguments">
+          <elementProp name="namespace" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">${grid_namespace}</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">namespace</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
+          </elementProp>
+          <elementProp name="search" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value"/>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">search</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
+          </elementProp>
+          <elementProp name="filters[placeholder]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">${grid_admin_browse_filter_text}</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">filters[placeholder]</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
+          </elementProp>
+          <elementProp name="paging[pageSize]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">${grid_entity_page_size}</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">paging[pageSize]</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
+          </elementProp>
+          <elementProp name="paging[current]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">1</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">paging[current]</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
+          </elementProp>
+          <elementProp name="sorting[field]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">entity_id</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">sorting[field]</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
+          </elementProp>
+          <elementProp name="sorting[direction]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">asc</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">sorting[direction]</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
+          </elementProp>
+          <elementProp name="isAjax" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">true</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">isAjax</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
+          </elementProp>
+        </collectionProp>
+      </elementProp>
+      <stringProp name="HTTPSampler.domain"/>
+      <stringProp name="HTTPSampler.port"/>
+      <stringProp name="HTTPSampler.connect_timeout"/>
+      <stringProp name="HTTPSampler.response_timeout"/>
+      <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
+      <stringProp name="HTTPSampler.contentEncoding"/>
+      <stringProp name="HTTPSampler.path">${base_path}${admin_path}/mui/index/render/</stringProp>
+      <stringProp name="HTTPSampler.method">GET</stringProp>
+      <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
+      <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
+      <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
+      <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
+      <boolProp name="HTTPSampler.monitor">false</boolProp>
+      <stringProp name="HTTPSampler.embedded_url_re"/>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_grid_browsing/set_filtered_pages_count.jmx</stringProp></HTTPSamplerProxy>
+    <hashTree>
+      <com.atlantbh.jmeter.plugins.jsonutils.jsonpathassertion.JSONPathAssertion guiclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathassertion.gui.JSONPathAssertionGui" testclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathassertion.JSONPathAssertion" testname="Assert total records is not 0" enabled="true">
+        <stringProp name="JSON_PATH">$.totalRecords</stringProp>
+        <stringProp name="EXPECTED_VALUE">0</stringProp>
+        <boolProp name="JSONVALIDATION">true</boolProp>
+        <boolProp name="EXPECT_NULL">false</boolProp>
+        <boolProp name="INVERT">true</boolProp>
+        <boolProp name="ISREGEX">true</boolProp>
+      </com.atlantbh.jmeter.plugins.jsonutils.jsonpathassertion.JSONPathAssertion>
+      <hashTree/>
+      <com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor guiclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.gui.JSONPathExtractorGui" testclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor" testname="Extract total records" enabled="true">
+        <stringProp name="VAR">entity_total_records</stringProp>
+        <stringProp name="JSONPATH">$.totalRecords</stringProp>
+        <stringProp name="DEFAULT"/>
+        <stringProp name="VARIABLE"/>
+        <stringProp name="SUBJECT">BODY</stringProp>
+      </com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor>
+      <hashTree/>
+      <JSR223PostProcessor guiclass="TestBeanGUI" testclass="JSR223PreProcessor" testname="SetUp - Calculate ${gridEntityType} filtered pages count" enabled="true">
+        <stringProp name="parameters"/>
+        <stringProp name="filename"/>
+        <stringProp name="script">
+          var pageSize = parseInt(vars.get("grid_entity_page_size")) || 20;
+var totalsRecord = parseInt(vars.get("entity_total_records"));
+var pageCount = Math.round(totalsRecord/pageSize);
+
+vars.put("grid_pages_count_filtered", pageCount);
+        </stringProp>
+        <stringProp name="scriptLanguage">javascript</stringProp>
+      </JSR223PostProcessor>
+      <hashTree/>
+    </hashTree>
+  
+    <CounterConfig guiclass="CounterConfigGui" testclass="CounterConfig" testname="SetUp - Select ${gridEntityType} Page Number" enabled="true">
+      <stringProp name="CounterConfig.start">1</stringProp>
+      <stringProp name="CounterConfig.end">${grid_pages_count}</stringProp>
+      <stringProp name="CounterConfig.incr">1</stringProp>
+      <stringProp name="CounterConfig.name">page_number</stringProp>
+      <stringProp name="CounterConfig.format"/>
+      <boolProp name="CounterConfig.per_user">true</boolProp>
+      <boolProp name="CounterConfig.reset_on_tg_iteration">false</boolProp>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_grid_browsing/select_page_number.jmx</stringProp></CounterConfig>
+    <hashTree/>
+  
+    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="View ${gridEntityType} page" enabled="true">
+      <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
+        <collectionProp name="Arguments.arguments">
+          <elementProp name="namespace" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">${grid_namespace}</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">namespace</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
+          </elementProp>
+          <elementProp name="search" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value"/>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">search</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
+          </elementProp>
+          <elementProp name="filters[placeholder]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">true</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">filters[placeholder]</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
+          </elementProp>
+          <elementProp name="paging[pageSize]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">${grid_entity_page_size}</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">paging[pageSize]</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
+          </elementProp>
+          <elementProp name="paging[current]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">${page_number}</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">paging[current]</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
+          </elementProp>
+          <elementProp name="sorting[field]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">entity_id</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">sorting[field]</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
+          </elementProp>
+          <elementProp name="sorting[direction]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">asc</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">sorting[direction]</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
+          </elementProp>
+          <elementProp name="isAjax" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">true</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">isAjax</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
+          </elementProp>
+        </collectionProp>
+      </elementProp>
+      <stringProp name="HTTPSampler.domain"/>
+      <stringProp name="HTTPSampler.port"/>
+      <stringProp name="HTTPSampler.connect_timeout"/>
+      <stringProp name="HTTPSampler.response_timeout"/>
+      <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
+      <stringProp name="HTTPSampler.contentEncoding"/>
+      <stringProp name="HTTPSampler.path">${base_path}${admin_path}/mui/index/render/</stringProp>
+      <stringProp name="HTTPSampler.method">GET</stringProp>
+      <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
+      <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
+      <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
+      <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
+      <boolProp name="HTTPSampler.monitor">false</boolProp>
+      <stringProp name="HTTPSampler.embedded_url_re"/>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_grid_browsing/admin_browse_grid.jmx</stringProp></HTTPSamplerProxy>
+    <hashTree>
+      <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Response Assertion" enabled="true">
+        <collectionProp name="Asserion.test_strings">
+          <stringProp name="1637639774">\"totalRecords\":[^0]\d*</stringProp>
+        </collectionProp>
+        <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
+        <boolProp name="Assertion.assume_success">false</boolProp>
+        <intProp name="Assertion.test_type">2</intProp>
+      </ResponseAssertion>
+      <hashTree/>
+    </hashTree>
+  
+    <CounterConfig guiclass="CounterConfigGui" testclass="CounterConfig" testname="SetUp - Select Filtered ${gridEntityType} Page Number" enabled="true">
+      <stringProp name="CounterConfig.start">1</stringProp>
+      <stringProp name="CounterConfig.end">${grid_pages_count_filtered}</stringProp>
+      <stringProp name="CounterConfig.incr">1</stringProp>
+      <stringProp name="CounterConfig.name">page_number</stringProp>
+      <stringProp name="CounterConfig.format"/>
+      <boolProp name="CounterConfig.per_user">true</boolProp>
+      <boolProp name="CounterConfig.reset_on_tg_iteration">false</boolProp>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_grid_browsing/select_filtered_page_number.jmx</stringProp></CounterConfig>
+    <hashTree/>
+  
+    <TestFragmentController guiclass="TestFragmentControllerGui" testclass="TestFragmentController" testname="View ${gridEntityType} page - Filtering + Sorting" enabled="true">
+  <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_grid_browsing/admin_browse_grid_sort_and_filter.jmx</stringProp>
+</TestFragmentController>
+    <hashTree>
+      <ForeachController guiclass="ForeachControlPanel" testclass="ForeachController" testname="ForEach Sort Field Defined" enabled="true">
+        <stringProp name="ForeachController.inputVal">grid_sort_field</stringProp>
+        <stringProp name="ForeachController.returnVal">grid_sort_field</stringProp>
+        <boolProp name="ForeachController.useSeparator">true</boolProp>
+        <stringProp name="ForeachController.startIndex">0</stringProp>
+        <stringProp name="ForeachController.endIndex">3</stringProp>
+      </ForeachController>
+      <hashTree>
+        <ForeachController guiclass="ForeachControlPanel" testclass="ForeachController" testname="ForEach Sort Order Defined" enabled="true">
+          <stringProp name="ForeachController.inputVal">grid_sort_order</stringProp>
+          <stringProp name="ForeachController.returnVal">grid_sort_order</stringProp>
+          <boolProp name="ForeachController.useSeparator">true</boolProp>
+          <stringProp name="ForeachController.startIndex">0</stringProp>
+          <stringProp name="ForeachController.endIndex">2</stringProp>
+        </ForeachController>
+        <hashTree>
+          <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="View ${gridEntityType} page - Filtering + Sort By ${grid_sort_field} ${grid_sort_order}" enabled="true">
+            <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
+              <collectionProp name="Arguments.arguments">
+                <elementProp name="namespace" elementType="HTTPArgument">
+                  <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                  <stringProp name="Argument.value">${grid_namespace}</stringProp>
+                  <stringProp name="Argument.metadata">=</stringProp>
+                  <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                  <stringProp name="Argument.name">namespace</stringProp>
+                  <stringProp name="Argument.desc">false</stringProp>
+                </elementProp>
+                <elementProp name="filters[${grid_filter_field}]" elementType="HTTPArgument">
+                  <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                  <stringProp name="Argument.value">${grid_admin_browse_filter_text}</stringProp>
+                  <stringProp name="Argument.metadata">=</stringProp>
+                  <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                  <stringProp name="Argument.name">filters[${grid_filter_field}]</stringProp>
+                  <stringProp name="Argument.desc">false</stringProp>
+                </elementProp>
+                <elementProp name="filters[placeholder]" elementType="HTTPArgument">
+                  <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">true</stringProp>
+                  <stringProp name="Argument.metadata">=</stringProp>
+                  <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                  <stringProp name="Argument.name">filters[placeholder]</stringProp>
+                  <stringProp name="Argument.desc">false</stringProp>
+                </elementProp>
+                <elementProp name="paging[pageSize]" elementType="HTTPArgument">
+                  <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                  <stringProp name="Argument.value">${grid_entity_page_size}</stringProp>
+                  <stringProp name="Argument.metadata">=</stringProp>
+                  <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                  <stringProp name="Argument.name">paging[pageSize]</stringProp>
+                  <stringProp name="Argument.desc">false</stringProp>
+                </elementProp>
+                <elementProp name="paging[current]" elementType="HTTPArgument">
+                  <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                  <stringProp name="Argument.value">${page_number}</stringProp>
+                  <stringProp name="Argument.metadata">=</stringProp>
+                  <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                  <stringProp name="Argument.name">paging[current]</stringProp>
+                  <stringProp name="Argument.desc">false</stringProp>
+                </elementProp>
+                <elementProp name="sorting[field]" elementType="HTTPArgument">
+                  <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                  <stringProp name="Argument.value">${grid_sort_field}</stringProp>
+                  <stringProp name="Argument.metadata">=</stringProp>
+                  <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                  <stringProp name="Argument.name">sorting[field]</stringProp>
+                  <stringProp name="Argument.desc">false</stringProp>
+                </elementProp>
+                <elementProp name="sorting[direction]" elementType="HTTPArgument">
+                  <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                  <stringProp name="Argument.value">${grid_sort_order}</stringProp>
+                  <stringProp name="Argument.metadata">=</stringProp>
+                  <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                  <stringProp name="Argument.name">sorting[direction]</stringProp>
+                  <stringProp name="Argument.desc">false</stringProp>
+                </elementProp>
+                <elementProp name="isAjax" elementType="HTTPArgument">
+                  <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                  <stringProp name="Argument.value">true</stringProp>
+                  <stringProp name="Argument.metadata">=</stringProp>
+                  <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                  <stringProp name="Argument.name">isAjax</stringProp>
+                  <stringProp name="Argument.desc">false</stringProp>
+                </elementProp>
+              </collectionProp>
+            </elementProp>
+            <stringProp name="HTTPSampler.domain"/>
+            <stringProp name="HTTPSampler.port"/>
+            <stringProp name="HTTPSampler.connect_timeout"/>
+            <stringProp name="HTTPSampler.response_timeout"/>
+            <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
+            <stringProp name="HTTPSampler.contentEncoding"/>
+            <stringProp name="HTTPSampler.path">${base_path}${admin_path}/mui/index/render/</stringProp>
+            <stringProp name="HTTPSampler.method">GET</stringProp>
+            <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
+            <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
+            <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
+            <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
+            <boolProp name="HTTPSampler.monitor">false</boolProp>
+            <stringProp name="HTTPSampler.embedded_url_re"/>
+          </HTTPSamplerProxy>
+          <hashTree>
+            <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Response Assertion" enabled="true">
+              <collectionProp name="Asserion.test_strings">
+                <stringProp name="1637639774">\"totalRecords\":[^0]\d*</stringProp>
+              </collectionProp>
+              <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
+              <boolProp name="Assertion.assume_success">false</boolProp>
+              <intProp name="Assertion.test_type">2</intProp>
+            </ResponseAssertion>
+            <hashTree/>
+          </hashTree>
+        </hashTree>
+      </hashTree>
+    </hashTree>
+  </hashTree>
+  
+    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Logout" enabled="true">
+      <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
+        <collectionProp name="Arguments.arguments"/>
+      </elementProp>
+      <stringProp name="HTTPSampler.domain"/>
+      <stringProp name="HTTPSampler.port"/>
+      <stringProp name="HTTPSampler.connect_timeout"/>
+      <stringProp name="HTTPSampler.response_timeout"/>
+      <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
+      <stringProp name="HTTPSampler.contentEncoding"/>
+      <stringProp name="HTTPSampler.path">${base_path}${admin_path}/admin/auth/logout/</stringProp>
+      <stringProp name="HTTPSampler.method">GET</stringProp>
+      <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
+      <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
+      <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
+      <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
+      <boolProp name="HTTPSampler.monitor">false</boolProp>
+      <stringProp name="HTTPSampler.embedded_url_re"/>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/setup/admin_logout.jmx</stringProp></HTTPSamplerProxy>
+    <hashTree>
+    
+    <BeanShellPostProcessor guiclass="TestBeanGUI" testclass="BeanShellPostProcessor" testname="Return Admin to Pool" enabled="true">
+        <boolProp name="resetInterpreter">false</boolProp>
+        <stringProp name="parameters"/>
+        <stringProp name="filename"/>
+        <stringProp name="script">
+adminUserList = props.get("adminUserList");
+adminUserList.add(vars.get("admin_user"));
+        </stringProp>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/common/return_admin_email_to_pool.jmx</stringProp></BeanShellPostProcessor>
+    <hashTree/>
+  </hashTree>
+  </hashTree>
+
+  
+    <ThroughputController guiclass="ThroughputControllerGui" testclass="ThroughputController" testname="Browse Order Grid" enabled="true">
+      <intProp name="ThroughputController.style">1</intProp>
+      <boolProp name="ThroughputController.perThread">false</boolProp>
+      <intProp name="ThroughputController.maxThroughput">1</intProp>
+      <stringProp name="ThroughputController.percentThroughput">${browseOrderGridPercentage}</stringProp>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/_system/scenario_controller_tmpl.jmx</stringProp></ThroughputController>
+    <hashTree>
+        <JSR223PreProcessor guiclass="TestBeanGUI" testclass="JSR223PreProcessor" testname="Set Test Label" enabled="true">
+            <stringProp name="script">
+var testLabel = "${testLabel}" ? " (${testLabel})" : "";
+if (testLabel
+    &amp;&amp; sampler.getClass().getName() == 'org.apache.jmeter.protocol.http.sampler.HTTPSamplerProxy'
+) {
+    if (sampler.getName().indexOf(testLabel) == -1) {
+       sampler.setName(sampler.getName() + testLabel);
+    }
+} else if (sampler.getName().indexOf("SetUp - ") == -1) {
+    sampler.setName("SetUp - " + sampler.getName());
+}
+            </stringProp>
+            <stringProp name="scriptLanguage">javascript</stringProp>
+        <stringProp name="TestPlan.comments">mpaf/tool/fragments/_system/setup_label.jmx</stringProp></JSR223PreProcessor>
         <hashTree/>
-        <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert customer default_billing" enabled="true">
-          <collectionProp name="Asserion.test_strings">
-            <stringProp name="89649215">^\d+$</stringProp>
-          </collectionProp>
-          <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
-          <boolProp name="Assertion.assume_success">false</boolProp>
-          <intProp name="Assertion.test_type">1</intProp>
-          <stringProp name="Assertion.scope">variable</stringProp>
-          <stringProp name="Scope.variable">admin_customer_default_billing</stringProp>
-        </ResponseAssertion>
+        <BeanShellSampler guiclass="BeanShellSamplerGui" testclass="BeanShellSampler" testname="SetUp - Set Label" enabled="true">
+            <stringProp name="BeanShellSampler.query">
+                vars.put("testLabel", "Browse Order Grid");
+            </stringProp>
+            <boolProp name="BeanShellSampler.resetInterpreter">true</boolProp>
+        </BeanShellSampler>
         <hashTree/>
-        <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert customer default_shipping" enabled="true">
-          <collectionProp name="Asserion.test_strings">
-            <stringProp name="89649215">^\d+$</stringProp>
-          </collectionProp>
-          <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
-          <boolProp name="Assertion.assume_success">false</boolProp>
-          <intProp name="Assertion.test_type">1</intProp>
-          <stringProp name="Assertion.scope">variable</stringProp>
-          <stringProp name="Scope.variable">admin_customer_default_shipping</stringProp>
-        </ResponseAssertion>
+    
+        <JSR223PostProcessor guiclass="TestBeanGUI" testclass="JSR223PostProcessor" testname="Get admin form key PostProcessor" enabled="true">
+        <stringProp name="script">
+        function getFormKeyFromResponse()
+        {
+            var url = prev.getUrlAsString(),
+            responseCode =  prev.getResponseCode(),
+            formKey = null;
+            searchPattern = /var FORM_KEY = '(.+)'/;
+            if (responseCode == "200" &amp;&amp; url) {
+                response = prev.getResponseDataAsString();
+                formKey = response  &amp;&amp; response.match(searchPattern) ? response.match(searchPattern)[1] : null;
+            }
+            return formKey;
+        }
+
+        formKey = vars.get("form_key_storage");
+
+	   currentFormKey = getFormKeyFromResponse();
+
+	   if (currentFormKey != null &amp;&amp; currentFormKey != formKey) {
+		  vars.put("form_key_storage", currentFormKey);
+	   }
+        </stringProp>
+        <stringProp name="scriptLanguage">javascript</stringProp>
+        <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin/handle_admin_form_key.jmx</stringProp></JSR223PostProcessor>
         <hashTree/>
-        <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert customer gender" enabled="true">
-          <collectionProp name="Asserion.test_strings">
-            <stringProp name="89649215">^\d+$</stringProp>
-          </collectionProp>
-          <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
-          <boolProp name="Assertion.assume_success">false</boolProp>
-          <intProp name="Assertion.test_type">1</intProp>
-          <stringProp name="Assertion.scope">variable</stringProp>
-          <stringProp name="Scope.variable">admin_customer_gender</stringProp>
-        </ResponseAssertion>
+        <JSR223PreProcessor guiclass="TestBeanGUI" testclass="JSR223PreProcessor" testname="Set admin form key PreProcessor" enabled="true">
+            <stringProp name="script">
+                formKey =  vars.get("form_key_storage");
+                if (formKey
+                    &amp;&amp; sampler.getClass().getName() == 'org.apache.jmeter.protocol.http.sampler.HTTPSamplerProxy'
+                    &amp;&amp; sampler.getMethod() == "POST")
+                    {
+                        arguments = sampler.getArguments();
+                        for (i=0; i&lt;arguments.getArgumentCount(); i++)
+                        {
+                            argument = arguments.getArgument(i);
+                            if (argument.getName() == 'form_key' &amp;&amp; argument.getValue() != formKey) {
+                            log.info("admin form key updated: " + argument.getValue() + " =&gt; " + formKey);
+                            argument.setValue(formKey);
+                        }
+                    }
+                }
+            </stringProp>
+            <stringProp name="scriptLanguage">javascript</stringProp>
+        </JSR223PreProcessor>
         <hashTree/>
-        <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert customer failures_num" enabled="true">
-          <collectionProp name="Asserion.test_strings">
-            <stringProp name="89649215">^\d+$</stringProp>
-          </collectionProp>
-          <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
-          <boolProp name="Assertion.assume_success">false</boolProp>
-          <intProp name="Assertion.test_type">1</intProp>
-          <stringProp name="Assertion.scope">variable</stringProp>
-          <stringProp name="Scope.variable">admin_customer_failures_num</stringProp>
-        </ResponseAssertion>
+    
+    <CookieManager guiclass="CookiePanel" testclass="CookieManager" testname="HTTP Cookie Manager" enabled="true">
+      <collectionProp name="CookieManager.cookies"/>
+      <boolProp name="CookieManager.clearEachIteration">false</boolProp>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/http_cookie_manager_without_clear_each_iteration.jmx</stringProp></CookieManager>
+    <hashTree/>
+  
+    <GenericController guiclass="LogicControllerGui" testclass="GenericController" testname="Admin Login" enabled="true">
+  <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/simple_controller.jmx</stringProp>
+</GenericController>
+    <hashTree>
+    <CriticalSectionController guiclass="CriticalSectionControllerGui" testclass="CriticalSectionController" testname="Admin Login Lock" enabled="true">
+        <stringProp name="CriticalSectionController.lockName">get-admin-email</stringProp>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/lock_controller.jmx</stringProp></CriticalSectionController>
+    <hashTree>
+    
+    <BeanShellSampler guiclass="BeanShellSamplerGui" testclass="BeanShellSampler" testname="SetUp - Get Admin Email" enabled="true">
+      <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/get_admin_email.jmx</stringProp>
+      <stringProp name="BeanShellSampler.query">
+adminUserList = props.get("adminUserList");
+adminUser = adminUserList.poll();
+if (adminUser == null) {
+  SampleResult.setResponseMessage("adminUser list is empty");
+  SampleResult.setResponseData("adminUser list is empty","UTF-8");
+  IsSuccess=false;
+  SampleResult.setSuccessful(false);
+  SampleResult.setStopThread(true);
+}
+vars.put("admin_user", adminUser);
+      </stringProp>
+      <stringProp name="BeanShellSampler.filename"/>
+      <stringProp name="BeanShellSampler.parameters"/>
+      <boolProp name="BeanShellSampler.resetInterpreter">true</boolProp>
+    </BeanShellSampler>
+    <hashTree/>
+  </hashTree>
+  
+    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="SetUp - Login" enabled="true">
+      <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
+        <collectionProp name="Arguments.arguments"/>
+      </elementProp>
+      <stringProp name="HTTPSampler.domain"/>
+      <stringProp name="HTTPSampler.port"/>
+      <stringProp name="HTTPSampler.connect_timeout"/>
+      <stringProp name="HTTPSampler.response_timeout"/>
+      <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
+      <stringProp name="HTTPSampler.contentEncoding"/>
+      <stringProp name="HTTPSampler.path">${base_path}${admin_path}</stringProp>
+      <stringProp name="HTTPSampler.method">GET</stringProp>
+      <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
+      <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
+      <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
+      <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
+      <boolProp name="HTTPSampler.monitor">false</boolProp>
+      <stringProp name="HTTPSampler.embedded_url_re"/>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_login/admin_login.jmx</stringProp></HTTPSamplerProxy>
+    <hashTree>
+      <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert login form shown" enabled="true">
+        <collectionProp name="Asserion.test_strings">
+          <stringProp name="-1397214398">Welcome</stringProp>
+          <stringProp name="-515240035">&lt;title&gt;Magento Admin&lt;/title&gt;</stringProp>
+        </collectionProp>
+        <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
+        <boolProp name="Assertion.assume_success">false</boolProp>
+        <intProp name="Assertion.test_type">2</intProp>
+      </ResponseAssertion>
+      <hashTree/>
+      <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract form key" enabled="true">
+        <stringProp name="RegexExtractor.useHeaders">false</stringProp>
+        <stringProp name="RegexExtractor.refname">admin_form_key</stringProp>
+        <stringProp name="RegexExtractor.regex">&lt;input name="form_key" type="hidden" value="([^'"]+)" /&gt;</stringProp>
+        <stringProp name="RegexExtractor.template">$1$</stringProp>
+        <stringProp name="RegexExtractor.default"/>
+        <stringProp name="RegexExtractor.match_number">1</stringProp>
+      </RegexExtractor>
+      <hashTree/>
+      <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert form_key extracted" enabled="true">
+        <collectionProp name="Asserion.test_strings">
+          <stringProp name="2845929">^.+$</stringProp>
+        </collectionProp>
+        <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
+        <boolProp name="Assertion.assume_success">false</boolProp>
+        <intProp name="Assertion.test_type">1</intProp>
+        <stringProp name="Assertion.scope">variable</stringProp>
+        <stringProp name="Scope.variable">admin_form_key</stringProp>
+      </ResponseAssertion>
+      <hashTree/>
+    </hashTree>
+  
+    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="SetUp - Login Submit Form" enabled="true">
+      <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
+        <collectionProp name="Arguments.arguments">
+          <elementProp name="dummy" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value"/>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">dummy</stringProp>
+          </elementProp>
+          <elementProp name="form_key" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">${admin_form_key}</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">form_key</stringProp>
+          </elementProp>
+          <elementProp name="login[password]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">${admin_password}</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">login[password]</stringProp>
+          </elementProp>
+          <elementProp name="login[username]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">${admin_user}</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">login[username]</stringProp>
+          </elementProp>
+        </collectionProp>
+      </elementProp>
+      <stringProp name="HTTPSampler.domain"/>
+      <stringProp name="HTTPSampler.port"/>
+      <stringProp name="HTTPSampler.connect_timeout"/>
+      <stringProp name="HTTPSampler.response_timeout"/>
+      <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
+      <stringProp name="HTTPSampler.contentEncoding"/>
+      <stringProp name="HTTPSampler.path">${base_path}${admin_path}/admin/dashboard/</stringProp>
+      <stringProp name="HTTPSampler.method">POST</stringProp>
+      <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
+      <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
+      <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
+      <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
+      <stringProp name="HTTPSampler.implementation">Java</stringProp>
+      <boolProp name="HTTPSampler.monitor">false</boolProp>
+      <stringProp name="HTTPSampler.embedded_url_re"/>
+      <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_login/admin_login_submit_form.jmx</stringProp>
+    </HTTPSamplerProxy>
+    <hashTree>
+        <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract form key" enabled="true">
+            <stringProp name="RegexExtractor.useHeaders">false</stringProp>
+            <stringProp name="RegexExtractor.refname">admin_form_key</stringProp>
+            <stringProp name="RegexExtractor.regex">&lt;input name="form_key" type="hidden" value="([^'"]+)" /&gt;</stringProp>
+            <stringProp name="RegexExtractor.template">$1$</stringProp>
+            <stringProp name="RegexExtractor.default"/>
+            <stringProp name="RegexExtractor.match_number">1</stringProp>
+        <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_login/admin_retrieve_form_key.jmx</stringProp></RegexExtractor>
+        <hashTree/>
+    </hashTree>
+  </hashTree>
+  
+    <JSR223PostProcessor guiclass="TestBeanGUI" testclass="JSR223PreProcessor" testname="SetUp - Set Arguments" enabled="true">
+      <stringProp name="script">
+        vars.put("gridEntityType" , "Order");
+
+        pagesCount = parseInt(vars.get("orders_page_size")) || 20;
+        vars.put("grid_entity_page_size" , pagesCount);
+        vars.put("grid_namespace" , "sales_order_grid");
+        vars.put("grid_admin_browse_filter_text" , vars.get("admin_browse_orders_filter_text"));
+        vars.put("grid_filter_field", "status");
+
+        // set sort fields and sort directions
+        vars.put("grid_sort_field_1", "increment_id");
+        vars.put("grid_sort_field_2", "created_at");
+        vars.put("grid_sort_field_3", "billing_name");
+        vars.put("grid_sort_order_1", "asc");
+        vars.put("grid_sort_order_2", "desc");
+      </stringProp>
+      <stringProp name="scriptLanguage">javascript</stringProp>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_browse_orders_grid/setup.jmx</stringProp></JSR223PostProcessor>
+    <hashTree/>
+  
+    <GenericController guiclass="LogicControllerGui" testclass="GenericController" testname="Simple Controller" enabled="true">
+  <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/simple_controller.jmx</stringProp>
+</GenericController>
+    <hashTree>
+    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="SetUp - Set ${gridEntityType} Pages Count" enabled="true">
+      <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
+        <collectionProp name="Arguments.arguments">
+          <elementProp name="namespace" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">${grid_namespace}</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">namespace</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
+          </elementProp>
+          <elementProp name="search" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value"/>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">search</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
+          </elementProp>
+          <elementProp name="filters[placeholder]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">true</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">filters[placeholder]</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
+          </elementProp>
+          <elementProp name="paging[pageSize]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">${grid_entity_page_size}</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">paging[pageSize]</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
+          </elementProp>
+          <elementProp name="paging[current]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">1</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">paging[current]</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
+          </elementProp>
+          <elementProp name="sorting[field]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">entity_id</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">sorting[field]</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
+          </elementProp>
+          <elementProp name="sorting[direction]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">asc</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">sorting[direction]</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
+          </elementProp>
+          <elementProp name="isAjax" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">true</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">isAjax</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
+          </elementProp>
+        </collectionProp>
+      </elementProp>
+      <stringProp name="HTTPSampler.domain"/>
+      <stringProp name="HTTPSampler.port"/>
+      <stringProp name="HTTPSampler.connect_timeout"/>
+      <stringProp name="HTTPSampler.response_timeout"/>
+      <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
+      <stringProp name="HTTPSampler.contentEncoding"/>
+      <stringProp name="HTTPSampler.path">${base_path}${admin_path}/mui/index/render/</stringProp>
+      <stringProp name="HTTPSampler.method">GET</stringProp>
+      <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
+      <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
+      <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
+      <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
+      <boolProp name="HTTPSampler.monitor">false</boolProp>
+      <stringProp name="HTTPSampler.embedded_url_re"/>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_grid_browsing/set_pages_count.jmx</stringProp></HTTPSamplerProxy>
+    <hashTree>
+      <com.atlantbh.jmeter.plugins.jsonutils.jsonpathassertion.JSONPathAssertion guiclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathassertion.gui.JSONPathAssertionGui" testclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathassertion.JSONPathAssertion" testname="Assert total records is not 0" enabled="true">
+        <stringProp name="JSON_PATH">$.totalRecords</stringProp>
+        <stringProp name="EXPECTED_VALUE">0</stringProp>
+        <boolProp name="JSONVALIDATION">true</boolProp>
+        <boolProp name="EXPECT_NULL">false</boolProp>
+        <boolProp name="INVERT">true</boolProp>
+      </com.atlantbh.jmeter.plugins.jsonutils.jsonpathassertion.JSONPathAssertion>
+      <hashTree/>
+      <com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor guiclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.gui.JSONPathExtractorGui" testclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor" testname="Extract total records" enabled="true">
+        <stringProp name="VAR">entity_total_records</stringProp>
+        <stringProp name="JSONPATH">$.totalRecords</stringProp>
+        <stringProp name="DEFAULT"/>
+        <stringProp name="VARIABLE"/>
+        <stringProp name="SUBJECT">BODY</stringProp>
+      </com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor>
+      <hashTree/>
+      <JSR223PostProcessor guiclass="TestBeanGUI" testclass="JSR223PreProcessor" testname="SetUp - Calculate ${gridEntityType} pages count" enabled="true">
+        <stringProp name="cacheKey"/>
+        <stringProp name="filename"/>
+        <stringProp name="parameters"/>
+        <stringProp name="script">
+          var pageSize = parseInt(vars.get("grid_entity_page_size")) || 20;
+          var totalsRecord = parseInt(vars.get("entity_total_records"));
+          var pageCount = Math.round(totalsRecord/pageSize);
+
+          vars.put("grid_pages_count", pageCount);
+        </stringProp>
+        <stringProp name="scriptLanguage">javascript</stringProp>
+      </JSR223PostProcessor>
+      <hashTree/>
+    </hashTree>
+  
+    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="SetUp - Set ${gridEntityType} Filtered Pages Count" enabled="true">
+      <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
+        <collectionProp name="Arguments.arguments">
+          <elementProp name="namespace" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">${grid_namespace}</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">namespace</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
+          </elementProp>
+          <elementProp name="search" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value"/>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">search</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
+          </elementProp>
+          <elementProp name="filters[placeholder]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">${grid_admin_browse_filter_text}</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">filters[placeholder]</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
+          </elementProp>
+          <elementProp name="paging[pageSize]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">${grid_entity_page_size}</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">paging[pageSize]</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
+          </elementProp>
+          <elementProp name="paging[current]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">1</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">paging[current]</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
+          </elementProp>
+          <elementProp name="sorting[field]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">entity_id</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">sorting[field]</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
+          </elementProp>
+          <elementProp name="sorting[direction]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">asc</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">sorting[direction]</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
+          </elementProp>
+          <elementProp name="isAjax" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">true</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">isAjax</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
+          </elementProp>
+        </collectionProp>
+      </elementProp>
+      <stringProp name="HTTPSampler.domain"/>
+      <stringProp name="HTTPSampler.port"/>
+      <stringProp name="HTTPSampler.connect_timeout"/>
+      <stringProp name="HTTPSampler.response_timeout"/>
+      <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
+      <stringProp name="HTTPSampler.contentEncoding"/>
+      <stringProp name="HTTPSampler.path">${base_path}${admin_path}/mui/index/render/</stringProp>
+      <stringProp name="HTTPSampler.method">GET</stringProp>
+      <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
+      <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
+      <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
+      <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
+      <boolProp name="HTTPSampler.monitor">false</boolProp>
+      <stringProp name="HTTPSampler.embedded_url_re"/>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_grid_browsing/set_filtered_pages_count.jmx</stringProp></HTTPSamplerProxy>
+    <hashTree>
+      <com.atlantbh.jmeter.plugins.jsonutils.jsonpathassertion.JSONPathAssertion guiclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathassertion.gui.JSONPathAssertionGui" testclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathassertion.JSONPathAssertion" testname="Assert total records is not 0" enabled="true">
+        <stringProp name="JSON_PATH">$.totalRecords</stringProp>
+        <stringProp name="EXPECTED_VALUE">0</stringProp>
+        <boolProp name="JSONVALIDATION">true</boolProp>
+        <boolProp name="EXPECT_NULL">false</boolProp>
+        <boolProp name="INVERT">true</boolProp>
+        <boolProp name="ISREGEX">true</boolProp>
+      </com.atlantbh.jmeter.plugins.jsonutils.jsonpathassertion.JSONPathAssertion>
+      <hashTree/>
+      <com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor guiclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.gui.JSONPathExtractorGui" testclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor" testname="Extract total records" enabled="true">
+        <stringProp name="VAR">entity_total_records</stringProp>
+        <stringProp name="JSONPATH">$.totalRecords</stringProp>
+        <stringProp name="DEFAULT"/>
+        <stringProp name="VARIABLE"/>
+        <stringProp name="SUBJECT">BODY</stringProp>
+      </com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor>
+      <hashTree/>
+      <JSR223PostProcessor guiclass="TestBeanGUI" testclass="JSR223PreProcessor" testname="SetUp - Calculate ${gridEntityType} filtered pages count" enabled="true">
+        <stringProp name="parameters"/>
+        <stringProp name="filename"/>
+        <stringProp name="script">
+          var pageSize = parseInt(vars.get("grid_entity_page_size")) || 20;
+var totalsRecord = parseInt(vars.get("entity_total_records"));
+var pageCount = Math.round(totalsRecord/pageSize);
+
+vars.put("grid_pages_count_filtered", pageCount);
+        </stringProp>
+        <stringProp name="scriptLanguage">javascript</stringProp>
+      </JSR223PostProcessor>
+      <hashTree/>
+    </hashTree>
+  
+    <CounterConfig guiclass="CounterConfigGui" testclass="CounterConfig" testname="SetUp - Select ${gridEntityType} Page Number" enabled="true">
+      <stringProp name="CounterConfig.start">1</stringProp>
+      <stringProp name="CounterConfig.end">${grid_pages_count}</stringProp>
+      <stringProp name="CounterConfig.incr">1</stringProp>
+      <stringProp name="CounterConfig.name">page_number</stringProp>
+      <stringProp name="CounterConfig.format"/>
+      <boolProp name="CounterConfig.per_user">true</boolProp>
+      <boolProp name="CounterConfig.reset_on_tg_iteration">false</boolProp>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_grid_browsing/select_page_number.jmx</stringProp></CounterConfig>
+    <hashTree/>
+  
+    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="View ${gridEntityType} page" enabled="true">
+      <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
+        <collectionProp name="Arguments.arguments">
+          <elementProp name="namespace" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">${grid_namespace}</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">namespace</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
+          </elementProp>
+          <elementProp name="search" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value"/>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">search</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
+          </elementProp>
+          <elementProp name="filters[placeholder]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">true</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">filters[placeholder]</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
+          </elementProp>
+          <elementProp name="paging[pageSize]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">${grid_entity_page_size}</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">paging[pageSize]</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
+          </elementProp>
+          <elementProp name="paging[current]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">${page_number}</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">paging[current]</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
+          </elementProp>
+          <elementProp name="sorting[field]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">entity_id</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">sorting[field]</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
+          </elementProp>
+          <elementProp name="sorting[direction]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">asc</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">sorting[direction]</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
+          </elementProp>
+          <elementProp name="isAjax" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">true</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">isAjax</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
+          </elementProp>
+        </collectionProp>
+      </elementProp>
+      <stringProp name="HTTPSampler.domain"/>
+      <stringProp name="HTTPSampler.port"/>
+      <stringProp name="HTTPSampler.connect_timeout"/>
+      <stringProp name="HTTPSampler.response_timeout"/>
+      <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
+      <stringProp name="HTTPSampler.contentEncoding"/>
+      <stringProp name="HTTPSampler.path">${base_path}${admin_path}/mui/index/render/</stringProp>
+      <stringProp name="HTTPSampler.method">GET</stringProp>
+      <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
+      <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
+      <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
+      <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
+      <boolProp name="HTTPSampler.monitor">false</boolProp>
+      <stringProp name="HTTPSampler.embedded_url_re"/>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_grid_browsing/admin_browse_grid.jmx</stringProp></HTTPSamplerProxy>
+    <hashTree>
+      <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Response Assertion" enabled="true">
+        <collectionProp name="Asserion.test_strings">
+          <stringProp name="1637639774">\"totalRecords\":[^0]\d*</stringProp>
+        </collectionProp>
+        <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
+        <boolProp name="Assertion.assume_success">false</boolProp>
+        <intProp name="Assertion.test_type">2</intProp>
+      </ResponseAssertion>
+      <hashTree/>
+    </hashTree>
+  
+    <CounterConfig guiclass="CounterConfigGui" testclass="CounterConfig" testname="SetUp - Select Filtered ${gridEntityType} Page Number" enabled="true">
+      <stringProp name="CounterConfig.start">1</stringProp>
+      <stringProp name="CounterConfig.end">${grid_pages_count_filtered}</stringProp>
+      <stringProp name="CounterConfig.incr">1</stringProp>
+      <stringProp name="CounterConfig.name">page_number</stringProp>
+      <stringProp name="CounterConfig.format"/>
+      <boolProp name="CounterConfig.per_user">true</boolProp>
+      <boolProp name="CounterConfig.reset_on_tg_iteration">false</boolProp>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_grid_browsing/select_filtered_page_number.jmx</stringProp></CounterConfig>
+    <hashTree/>
+  
+    <TestFragmentController guiclass="TestFragmentControllerGui" testclass="TestFragmentController" testname="View ${gridEntityType} page - Filtering + Sorting" enabled="true">
+  <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_grid_browsing/admin_browse_grid_sort_and_filter.jmx</stringProp>
+</TestFragmentController>
+    <hashTree>
+      <ForeachController guiclass="ForeachControlPanel" testclass="ForeachController" testname="ForEach Sort Field Defined" enabled="true">
+        <stringProp name="ForeachController.inputVal">grid_sort_field</stringProp>
+        <stringProp name="ForeachController.returnVal">grid_sort_field</stringProp>
+        <boolProp name="ForeachController.useSeparator">true</boolProp>
+        <stringProp name="ForeachController.startIndex">0</stringProp>
+        <stringProp name="ForeachController.endIndex">3</stringProp>
+      </ForeachController>
+      <hashTree>
+        <ForeachController guiclass="ForeachControlPanel" testclass="ForeachController" testname="ForEach Sort Order Defined" enabled="true">
+          <stringProp name="ForeachController.inputVal">grid_sort_order</stringProp>
+          <stringProp name="ForeachController.returnVal">grid_sort_order</stringProp>
+          <boolProp name="ForeachController.useSeparator">true</boolProp>
+          <stringProp name="ForeachController.startIndex">0</stringProp>
+          <stringProp name="ForeachController.endIndex">2</stringProp>
+        </ForeachController>
+        <hashTree>
+          <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="View ${gridEntityType} page - Filtering + Sort By ${grid_sort_field} ${grid_sort_order}" enabled="true">
+            <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
+              <collectionProp name="Arguments.arguments">
+                <elementProp name="namespace" elementType="HTTPArgument">
+                  <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                  <stringProp name="Argument.value">${grid_namespace}</stringProp>
+                  <stringProp name="Argument.metadata">=</stringProp>
+                  <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                  <stringProp name="Argument.name">namespace</stringProp>
+                  <stringProp name="Argument.desc">false</stringProp>
+                </elementProp>
+                <elementProp name="filters[${grid_filter_field}]" elementType="HTTPArgument">
+                  <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                  <stringProp name="Argument.value">${grid_admin_browse_filter_text}</stringProp>
+                  <stringProp name="Argument.metadata">=</stringProp>
+                  <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                  <stringProp name="Argument.name">filters[${grid_filter_field}]</stringProp>
+                  <stringProp name="Argument.desc">false</stringProp>
+                </elementProp>
+                <elementProp name="filters[placeholder]" elementType="HTTPArgument">
+                  <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">true</stringProp>
+                  <stringProp name="Argument.metadata">=</stringProp>
+                  <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                  <stringProp name="Argument.name">filters[placeholder]</stringProp>
+                  <stringProp name="Argument.desc">false</stringProp>
+                </elementProp>
+                <elementProp name="paging[pageSize]" elementType="HTTPArgument">
+                  <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                  <stringProp name="Argument.value">${grid_entity_page_size}</stringProp>
+                  <stringProp name="Argument.metadata">=</stringProp>
+                  <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                  <stringProp name="Argument.name">paging[pageSize]</stringProp>
+                  <stringProp name="Argument.desc">false</stringProp>
+                </elementProp>
+                <elementProp name="paging[current]" elementType="HTTPArgument">
+                  <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                  <stringProp name="Argument.value">${page_number}</stringProp>
+                  <stringProp name="Argument.metadata">=</stringProp>
+                  <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                  <stringProp name="Argument.name">paging[current]</stringProp>
+                  <stringProp name="Argument.desc">false</stringProp>
+                </elementProp>
+                <elementProp name="sorting[field]" elementType="HTTPArgument">
+                  <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                  <stringProp name="Argument.value">${grid_sort_field}</stringProp>
+                  <stringProp name="Argument.metadata">=</stringProp>
+                  <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                  <stringProp name="Argument.name">sorting[field]</stringProp>
+                  <stringProp name="Argument.desc">false</stringProp>
+                </elementProp>
+                <elementProp name="sorting[direction]" elementType="HTTPArgument">
+                  <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                  <stringProp name="Argument.value">${grid_sort_order}</stringProp>
+                  <stringProp name="Argument.metadata">=</stringProp>
+                  <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                  <stringProp name="Argument.name">sorting[direction]</stringProp>
+                  <stringProp name="Argument.desc">false</stringProp>
+                </elementProp>
+                <elementProp name="isAjax" elementType="HTTPArgument">
+                  <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                  <stringProp name="Argument.value">true</stringProp>
+                  <stringProp name="Argument.metadata">=</stringProp>
+                  <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                  <stringProp name="Argument.name">isAjax</stringProp>
+                  <stringProp name="Argument.desc">false</stringProp>
+                </elementProp>
+              </collectionProp>
+            </elementProp>
+            <stringProp name="HTTPSampler.domain"/>
+            <stringProp name="HTTPSampler.port"/>
+            <stringProp name="HTTPSampler.connect_timeout"/>
+            <stringProp name="HTTPSampler.response_timeout"/>
+            <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
+            <stringProp name="HTTPSampler.contentEncoding"/>
+            <stringProp name="HTTPSampler.path">${base_path}${admin_path}/mui/index/render/</stringProp>
+            <stringProp name="HTTPSampler.method">GET</stringProp>
+            <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
+            <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
+            <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
+            <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
+            <boolProp name="HTTPSampler.monitor">false</boolProp>
+            <stringProp name="HTTPSampler.embedded_url_re"/>
+          </HTTPSamplerProxy>
+          <hashTree>
+            <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Response Assertion" enabled="true">
+              <collectionProp name="Asserion.test_strings">
+                <stringProp name="1637639774">\"totalRecords\":[^0]\d*</stringProp>
+              </collectionProp>
+              <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
+              <boolProp name="Assertion.assume_success">false</boolProp>
+              <intProp name="Assertion.test_type">2</intProp>
+            </ResponseAssertion>
+            <hashTree/>
+          </hashTree>
+        </hashTree>
+      </hashTree>
+    </hashTree>
+  </hashTree>
+  
+    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Logout" enabled="true">
+      <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
+        <collectionProp name="Arguments.arguments"/>
+      </elementProp>
+      <stringProp name="HTTPSampler.domain"/>
+      <stringProp name="HTTPSampler.port"/>
+      <stringProp name="HTTPSampler.connect_timeout"/>
+      <stringProp name="HTTPSampler.response_timeout"/>
+      <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
+      <stringProp name="HTTPSampler.contentEncoding"/>
+      <stringProp name="HTTPSampler.path">${base_path}${admin_path}/admin/auth/logout/</stringProp>
+      <stringProp name="HTTPSampler.method">GET</stringProp>
+      <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
+      <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
+      <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
+      <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
+      <boolProp name="HTTPSampler.monitor">false</boolProp>
+      <stringProp name="HTTPSampler.embedded_url_re"/>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/setup/admin_logout.jmx</stringProp></HTTPSamplerProxy>
+    <hashTree>
+    
+    <BeanShellPostProcessor guiclass="TestBeanGUI" testclass="BeanShellPostProcessor" testname="Return Admin to Pool" enabled="true">
+        <boolProp name="resetInterpreter">false</boolProp>
+        <stringProp name="parameters"/>
+        <stringProp name="filename"/>
+        <stringProp name="script">
+adminUserList = props.get("adminUserList");
+adminUserList.add(vars.get("admin_user"));
+        </stringProp>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/common/return_admin_email_to_pool.jmx</stringProp></BeanShellPostProcessor>
+    <hashTree/>
+  </hashTree>
+  </hashTree>
+
+  </hashTree>
+
+    
+        <ThreadGroup guiclass="ThreadGroupGui" testclass="ThreadGroup" testname="CSR Pool" enabled="true">
+            <stringProp name="ThreadGroup.on_sample_error">continue</stringProp>
+            <elementProp name="ThreadGroup.main_controller" elementType="LoopController" guiclass="LoopControlPanel" testclass="LoopController" testname="Loop Controller" enabled="true">
+                <boolProp name="LoopController.continue_forever">false</boolProp>
+                <stringProp name="LoopController.loops">${loops}</stringProp>
+            </elementProp>
+            <stringProp name="ThreadGroup.num_threads">${csrPoolUsers}</stringProp>
+            <stringProp name="ThreadGroup.ramp_time">${ramp_period}</stringProp>
+            <longProp name="ThreadGroup.start_time">1505803944000</longProp>
+            <longProp name="ThreadGroup.end_time">1505803944000</longProp>
+            <boolProp name="ThreadGroup.scheduler">false</boolProp>
+            <stringProp name="ThreadGroup.duration"/>
+            <stringProp name="ThreadGroup.delay"/>
+        <stringProp name="TestPlan.comments">mpaf/tool/fragments/_system/thread_group.jmx</stringProp></ThreadGroup>
+        <hashTree>
+    <ThroughputController guiclass="ThroughputControllerGui" testclass="ThroughputController" testname="Admin Returns Management" enabled="true">
+      <intProp name="ThroughputController.style">1</intProp>
+      <boolProp name="ThroughputController.perThread">false</boolProp>
+      <intProp name="ThroughputController.maxThroughput">1</intProp>
+      <stringProp name="ThroughputController.percentThroughput">${adminReturnsManagementPercentage}</stringProp>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/_system/scenario_controller_tmpl.jmx</stringProp></ThroughputController>
+    <hashTree>
+        <JSR223PreProcessor guiclass="TestBeanGUI" testclass="JSR223PreProcessor" testname="Set Test Label" enabled="true">
+            <stringProp name="script">
+var testLabel = "${testLabel}" ? " (${testLabel})" : "";
+if (testLabel
+    &amp;&amp; sampler.getClass().getName() == 'org.apache.jmeter.protocol.http.sampler.HTTPSamplerProxy'
+) {
+    if (sampler.getName().indexOf(testLabel) == -1) {
+       sampler.setName(sampler.getName() + testLabel);
+    }
+} else if (sampler.getName().indexOf("SetUp - ") == -1) {
+    sampler.setName("SetUp - " + sampler.getName());
+}
+            </stringProp>
+            <stringProp name="scriptLanguage">javascript</stringProp>
+        <stringProp name="TestPlan.comments">mpaf/tool/fragments/_system/setup_label.jmx</stringProp></JSR223PreProcessor>
         <hashTree/>
-        <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert address_entity_id" enabled="true">
-          <collectionProp name="Asserion.test_strings">
-            <stringProp name="89649215">^\d+$</stringProp>
-          </collectionProp>
-          <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
-          <boolProp name="Assertion.assume_success">false</boolProp>
-          <intProp name="Assertion.test_type">1</intProp>
-          <stringProp name="Assertion.scope">variable</stringProp>
-          <stringProp name="Scope.variable">admin_customer_address_entity_id</stringProp>
-        </ResponseAssertion>
+        <BeanShellSampler guiclass="BeanShellSamplerGui" testclass="BeanShellSampler" testname="SetUp - Set Label" enabled="true">
+            <stringProp name="BeanShellSampler.query">
+                vars.put("testLabel", "Admin Returns Management");
+            </stringProp>
+            <boolProp name="BeanShellSampler.resetInterpreter">true</boolProp>
+        </BeanShellSampler>
         <hashTree/>
-        <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert address_created_at" enabled="true">
-          <collectionProp name="Asserion.test_strings">
-            <stringProp name="2845929">^.+$</stringProp>
-          </collectionProp>
-          <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
-          <boolProp name="Assertion.assume_success">false</boolProp>
-          <intProp name="Assertion.test_type">1</intProp>
-          <stringProp name="Assertion.scope">variable</stringProp>
-          <stringProp name="Scope.variable">admin_customer_address_created_at</stringProp>
-        </ResponseAssertion>
+    
+        <JSR223PostProcessor guiclass="TestBeanGUI" testclass="JSR223PostProcessor" testname="Get admin form key PostProcessor" enabled="true">
+        <stringProp name="script">
+        function getFormKeyFromResponse()
+        {
+            var url = prev.getUrlAsString(),
+            responseCode =  prev.getResponseCode(),
+            formKey = null;
+            searchPattern = /var FORM_KEY = '(.+)'/;
+            if (responseCode == "200" &amp;&amp; url) {
+                response = prev.getResponseDataAsString();
+                formKey = response  &amp;&amp; response.match(searchPattern) ? response.match(searchPattern)[1] : null;
+            }
+            return formKey;
+        }
+
+        formKey = vars.get("form_key_storage");
+
+	   currentFormKey = getFormKeyFromResponse();
+
+	   if (currentFormKey != null &amp;&amp; currentFormKey != formKey) {
+		  vars.put("form_key_storage", currentFormKey);
+	   }
+        </stringProp>
+        <stringProp name="scriptLanguage">javascript</stringProp>
+        <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin/handle_admin_form_key.jmx</stringProp></JSR223PostProcessor>
         <hashTree/>
-        <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert address_updated_at" enabled="true">
-          <collectionProp name="Asserion.test_strings">
-            <stringProp name="2845929">^.+$</stringProp>
-          </collectionProp>
-          <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
-          <boolProp name="Assertion.assume_success">false</boolProp>
-          <intProp name="Assertion.test_type">1</intProp>
-          <stringProp name="Assertion.scope">variable</stringProp>
-          <stringProp name="Scope.variable">admin_customer_address_updated_at</stringProp>
-        </ResponseAssertion>
+        <JSR223PreProcessor guiclass="TestBeanGUI" testclass="JSR223PreProcessor" testname="Set admin form key PreProcessor" enabled="true">
+            <stringProp name="script">
+                formKey =  vars.get("form_key_storage");
+                if (formKey
+                    &amp;&amp; sampler.getClass().getName() == 'org.apache.jmeter.protocol.http.sampler.HTTPSamplerProxy'
+                    &amp;&amp; sampler.getMethod() == "POST")
+                    {
+                        arguments = sampler.getArguments();
+                        for (i=0; i&lt;arguments.getArgumentCount(); i++)
+                        {
+                            argument = arguments.getArgument(i);
+                            if (argument.getName() == 'form_key' &amp;&amp; argument.getValue() != formKey) {
+                            log.info("admin form key updated: " + argument.getValue() + " =&gt; " + formKey);
+                            argument.setValue(formKey);
+                        }
+                    }
+                }
+            </stringProp>
+            <stringProp name="scriptLanguage">javascript</stringProp>
+        </JSR223PreProcessor>
         <hashTree/>
-        <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert address_is_active" enabled="true">
-          <collectionProp name="Asserion.test_strings">
-            <stringProp name="89649215">^\d+$</stringProp>
-          </collectionProp>
-          <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
-          <boolProp name="Assertion.assume_success">false</boolProp>
-          <intProp name="Assertion.test_type">1</intProp>
-          <stringProp name="Assertion.scope">variable</stringProp>
-          <stringProp name="Scope.variable">admin_customer_address_is_active</stringProp>
-        </ResponseAssertion>
+    
+    <CookieManager guiclass="CookiePanel" testclass="CookieManager" testname="HTTP Cookie Manager" enabled="true">
+      <collectionProp name="CookieManager.cookies"/>
+      <boolProp name="CookieManager.clearEachIteration">false</boolProp>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/http_cookie_manager_without_clear_each_iteration.jmx</stringProp></CookieManager>
+    <hashTree/>
+  
+    <GenericController guiclass="LogicControllerGui" testclass="GenericController" testname="Admin Login" enabled="true">
+  <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/simple_controller.jmx</stringProp>
+</GenericController>
+    <hashTree>
+    <CriticalSectionController guiclass="CriticalSectionControllerGui" testclass="CriticalSectionController" testname="Admin Login Lock" enabled="true">
+        <stringProp name="CriticalSectionController.lockName">get-admin-email</stringProp>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/lock_controller.jmx</stringProp></CriticalSectionController>
+    <hashTree>
+    
+    <BeanShellSampler guiclass="BeanShellSamplerGui" testclass="BeanShellSampler" testname="SetUp - Get Admin Email" enabled="true">
+      <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/get_admin_email.jmx</stringProp>
+      <stringProp name="BeanShellSampler.query">
+adminUserList = props.get("adminUserList");
+adminUser = adminUserList.poll();
+if (adminUser == null) {
+  SampleResult.setResponseMessage("adminUser list is empty");
+  SampleResult.setResponseData("adminUser list is empty","UTF-8");
+  IsSuccess=false;
+  SampleResult.setSuccessful(false);
+  SampleResult.setStopThread(true);
+}
+vars.put("admin_user", adminUser);
+      </stringProp>
+      <stringProp name="BeanShellSampler.filename"/>
+      <stringProp name="BeanShellSampler.parameters"/>
+      <boolProp name="BeanShellSampler.resetInterpreter">true</boolProp>
+    </BeanShellSampler>
+    <hashTree/>
+  </hashTree>
+  
+    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="SetUp - Login" enabled="true">
+      <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
+        <collectionProp name="Arguments.arguments"/>
+      </elementProp>
+      <stringProp name="HTTPSampler.domain"/>
+      <stringProp name="HTTPSampler.port"/>
+      <stringProp name="HTTPSampler.connect_timeout"/>
+      <stringProp name="HTTPSampler.response_timeout"/>
+      <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
+      <stringProp name="HTTPSampler.contentEncoding"/>
+      <stringProp name="HTTPSampler.path">${base_path}${admin_path}</stringProp>
+      <stringProp name="HTTPSampler.method">GET</stringProp>
+      <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
+      <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
+      <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
+      <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
+      <boolProp name="HTTPSampler.monitor">false</boolProp>
+      <stringProp name="HTTPSampler.embedded_url_re"/>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_login/admin_login.jmx</stringProp></HTTPSamplerProxy>
+    <hashTree>
+      <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert login form shown" enabled="true">
+        <collectionProp name="Asserion.test_strings">
+          <stringProp name="-1397214398">Welcome</stringProp>
+          <stringProp name="-515240035">&lt;title&gt;Magento Admin&lt;/title&gt;</stringProp>
+        </collectionProp>
+        <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
+        <boolProp name="Assertion.assume_success">false</boolProp>
+        <intProp name="Assertion.test_type">2</intProp>
+      </ResponseAssertion>
+      <hashTree/>
+      <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract form key" enabled="true">
+        <stringProp name="RegexExtractor.useHeaders">false</stringProp>
+        <stringProp name="RegexExtractor.refname">admin_form_key</stringProp>
+        <stringProp name="RegexExtractor.regex">&lt;input name="form_key" type="hidden" value="([^'"]+)" /&gt;</stringProp>
+        <stringProp name="RegexExtractor.template">$1$</stringProp>
+        <stringProp name="RegexExtractor.default"/>
+        <stringProp name="RegexExtractor.match_number">1</stringProp>
+      </RegexExtractor>
+      <hashTree/>
+      <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert form_key extracted" enabled="true">
+        <collectionProp name="Asserion.test_strings">
+          <stringProp name="2845929">^.+$</stringProp>
+        </collectionProp>
+        <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
+        <boolProp name="Assertion.assume_success">false</boolProp>
+        <intProp name="Assertion.test_type">1</intProp>
+        <stringProp name="Assertion.scope">variable</stringProp>
+        <stringProp name="Scope.variable">admin_form_key</stringProp>
+      </ResponseAssertion>
+      <hashTree/>
+    </hashTree>
+  
+    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="SetUp - Login Submit Form" enabled="true">
+      <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
+        <collectionProp name="Arguments.arguments">
+          <elementProp name="dummy" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value"/>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">dummy</stringProp>
+          </elementProp>
+          <elementProp name="form_key" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">${admin_form_key}</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">form_key</stringProp>
+          </elementProp>
+          <elementProp name="login[password]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">${admin_password}</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">login[password]</stringProp>
+          </elementProp>
+          <elementProp name="login[username]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">${admin_user}</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">login[username]</stringProp>
+          </elementProp>
+        </collectionProp>
+      </elementProp>
+      <stringProp name="HTTPSampler.domain"/>
+      <stringProp name="HTTPSampler.port"/>
+      <stringProp name="HTTPSampler.connect_timeout"/>
+      <stringProp name="HTTPSampler.response_timeout"/>
+      <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
+      <stringProp name="HTTPSampler.contentEncoding"/>
+      <stringProp name="HTTPSampler.path">${base_path}${admin_path}/admin/dashboard/</stringProp>
+      <stringProp name="HTTPSampler.method">POST</stringProp>
+      <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
+      <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
+      <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
+      <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
+      <stringProp name="HTTPSampler.implementation">Java</stringProp>
+      <boolProp name="HTTPSampler.monitor">false</boolProp>
+      <stringProp name="HTTPSampler.embedded_url_re"/>
+      <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_login/admin_login_submit_form.jmx</stringProp>
+    </HTTPSamplerProxy>
+    <hashTree>
+        <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract form key" enabled="true">
+            <stringProp name="RegexExtractor.useHeaders">false</stringProp>
+            <stringProp name="RegexExtractor.refname">admin_form_key</stringProp>
+            <stringProp name="RegexExtractor.regex">&lt;input name="form_key" type="hidden" value="([^'"]+)" /&gt;</stringProp>
+            <stringProp name="RegexExtractor.template">$1$</stringProp>
+            <stringProp name="RegexExtractor.default"/>
+            <stringProp name="RegexExtractor.match_number">1</stringProp>
+        <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_login/admin_retrieve_form_key.jmx</stringProp></RegexExtractor>
         <hashTree/>
-        <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert address_city" enabled="true">
-          <collectionProp name="Asserion.test_strings">
-            <stringProp name="2845929">^.+$</stringProp>
-          </collectionProp>
-          <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
-          <boolProp name="Assertion.assume_success">false</boolProp>
-          <intProp name="Assertion.test_type">1</intProp>
-          <stringProp name="Assertion.scope">variable</stringProp>
-          <stringProp name="Scope.variable">admin_customer_address_city</stringProp>
-        </ResponseAssertion>
+    </hashTree>
+  </hashTree>
+  
+    <GenericController guiclass="LogicControllerGui" testclass="GenericController" testname="Simple Controller" enabled="true">
+  <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/simple_controller.jmx</stringProp>
+</GenericController>
+    <hashTree>
+  <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Orders page" enabled="true">
+    <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
+      <collectionProp name="Arguments.arguments"/>
+    </elementProp>
+    <stringProp name="HTTPSampler.domain"/>
+    <stringProp name="HTTPSampler.port"/>
+    <stringProp name="HTTPSampler.connect_timeout"/>
+    <stringProp name="HTTPSampler.response_timeout"/>
+    <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
+    <stringProp name="HTTPSampler.contentEncoding"/>
+    <stringProp name="HTTPSampler.path">${base_path}${admin_path}/sales/order/</stringProp>
+    <stringProp name="HTTPSampler.method">GET</stringProp>
+    <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
+    <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
+    <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
+    <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
+    <boolProp name="HTTPSampler.monitor">false</boolProp>
+    <stringProp name="HTTPSampler.embedded_url_re"/>
+  <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_create_process_returns/orders_page.jmx</stringProp></HTTPSamplerProxy>
+  <hashTree>
+    <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Response Assertion" enabled="true">
+      <collectionProp name="Asserion.test_strings">
+        <stringProp name="1204796042">Create New Order</stringProp>
+      </collectionProp>
+      <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
+      <boolProp name="Assertion.assume_success">false</boolProp>
+      <intProp name="Assertion.test_type">2</intProp>
+    </ResponseAssertion>
+    <hashTree/>
+  </hashTree>
+
+  <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Open Orders" enabled="true">
+    <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
+      <collectionProp name="Arguments.arguments">
+        <elementProp name="namespace" elementType="HTTPArgument">
+          <boolProp name="HTTPArgument.always_encode">true</boolProp>
+          <stringProp name="Argument.value">sales_order_grid</stringProp>
+          <stringProp name="Argument.metadata">=</stringProp>
+          <boolProp name="HTTPArgument.use_equals">true</boolProp>
+          <stringProp name="Argument.name">namespace</stringProp>
+        </elementProp>
+        <elementProp name="search" elementType="HTTPArgument">
+          <boolProp name="HTTPArgument.always_encode">true</boolProp>
+          <stringProp name="Argument.value"/>
+          <stringProp name="Argument.metadata">=</stringProp>
+          <boolProp name="HTTPArgument.use_equals">true</boolProp>
+          <stringProp name="Argument.name">search</stringProp>
+        </elementProp>
+        <elementProp name="filters[placeholder]" elementType="HTTPArgument">
+          <boolProp name="HTTPArgument.always_encode">true</boolProp>
+          <stringProp name="Argument.value">true</stringProp>
+          <stringProp name="Argument.metadata">=</stringProp>
+          <boolProp name="HTTPArgument.use_equals">true</boolProp>
+          <stringProp name="Argument.name">filters[placeholder]</stringProp>
+        </elementProp>
+        <elementProp name="paging[pageSize]" elementType="HTTPArgument">
+          <boolProp name="HTTPArgument.always_encode">true</boolProp>
+          <stringProp name="Argument.value">200</stringProp>
+          <stringProp name="Argument.metadata">=</stringProp>
+          <boolProp name="HTTPArgument.use_equals">true</boolProp>
+          <stringProp name="Argument.name">paging[pageSize]</stringProp>
+        </elementProp>
+        <elementProp name="paging[current]" elementType="HTTPArgument">
+          <boolProp name="HTTPArgument.always_encode">true</boolProp>
+          <stringProp name="Argument.value">1</stringProp>
+          <stringProp name="Argument.metadata">=</stringProp>
+          <boolProp name="HTTPArgument.use_equals">true</boolProp>
+          <stringProp name="Argument.name">paging[current]</stringProp>
+        </elementProp>
+        <elementProp name="sorting[field]" elementType="HTTPArgument">
+          <boolProp name="HTTPArgument.always_encode">true</boolProp>
+          <stringProp name="Argument.value">increment_id</stringProp>
+          <stringProp name="Argument.metadata">=</stringProp>
+          <boolProp name="HTTPArgument.use_equals">true</boolProp>
+          <stringProp name="Argument.name">sorting[field]</stringProp>
+        </elementProp>
+        <elementProp name="sorting[direction]" elementType="HTTPArgument">
+          <boolProp name="HTTPArgument.always_encode">true</boolProp>
+          <stringProp name="Argument.value">desc</stringProp>
+          <stringProp name="Argument.metadata">=</stringProp>
+          <boolProp name="HTTPArgument.use_equals">true</boolProp>
+          <stringProp name="Argument.name">sorting[direction]</stringProp>
+        </elementProp>
+        <elementProp name="isAjax" elementType="HTTPArgument">
+          <boolProp name="HTTPArgument.always_encode">true</boolProp>
+          <stringProp name="Argument.value">true</stringProp>
+          <stringProp name="Argument.metadata">=</stringProp>
+          <boolProp name="HTTPArgument.use_equals">true</boolProp>
+          <stringProp name="Argument.name">isAjax</stringProp>
+        </elementProp>
+        <elementProp name="form_key" elementType="HTTPArgument">
+          <boolProp name="HTTPArgument.always_encode">true</boolProp>
+          <stringProp name="Argument.value">${admin_form_key}</stringProp>
+          <stringProp name="Argument.metadata">=</stringProp>
+          <boolProp name="HTTPArgument.use_equals">true</boolProp>
+          <stringProp name="Argument.name">form_key</stringProp>
+          <stringProp name="Argument.desc">false</stringProp>
+        </elementProp>
+        <elementProp name="filters[status]" elementType="HTTPArgument">
+          <boolProp name="HTTPArgument.always_encode">true</boolProp>
+          <stringProp name="Argument.value">pending</stringProp>
+          <stringProp name="Argument.metadata">=</stringProp>
+          <boolProp name="HTTPArgument.use_equals">true</boolProp>
+          <stringProp name="Argument.name">filters[status]</stringProp>
+          <stringProp name="Argument.desc">true</stringProp>
+        </elementProp>
+        <elementProp name="_" elementType="HTTPArgument">
+          <boolProp name="HTTPArgument.always_encode">true</boolProp>
+          <stringProp name="Argument.value">${__time()}${__Random(1,1000000)}</stringProp>
+          <stringProp name="Argument.metadata">=</stringProp>
+          <boolProp name="HTTPArgument.use_equals">true</boolProp>
+          <stringProp name="Argument.name">_</stringProp>
+        </elementProp>
+      </collectionProp>
+    </elementProp>
+    <stringProp name="HTTPSampler.domain"/>
+    <stringProp name="HTTPSampler.port"/>
+    <stringProp name="HTTPSampler.connect_timeout"/>
+    <stringProp name="HTTPSampler.response_timeout"/>
+    <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
+    <stringProp name="HTTPSampler.contentEncoding"/>
+    <stringProp name="HTTPSampler.path">${base_path}${admin_path}/mui/index/render/</stringProp>
+    <stringProp name="HTTPSampler.method">GET</stringProp>
+    <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
+    <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
+    <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
+    <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
+    <boolProp name="HTTPSampler.monitor">false</boolProp>
+    <stringProp name="HTTPSampler.embedded_url_re"/>
+  <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_create_process_returns/open_orders.jmx</stringProp></HTTPSamplerProxy>
+  <hashTree>
+    <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Response Assertion" enabled="true">
+      <collectionProp name="Asserion.test_strings">
+        <stringProp name="1637639774">totalRecords</stringProp>
+      </collectionProp>
+      <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
+      <boolProp name="Assertion.assume_success">false</boolProp>
+      <intProp name="Assertion.test_type">2</intProp>
+    </ResponseAssertion>
+    <hashTree/>
+  </hashTree>
+
+  <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Search Pending Orders" enabled="true">
+    <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
+      <collectionProp name="Arguments.arguments">
+        <elementProp name="form_key" elementType="HTTPArgument">
+          <boolProp name="HTTPArgument.always_encode">true</boolProp>
+          <stringProp name="Argument.value">${admin_form_key}</stringProp>
+          <stringProp name="Argument.metadata">=</stringProp>
+          <boolProp name="HTTPArgument.use_equals">true</boolProp>
+          <stringProp name="Argument.name">form_key</stringProp>
+        </elementProp>
+        <elementProp name="namespace" elementType="HTTPArgument">
+          <boolProp name="HTTPArgument.always_encode">true</boolProp>
+          <stringProp name="Argument.value">sales_order_grid</stringProp>
+          <stringProp name="Argument.metadata">=</stringProp>
+          <boolProp name="HTTPArgument.use_equals">true</boolProp>
+          <stringProp name="Argument.name">namespace</stringProp>
+          <stringProp name="Argument.desc">true</stringProp>
+        </elementProp>
+        <elementProp name="search" elementType="HTTPArgument">
+          <boolProp name="HTTPArgument.always_encode">true</boolProp>
+          <stringProp name="Argument.value"/>
+          <stringProp name="Argument.metadata">=</stringProp>
+          <boolProp name="HTTPArgument.use_equals">true</boolProp>
+          <stringProp name="Argument.name">search</stringProp>
+          <stringProp name="Argument.desc">true</stringProp>
+        </elementProp>
+        <elementProp name="filters[placeholder]" elementType="HTTPArgument">
+          <boolProp name="HTTPArgument.always_encode">true</boolProp>
+          <stringProp name="Argument.value">true</stringProp>
+          <stringProp name="Argument.metadata">=</stringProp>
+          <boolProp name="HTTPArgument.use_equals">true</boolProp>
+          <stringProp name="Argument.name">filters[placeholder]</stringProp>
+          <stringProp name="Argument.desc">true</stringProp>
+        </elementProp>
+        <elementProp name="paging[pageSize]" elementType="HTTPArgument">
+          <boolProp name="HTTPArgument.always_encode">true</boolProp>
+          <stringProp name="Argument.value">200</stringProp>
+          <stringProp name="Argument.metadata">=</stringProp>
+          <boolProp name="HTTPArgument.use_equals">true</boolProp>
+          <stringProp name="Argument.name">paging[pageSize]</stringProp>
+          <stringProp name="Argument.desc">true</stringProp>
+        </elementProp>
+        <elementProp name="paging[current]" elementType="HTTPArgument">
+          <boolProp name="HTTPArgument.always_encode">true</boolProp>
+          <stringProp name="Argument.value">1</stringProp>
+          <stringProp name="Argument.metadata">=</stringProp>
+          <boolProp name="HTTPArgument.use_equals">true</boolProp>
+          <stringProp name="Argument.name">paging[current]</stringProp>
+          <stringProp name="Argument.desc">true</stringProp>
+        </elementProp>
+        <elementProp name="sorting[field]" elementType="HTTPArgument">
+          <boolProp name="HTTPArgument.always_encode">true</boolProp>
+          <stringProp name="Argument.value">increment_id</stringProp>
+          <stringProp name="Argument.metadata">=</stringProp>
+          <boolProp name="HTTPArgument.use_equals">true</boolProp>
+          <stringProp name="Argument.name">sorting[field]</stringProp>
+          <stringProp name="Argument.desc">true</stringProp>
+        </elementProp>
+        <elementProp name="sorting[direction]" elementType="HTTPArgument">
+          <boolProp name="HTTPArgument.always_encode">true</boolProp>
+          <stringProp name="Argument.value">asc</stringProp>
+          <stringProp name="Argument.metadata">=</stringProp>
+          <boolProp name="HTTPArgument.use_equals">true</boolProp>
+          <stringProp name="Argument.name">sorting[direction]</stringProp>
+          <stringProp name="Argument.desc">true</stringProp>
+        </elementProp>
+        <elementProp name="isAjax" elementType="HTTPArgument">
+          <boolProp name="HTTPArgument.always_encode">true</boolProp>
+          <stringProp name="Argument.value">true</stringProp>
+          <stringProp name="Argument.metadata">=</stringProp>
+          <boolProp name="HTTPArgument.use_equals">true</boolProp>
+          <stringProp name="Argument.name">isAjax</stringProp>
+          <stringProp name="Argument.desc">true</stringProp>
+        </elementProp>
+        <elementProp name="filters[status]" elementType="HTTPArgument">
+          <boolProp name="HTTPArgument.always_encode">true</boolProp>
+          <stringProp name="Argument.value">pending</stringProp>
+          <stringProp name="Argument.metadata">=</stringProp>
+          <boolProp name="HTTPArgument.use_equals">true</boolProp>
+          <stringProp name="Argument.name">filters[status]</stringProp>
+        </elementProp>
+        <elementProp name="_" elementType="HTTPArgument">
+          <boolProp name="HTTPArgument.always_encode">true</boolProp>
+          <stringProp name="Argument.value">${__time()}${__Random(1,1000000)}</stringProp>
+          <stringProp name="Argument.metadata">=</stringProp>
+          <boolProp name="HTTPArgument.use_equals">true</boolProp>
+          <stringProp name="Argument.name">_</stringProp>
+        </elementProp>
+      </collectionProp>
+    </elementProp>
+    <stringProp name="HTTPSampler.domain"/>
+    <stringProp name="HTTPSampler.port"/>
+    <stringProp name="HTTPSampler.connect_timeout"/>
+    <stringProp name="HTTPSampler.response_timeout"/>
+    <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
+    <stringProp name="HTTPSampler.contentEncoding"/>
+    <stringProp name="HTTPSampler.path">${base_path}${admin_path}/mui/index/render/</stringProp>
+    <stringProp name="HTTPSampler.method">GET</stringProp>
+    <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
+    <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
+    <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
+    <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
+    <boolProp name="HTTPSampler.monitor">false</boolProp>
+    <stringProp name="HTTPSampler.embedded_url_re"/>
+  <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_create_process_returns/search_orders.jmx</stringProp></HTTPSamplerProxy>
+<hashTree>
+      <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Response Assertion" enabled="true">
+        <collectionProp name="Asserion.test_strings">
+          <stringProp name="1637639774">totalRecords</stringProp>
+        </collectionProp>
+        <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
+        <boolProp name="Assertion.assume_success">false</boolProp>
+        <intProp name="Assertion.test_type">2</intProp>
+      </ResponseAssertion>
+      <hashTree/>
+      <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract order numbers" enabled="true">
+        <stringProp name="RegexExtractor.useHeaders">false</stringProp>
+        <stringProp name="RegexExtractor.refname">order_numbers</stringProp>
+        <stringProp name="RegexExtractor.regex">\"increment_id\":\"(\d+)\"\,</stringProp>
+        <stringProp name="RegexExtractor.template">$1$</stringProp>
+        <stringProp name="RegexExtractor.default"/>
+        <stringProp name="RegexExtractor.match_number">-1</stringProp>
+        <stringProp name="Scope.variable">simple_products</stringProp>
+      </RegexExtractor>
+      <hashTree/>
+      <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract order ids" enabled="true">
+        <stringProp name="RegexExtractor.useHeaders">false</stringProp>
+        <stringProp name="RegexExtractor.refname">order_ids</stringProp>
+        <stringProp name="RegexExtractor.regex">\"entity_id\":\"(\d+)\"\,</stringProp>
+        <stringProp name="RegexExtractor.template">$1$</stringProp>
+        <stringProp name="RegexExtractor.default"/>
+        <stringProp name="RegexExtractor.match_number">-1</stringProp>
+        <stringProp name="Scope.variable">simple_products</stringProp>
+      </RegexExtractor>
+      <hashTree/>
+    </hashTree>
+
+      <BeanShellSampler guiclass="BeanShellSamplerGui" testclass="BeanShellSampler" testname="SetUp - Generate Unique Ids for each Thread" enabled="true">
+        <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_create_process_returns/setup.jmx</stringProp>
+        <stringProp name="BeanShellSampler.query">
+  import java.util.ArrayList;
+  import java.util.HashMap;
+  import org.apache.jmeter.protocol.http.util.Base64Encoder;
+  import java.util.Random;
+
+  // get count of "order_numbers" variable defined in "Search Pending Orders Limit"
+  int ordersCount = Integer.parseInt(vars.get("order_numbers_matchNr"));
+
+
+  int clusterLength;
+  int threadsNumber = ctx.getThreadGroup().getNumThreads();
+  if (threadsNumber == 0) {
+      //Number of orders for one thread
+      clusterLength = ordersCount;
+  } else {
+      clusterLength = Math.round(ordersCount / threadsNumber);
+      if (clusterLength == 0) {
+          clusterLength = 1;
+      }
+  }
+
+  //Current thread number starts from 0
+  int currentThreadNum = ctx.getThreadNum();
+
+  //Index of the current product from the cluster
+  Random random = new Random();
+  int iterator = random.nextInt(clusterLength);
+  if (iterator == 0) {
+  	iterator = 1;
+  }
+
+  int i = clusterLength * currentThreadNum + iterator;
+
+  orderNumber = vars.get("order_numbers_" + i.toString());
+  orderId = vars.get("order_ids_" + i.toString());
+  vars.put("order_number", orderNumber);
+  vars.put("order_id", orderId);
+
+  </stringProp>
+    <stringProp name="BeanShellSampler.filename"/>
+    <stringProp name="BeanShellSampler.parameters"/>
+    <boolProp name="BeanShellSampler.resetInterpreter">false</boolProp>
+  </BeanShellSampler>
+  <hashTree/>
+
+  <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Open Order" enabled="true">
+    <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
+      <collectionProp name="Arguments.arguments"/>
+    </elementProp>
+    <stringProp name="HTTPSampler.domain"/>
+    <stringProp name="HTTPSampler.port"/>
+    <stringProp name="HTTPSampler.connect_timeout"/>
+    <stringProp name="HTTPSampler.response_timeout"/>
+    <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
+    <stringProp name="HTTPSampler.contentEncoding"/>
+    <stringProp name="HTTPSampler.path">${base_path}${admin_path}/sales/order/view/order_id/${order_id}/</stringProp>
+    <stringProp name="HTTPSampler.method">GET</stringProp>
+    <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
+    <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
+    <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
+    <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
+    <boolProp name="HTTPSampler.monitor">false</boolProp>
+    <stringProp name="HTTPSampler.embedded_url_re"/>
+  <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_create_process_returns/open_order.jmx</stringProp></HTTPSamplerProxy>
+  <hashTree>
+    <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Response Assertion" enabled="true">
+      <collectionProp name="Asserion.test_strings">
+        <stringProp name="2103620713">#${order_number}</stringProp>
+      </collectionProp>
+      <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
+      <boolProp name="Assertion.assume_success">false</boolProp>
+      <intProp name="Assertion.test_type">2</intProp>
+    </ResponseAssertion>
+    <hashTree/>
+    <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract order status" enabled="true">
+      <stringProp name="RegexExtractor.useHeaders">false</stringProp>
+      <stringProp name="RegexExtractor.refname">order_status</stringProp>
+      <stringProp name="RegexExtractor.regex">&lt;span id="order_status"&gt;([^&lt;]+)&lt;/span&gt;</stringProp>
+      <stringProp name="RegexExtractor.template">$1$</stringProp>
+      <stringProp name="RegexExtractor.default"/>
+      <stringProp name="RegexExtractor.match_number">1</stringProp>
+      <stringProp name="Scope.variable">simple_products</stringProp>
+    </RegexExtractor>
+    <hashTree/>
+  </hashTree>
+
+    <IfController guiclass="IfControllerPanel" testclass="IfController" testname="If Controller" enabled="true">
+      <stringProp name="IfController.condition">"${order_status}" == "Pending"</stringProp>
+      <boolProp name="IfController.evaluateAll">false</boolProp>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_edit_order/if_controller.jmx</stringProp></IfController>
+    <hashTree>
+  <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Invoice Start" enabled="true">
+    <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
+      <collectionProp name="Arguments.arguments"/>
+    </elementProp>
+    <stringProp name="HTTPSampler.domain"/>
+    <stringProp name="HTTPSampler.port"/>
+    <stringProp name="HTTPSampler.connect_timeout"/>
+    <stringProp name="HTTPSampler.response_timeout"/>
+    <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
+    <stringProp name="HTTPSampler.contentEncoding"/>
+    <stringProp name="HTTPSampler.path">${base_path}${admin_path}/sales/order_invoice/start/order_id/${order_id}/</stringProp>
+    <stringProp name="HTTPSampler.method">GET</stringProp>
+    <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
+    <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
+    <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
+    <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
+    <boolProp name="HTTPSampler.monitor">false</boolProp>
+    <stringProp name="HTTPSampler.embedded_url_re"/>
+  <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_create_process_returns/invoice_start.jmx</stringProp></HTTPSamplerProxy>
+  <hashTree>
+    <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Response Assertion" enabled="true">
+      <collectionProp name="Asserion.test_strings">
+        <stringProp name="-1233850814">Invoice Totals</stringProp>
+      </collectionProp>
+      <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
+      <boolProp name="Assertion.assume_success">false</boolProp>
+      <intProp name="Assertion.test_type">2</intProp>
+    </ResponseAssertion>
+    <hashTree/>
+    <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract ordered items ids" enabled="true">
+      <stringProp name="RegexExtractor.useHeaders">false</stringProp>
+      <stringProp name="RegexExtractor.refname">item_ids</stringProp>
+      <stringProp name="RegexExtractor.regex">&lt;div id="order_item_(\d+)_title"\s*class="product-title"&gt;</stringProp>
+      <stringProp name="RegexExtractor.template">$1$</stringProp>
+      <stringProp name="RegexExtractor.default"/>
+      <stringProp name="RegexExtractor.match_number">-1</stringProp>
+      <stringProp name="Scope.variable">simple_products</stringProp>
+    </RegexExtractor>
+    <hashTree/>
+  </hashTree>
+
+  <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Invoice Submit" enabled="true">
+    <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
+      <collectionProp name="Arguments.arguments">
+        <elementProp name="form_key" elementType="HTTPArgument">
+          <boolProp name="HTTPArgument.always_encode">true</boolProp>
+          <stringProp name="Argument.value">${admin_form_key}</stringProp>
+          <stringProp name="Argument.metadata">=</stringProp>
+          <boolProp name="HTTPArgument.use_equals">true</boolProp>
+          <stringProp name="Argument.name">form_key</stringProp>
+          <stringProp name="Argument.desc">false</stringProp>
+        </elementProp>
+        <elementProp name="invoice[items][${item_ids_1}]" elementType="HTTPArgument">
+          <boolProp name="HTTPArgument.always_encode">true</boolProp>
+          <stringProp name="Argument.value">1</stringProp>
+          <stringProp name="Argument.metadata">=</stringProp>
+          <boolProp name="HTTPArgument.use_equals">true</boolProp>
+          <stringProp name="Argument.name">invoice[items][${item_ids_1}]</stringProp>
+        </elementProp>
+        <elementProp name="invoice[items][${item_ids_2}]" elementType="HTTPArgument">
+          <boolProp name="HTTPArgument.always_encode">true</boolProp>
+          <stringProp name="Argument.value">1</stringProp>
+          <stringProp name="Argument.metadata">=</stringProp>
+          <boolProp name="HTTPArgument.use_equals">true</boolProp>
+          <stringProp name="Argument.name">invoice[items][${item_ids_2}]</stringProp>
+        </elementProp>
+        <elementProp name="invoice[comment_text]" elementType="HTTPArgument">
+          <boolProp name="HTTPArgument.always_encode">true</boolProp>
+          <stringProp name="Argument.value">Invoiced</stringProp>
+          <stringProp name="Argument.metadata">=</stringProp>
+          <boolProp name="HTTPArgument.use_equals">true</boolProp>
+          <stringProp name="Argument.name">invoice[comment_text]</stringProp>
+        </elementProp>
+      </collectionProp>
+    </elementProp>
+    <stringProp name="HTTPSampler.domain"/>
+    <stringProp name="HTTPSampler.port"/>
+    <stringProp name="HTTPSampler.connect_timeout"/>
+    <stringProp name="HTTPSampler.response_timeout"/>
+    <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
+    <stringProp name="HTTPSampler.contentEncoding"/>
+    <stringProp name="HTTPSampler.path">${base_path}${admin_path}/sales/order_invoice/save/order_id/${order_id}/</stringProp>
+    <stringProp name="HTTPSampler.method">POST</stringProp>
+    <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
+    <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
+    <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
+    <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
+    <boolProp name="HTTPSampler.monitor">false</boolProp>
+    <stringProp name="HTTPSampler.embedded_url_re"/>
+  <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_create_process_returns/invoice_submit.jmx</stringProp></HTTPSamplerProxy>
+  <hashTree>
+    <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Response Assertion" enabled="true">
+      <collectionProp name="Asserion.test_strings">
+        <stringProp name="1740524604">The invoice has been created</stringProp>
+      </collectionProp>
+      <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
+      <boolProp name="Assertion.assume_success">false</boolProp>
+      <intProp name="Assertion.test_type">2</intProp>
+    </ResponseAssertion>
+    <hashTree/>
+  </hashTree>
+
+  <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Credit Memo Start" enabled="true">
+    <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
+      <collectionProp name="Arguments.arguments"/>
+    </elementProp>
+    <stringProp name="HTTPSampler.domain"/>
+    <stringProp name="HTTPSampler.port"/>
+    <stringProp name="HTTPSampler.connect_timeout"/>
+    <stringProp name="HTTPSampler.response_timeout"/>
+    <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
+    <stringProp name="HTTPSampler.contentEncoding"/>
+    <stringProp name="HTTPSampler.path">${base_path}${admin_path}/sales/order_creditmemo/start/order_id/${order_id}/</stringProp>
+    <stringProp name="HTTPSampler.method">GET</stringProp>
+    <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
+    <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
+    <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
+    <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
+    <boolProp name="HTTPSampler.monitor">false</boolProp>
+    <stringProp name="HTTPSampler.embedded_url_re"/>
+  <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_create_process_returns/credit_memo_start.jmx</stringProp></HTTPSamplerProxy>
+  <hashTree>
+    <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Response Assertion" enabled="true">
+      <collectionProp name="Asserion.test_strings">
+        <stringProp name="1382627322">New Memo</stringProp>
+      </collectionProp>
+      <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
+      <boolProp name="Assertion.assume_success">false</boolProp>
+      <intProp name="Assertion.test_type">2</intProp>
+    </ResponseAssertion>
+    <hashTree/>
+  </hashTree>
+
+  <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Credit Memo Submit - Full Refund" enabled="true">
+    <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
+      <collectionProp name="Arguments.arguments">
+        <elementProp name="form_key" elementType="HTTPArgument">
+          <boolProp name="HTTPArgument.always_encode">true</boolProp>
+          <stringProp name="Argument.value">${admin_form_key}</stringProp>
+          <stringProp name="Argument.metadata">=</stringProp>
+          <boolProp name="HTTPArgument.use_equals">true</boolProp>
+          <stringProp name="Argument.name">form_key</stringProp>
+          <stringProp name="Argument.desc">false</stringProp>
+        </elementProp>
+        <elementProp name="creditmemo[items][${item_ids_1}][qty]" elementType="HTTPArgument">
+          <boolProp name="HTTPArgument.always_encode">true</boolProp>
+          <stringProp name="Argument.value">1</stringProp>
+          <stringProp name="Argument.metadata">=</stringProp>
+          <boolProp name="HTTPArgument.use_equals">true</boolProp>
+          <stringProp name="Argument.name">creditmemo[items][${item_ids_1}][qty]</stringProp>
+        </elementProp>
+        <elementProp name="creditmemo[items][${item_ids_2}][qty]" elementType="HTTPArgument">
+          <boolProp name="HTTPArgument.always_encode">true</boolProp>
+          <stringProp name="Argument.value">1</stringProp>
+          <stringProp name="Argument.metadata">=</stringProp>
+          <boolProp name="HTTPArgument.use_equals">true</boolProp>
+          <stringProp name="Argument.name">creditmemo[items][${item_ids_2}][qty]</stringProp>
+        </elementProp>
+        <elementProp name="creditmemo[do_offline]" elementType="HTTPArgument">
+          <boolProp name="HTTPArgument.always_encode">true</boolProp>
+          <stringProp name="Argument.value">1</stringProp>
+          <stringProp name="Argument.metadata">=</stringProp>
+          <boolProp name="HTTPArgument.use_equals">true</boolProp>
+          <stringProp name="Argument.name">creditmemo[do_offline]</stringProp>
+        </elementProp>
+        <elementProp name="creditmemo[comment_text]" elementType="HTTPArgument">
+          <boolProp name="HTTPArgument.always_encode">true</boolProp>
+          <stringProp name="Argument.value">Credit Memo added</stringProp>
+          <stringProp name="Argument.metadata">=</stringProp>
+          <boolProp name="HTTPArgument.use_equals">true</boolProp>
+          <stringProp name="Argument.name">creditmemo[comment_text]</stringProp>
+        </elementProp>
+        <elementProp name="creditmemo[shipping_amount]" elementType="HTTPArgument">
+          <boolProp name="HTTPArgument.always_encode">true</boolProp>
+          <stringProp name="Argument.value">10</stringProp>
+          <stringProp name="Argument.metadata">=</stringProp>
+          <boolProp name="HTTPArgument.use_equals">true</boolProp>
+          <stringProp name="Argument.name">creditmemo[shipping_amount]</stringProp>
+        </elementProp>
+        <elementProp name="creditmemo[adjustment_positive]" elementType="HTTPArgument">
+          <boolProp name="HTTPArgument.always_encode">true</boolProp>
+          <stringProp name="Argument.value">0</stringProp>
+          <stringProp name="Argument.metadata">=</stringProp>
+          <boolProp name="HTTPArgument.use_equals">true</boolProp>
+          <stringProp name="Argument.name">creditmemo[adjustment_positive]</stringProp>
+        </elementProp>
+        <elementProp name="creditmemo[adjustment_negative]" elementType="HTTPArgument">
+          <boolProp name="HTTPArgument.always_encode">true</boolProp>
+          <stringProp name="Argument.value">0</stringProp>
+          <stringProp name="Argument.metadata">=</stringProp>
+          <boolProp name="HTTPArgument.use_equals">true</boolProp>
+          <stringProp name="Argument.name">creditmemo[adjustment_negative]</stringProp>
+        </elementProp>
+      </collectionProp>
+    </elementProp>
+    <stringProp name="HTTPSampler.domain"/>
+    <stringProp name="HTTPSampler.port"/>
+    <stringProp name="HTTPSampler.connect_timeout"/>
+    <stringProp name="HTTPSampler.response_timeout"/>
+    <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
+    <stringProp name="HTTPSampler.contentEncoding"/>
+    <stringProp name="HTTPSampler.path">${base_path}${admin_path}/sales/order_creditmemo/save/order_id/${order_id}/</stringProp>
+    <stringProp name="HTTPSampler.method">POST</stringProp>
+    <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
+    <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
+    <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
+    <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
+    <boolProp name="HTTPSampler.monitor">false</boolProp>
+    <stringProp name="HTTPSampler.embedded_url_re"/>
+  <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_create_process_returns/credit_memo_full_refund.jmx</stringProp></HTTPSamplerProxy>
+  <hashTree>
+    <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Response Assertion" enabled="true">
+        <collectionProp name="Asserion.test_strings">
+          <stringProp name="-515117447">You created the credit memo</stringProp>
+        </collectionProp>
+        <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
+        <boolProp name="Assertion.assume_success">false</boolProp>
+        <intProp name="Assertion.test_type">2</intProp>
+      </ResponseAssertion>
+    <hashTree/>
+  </hashTree>
+
+    <TestAction guiclass="TestActionGui" testclass="TestAction" testname="Create/Process Returns - Pause" enabled="true">
+      <intProp name="ActionProcessor.action">1</intProp>
+      <intProp name="ActionProcessor.target">0</intProp>
+      <stringProp name="ActionProcessor.duration">${__javaScript(Math.round(${adminCreateProcessReturnsDelay}*1000))}</stringProp>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_create_process_returns/pause.jmx</stringProp></TestAction>
+    <hashTree/>
+  </hashTree>
+  </hashTree>
+  
+    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Logout" enabled="true">
+      <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
+        <collectionProp name="Arguments.arguments"/>
+      </elementProp>
+      <stringProp name="HTTPSampler.domain"/>
+      <stringProp name="HTTPSampler.port"/>
+      <stringProp name="HTTPSampler.connect_timeout"/>
+      <stringProp name="HTTPSampler.response_timeout"/>
+      <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
+      <stringProp name="HTTPSampler.contentEncoding"/>
+      <stringProp name="HTTPSampler.path">${base_path}${admin_path}/admin/auth/logout/</stringProp>
+      <stringProp name="HTTPSampler.method">GET</stringProp>
+      <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
+      <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
+      <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
+      <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
+      <boolProp name="HTTPSampler.monitor">false</boolProp>
+      <stringProp name="HTTPSampler.embedded_url_re"/>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/setup/admin_logout.jmx</stringProp></HTTPSamplerProxy>
+    <hashTree>
+    
+    <BeanShellPostProcessor guiclass="TestBeanGUI" testclass="BeanShellPostProcessor" testname="Return Admin to Pool" enabled="true">
+        <boolProp name="resetInterpreter">false</boolProp>
+        <stringProp name="parameters"/>
+        <stringProp name="filename"/>
+        <stringProp name="script">
+adminUserList = props.get("adminUserList");
+adminUserList.add(vars.get("admin_user"));
+        </stringProp>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/common/return_admin_email_to_pool.jmx</stringProp></BeanShellPostProcessor>
+    <hashTree/>
+  </hashTree>
+  </hashTree>
+
+  
+    <ThroughputController guiclass="ThroughputControllerGui" testclass="ThroughputController" testname="Browse Customer Grid" enabled="true">
+      <intProp name="ThroughputController.style">1</intProp>
+      <boolProp name="ThroughputController.perThread">false</boolProp>
+      <intProp name="ThroughputController.maxThroughput">1</intProp>
+      <stringProp name="ThroughputController.percentThroughput">${browseCustomerGridPercentage}</stringProp>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/_system/scenario_controller_tmpl.jmx</stringProp></ThroughputController>
+    <hashTree>
+        <JSR223PreProcessor guiclass="TestBeanGUI" testclass="JSR223PreProcessor" testname="Set Test Label" enabled="true">
+            <stringProp name="script">
+var testLabel = "${testLabel}" ? " (${testLabel})" : "";
+if (testLabel
+    &amp;&amp; sampler.getClass().getName() == 'org.apache.jmeter.protocol.http.sampler.HTTPSamplerProxy'
+) {
+    if (sampler.getName().indexOf(testLabel) == -1) {
+       sampler.setName(sampler.getName() + testLabel);
+    }
+} else if (sampler.getName().indexOf("SetUp - ") == -1) {
+    sampler.setName("SetUp - " + sampler.getName());
+}
+            </stringProp>
+            <stringProp name="scriptLanguage">javascript</stringProp>
+        <stringProp name="TestPlan.comments">mpaf/tool/fragments/_system/setup_label.jmx</stringProp></JSR223PreProcessor>
         <hashTree/>
-        <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert address_country_id" enabled="true">
-          <collectionProp name="Asserion.test_strings">
-            <stringProp name="2845929">^.+$</stringProp>
-          </collectionProp>
-          <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
-          <boolProp name="Assertion.assume_success">false</boolProp>
-          <intProp name="Assertion.test_type">1</intProp>
-          <stringProp name="Assertion.scope">variable</stringProp>
-          <stringProp name="Scope.variable">admin_customer_address_country_id</stringProp>
-        </ResponseAssertion>
+        <BeanShellSampler guiclass="BeanShellSamplerGui" testclass="BeanShellSampler" testname="SetUp - Set Label" enabled="true">
+            <stringProp name="BeanShellSampler.query">
+                vars.put("testLabel", "Browse Customer Grid");
+            </stringProp>
+            <boolProp name="BeanShellSampler.resetInterpreter">true</boolProp>
+        </BeanShellSampler>
         <hashTree/>
-        <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert address_firstname" enabled="true">
-          <collectionProp name="Asserion.test_strings">
-            <stringProp name="2845929">^.+$</stringProp>
-          </collectionProp>
-          <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
-          <boolProp name="Assertion.assume_success">false</boolProp>
-          <intProp name="Assertion.test_type">1</intProp>
-          <stringProp name="Assertion.scope">variable</stringProp>
-          <stringProp name="Scope.variable">admin_customer_address_firstname</stringProp>
-        </ResponseAssertion>
+    
+        <JSR223PostProcessor guiclass="TestBeanGUI" testclass="JSR223PostProcessor" testname="Get admin form key PostProcessor" enabled="true">
+        <stringProp name="script">
+        function getFormKeyFromResponse()
+        {
+            var url = prev.getUrlAsString(),
+            responseCode =  prev.getResponseCode(),
+            formKey = null;
+            searchPattern = /var FORM_KEY = '(.+)'/;
+            if (responseCode == "200" &amp;&amp; url) {
+                response = prev.getResponseDataAsString();
+                formKey = response  &amp;&amp; response.match(searchPattern) ? response.match(searchPattern)[1] : null;
+            }
+            return formKey;
+        }
+
+        formKey = vars.get("form_key_storage");
+
+	   currentFormKey = getFormKeyFromResponse();
+
+	   if (currentFormKey != null &amp;&amp; currentFormKey != formKey) {
+		  vars.put("form_key_storage", currentFormKey);
+	   }
+        </stringProp>
+        <stringProp name="scriptLanguage">javascript</stringProp>
+        <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin/handle_admin_form_key.jmx</stringProp></JSR223PostProcessor>
         <hashTree/>
-        <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert address_lastname" enabled="true">
-          <collectionProp name="Asserion.test_strings">
-            <stringProp name="2845929">^.+$</stringProp>
-          </collectionProp>
-          <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
-          <boolProp name="Assertion.assume_success">false</boolProp>
-          <intProp name="Assertion.test_type">1</intProp>
-          <stringProp name="Assertion.scope">variable</stringProp>
-          <stringProp name="Scope.variable">admin_customer_address_lastname</stringProp>
-        </ResponseAssertion>
+        <JSR223PreProcessor guiclass="TestBeanGUI" testclass="JSR223PreProcessor" testname="Set admin form key PreProcessor" enabled="true">
+            <stringProp name="script">
+                formKey =  vars.get("form_key_storage");
+                if (formKey
+                    &amp;&amp; sampler.getClass().getName() == 'org.apache.jmeter.protocol.http.sampler.HTTPSamplerProxy'
+                    &amp;&amp; sampler.getMethod() == "POST")
+                    {
+                        arguments = sampler.getArguments();
+                        for (i=0; i&lt;arguments.getArgumentCount(); i++)
+                        {
+                            argument = arguments.getArgument(i);
+                            if (argument.getName() == 'form_key' &amp;&amp; argument.getValue() != formKey) {
+                            log.info("admin form key updated: " + argument.getValue() + " =&gt; " + formKey);
+                            argument.setValue(formKey);
+                        }
+                    }
+                }
+            </stringProp>
+            <stringProp name="scriptLanguage">javascript</stringProp>
+        </JSR223PreProcessor>
         <hashTree/>
-        <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert address_postcode" enabled="true">
-          <collectionProp name="Asserion.test_strings">
-            <stringProp name="2845929">^.+$</stringProp>
-          </collectionProp>
-          <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
-          <boolProp name="Assertion.assume_success">false</boolProp>
-          <intProp name="Assertion.test_type">1</intProp>
-          <stringProp name="Assertion.scope">variable</stringProp>
-          <stringProp name="Scope.variable">admin_customer_address_postcode</stringProp>
-        </ResponseAssertion>
+    
+    <CookieManager guiclass="CookiePanel" testclass="CookieManager" testname="HTTP Cookie Manager" enabled="true">
+      <collectionProp name="CookieManager.cookies"/>
+      <boolProp name="CookieManager.clearEachIteration">false</boolProp>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/http_cookie_manager_without_clear_each_iteration.jmx</stringProp></CookieManager>
+    <hashTree/>
+  
+    <GenericController guiclass="LogicControllerGui" testclass="GenericController" testname="Admin Login" enabled="true">
+  <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/simple_controller.jmx</stringProp>
+</GenericController>
+    <hashTree>
+    <CriticalSectionController guiclass="CriticalSectionControllerGui" testclass="CriticalSectionController" testname="Admin Login Lock" enabled="true">
+        <stringProp name="CriticalSectionController.lockName">get-admin-email</stringProp>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/lock_controller.jmx</stringProp></CriticalSectionController>
+    <hashTree>
+    
+    <BeanShellSampler guiclass="BeanShellSamplerGui" testclass="BeanShellSampler" testname="SetUp - Get Admin Email" enabled="true">
+      <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/get_admin_email.jmx</stringProp>
+      <stringProp name="BeanShellSampler.query">
+adminUserList = props.get("adminUserList");
+adminUser = adminUserList.poll();
+if (adminUser == null) {
+  SampleResult.setResponseMessage("adminUser list is empty");
+  SampleResult.setResponseData("adminUser list is empty","UTF-8");
+  IsSuccess=false;
+  SampleResult.setSuccessful(false);
+  SampleResult.setStopThread(true);
+}
+vars.put("admin_user", adminUser);
+      </stringProp>
+      <stringProp name="BeanShellSampler.filename"/>
+      <stringProp name="BeanShellSampler.parameters"/>
+      <boolProp name="BeanShellSampler.resetInterpreter">true</boolProp>
+    </BeanShellSampler>
+    <hashTree/>
+  </hashTree>
+  
+    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="SetUp - Login" enabled="true">
+      <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
+        <collectionProp name="Arguments.arguments"/>
+      </elementProp>
+      <stringProp name="HTTPSampler.domain"/>
+      <stringProp name="HTTPSampler.port"/>
+      <stringProp name="HTTPSampler.connect_timeout"/>
+      <stringProp name="HTTPSampler.response_timeout"/>
+      <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
+      <stringProp name="HTTPSampler.contentEncoding"/>
+      <stringProp name="HTTPSampler.path">${base_path}${admin_path}</stringProp>
+      <stringProp name="HTTPSampler.method">GET</stringProp>
+      <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
+      <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
+      <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
+      <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
+      <boolProp name="HTTPSampler.monitor">false</boolProp>
+      <stringProp name="HTTPSampler.embedded_url_re"/>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_login/admin_login.jmx</stringProp></HTTPSamplerProxy>
+    <hashTree>
+      <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert login form shown" enabled="true">
+        <collectionProp name="Asserion.test_strings">
+          <stringProp name="-1397214398">Welcome</stringProp>
+          <stringProp name="-515240035">&lt;title&gt;Magento Admin&lt;/title&gt;</stringProp>
+        </collectionProp>
+        <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
+        <boolProp name="Assertion.assume_success">false</boolProp>
+        <intProp name="Assertion.test_type">2</intProp>
+      </ResponseAssertion>
+      <hashTree/>
+      <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract form key" enabled="true">
+        <stringProp name="RegexExtractor.useHeaders">false</stringProp>
+        <stringProp name="RegexExtractor.refname">admin_form_key</stringProp>
+        <stringProp name="RegexExtractor.regex">&lt;input name="form_key" type="hidden" value="([^'"]+)" /&gt;</stringProp>
+        <stringProp name="RegexExtractor.template">$1$</stringProp>
+        <stringProp name="RegexExtractor.default"/>
+        <stringProp name="RegexExtractor.match_number">1</stringProp>
+      </RegexExtractor>
+      <hashTree/>
+      <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert form_key extracted" enabled="true">
+        <collectionProp name="Asserion.test_strings">
+          <stringProp name="2845929">^.+$</stringProp>
+        </collectionProp>
+        <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
+        <boolProp name="Assertion.assume_success">false</boolProp>
+        <intProp name="Assertion.test_type">1</intProp>
+        <stringProp name="Assertion.scope">variable</stringProp>
+        <stringProp name="Scope.variable">admin_form_key</stringProp>
+      </ResponseAssertion>
+      <hashTree/>
+    </hashTree>
+  
+    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="SetUp - Login Submit Form" enabled="true">
+      <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
+        <collectionProp name="Arguments.arguments">
+          <elementProp name="dummy" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value"/>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">dummy</stringProp>
+          </elementProp>
+          <elementProp name="form_key" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">${admin_form_key}</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">form_key</stringProp>
+          </elementProp>
+          <elementProp name="login[password]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">${admin_password}</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">login[password]</stringProp>
+          </elementProp>
+          <elementProp name="login[username]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">${admin_user}</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">login[username]</stringProp>
+          </elementProp>
+        </collectionProp>
+      </elementProp>
+      <stringProp name="HTTPSampler.domain"/>
+      <stringProp name="HTTPSampler.port"/>
+      <stringProp name="HTTPSampler.connect_timeout"/>
+      <stringProp name="HTTPSampler.response_timeout"/>
+      <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
+      <stringProp name="HTTPSampler.contentEncoding"/>
+      <stringProp name="HTTPSampler.path">${base_path}${admin_path}/admin/dashboard/</stringProp>
+      <stringProp name="HTTPSampler.method">POST</stringProp>
+      <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
+      <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
+      <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
+      <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
+      <stringProp name="HTTPSampler.implementation">Java</stringProp>
+      <boolProp name="HTTPSampler.monitor">false</boolProp>
+      <stringProp name="HTTPSampler.embedded_url_re"/>
+      <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_login/admin_login_submit_form.jmx</stringProp>
+    </HTTPSamplerProxy>
+    <hashTree>
+        <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract form key" enabled="true">
+            <stringProp name="RegexExtractor.useHeaders">false</stringProp>
+            <stringProp name="RegexExtractor.refname">admin_form_key</stringProp>
+            <stringProp name="RegexExtractor.regex">&lt;input name="form_key" type="hidden" value="([^'"]+)" /&gt;</stringProp>
+            <stringProp name="RegexExtractor.template">$1$</stringProp>
+            <stringProp name="RegexExtractor.default"/>
+            <stringProp name="RegexExtractor.match_number">1</stringProp>
+        <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_login/admin_retrieve_form_key.jmx</stringProp></RegexExtractor>
         <hashTree/>
-        <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert address_region" enabled="true">
-          <collectionProp name="Asserion.test_strings">
-            <stringProp name="2845929">^.+$</stringProp>
-          </collectionProp>
-          <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
-          <boolProp name="Assertion.assume_success">false</boolProp>
-          <intProp name="Assertion.test_type">1</intProp>
-          <stringProp name="Assertion.scope">variable</stringProp>
-          <stringProp name="Scope.variable">admin_customer_address_region</stringProp>
-        </ResponseAssertion>
+    </hashTree>
+  </hashTree>
+  
+    <JSR223PostProcessor guiclass="TestBeanGUI" testclass="JSR223PreProcessor" testname="SetUp - Set Arguments" enabled="true">
+      <stringProp name="script">
+        vars.put("gridEntityType" , "Customer");
+
+        pagesCount = parseInt(vars.get("customers_page_size")) || 20;
+        vars.put("grid_entity_page_size" , pagesCount);
+        vars.put("grid_namespace" , "customer_listing");
+        vars.put("grid_admin_browse_filter_text" , vars.get("admin_browse_customer_filter_text"));
+        vars.put("grid_filter_field", "name");
+
+        // set sort fields and sort directions
+        vars.put("grid_sort_field_1", "name");
+        vars.put("grid_sort_field_2", "group_id");
+        vars.put("grid_sort_field_3", "billing_country_id");
+        vars.put("grid_sort_order_1", "asc");
+        vars.put("grid_sort_order_2", "desc");
+      </stringProp>
+      <stringProp name="scriptLanguage">javascript</stringProp>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_browse_customers_grid/setup.jmx</stringProp></JSR223PostProcessor>
+    <hashTree/>
+  
+    <GenericController guiclass="LogicControllerGui" testclass="GenericController" testname="Simple Controller" enabled="true">
+  <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/simple_controller.jmx</stringProp>
+</GenericController>
+    <hashTree>
+    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="SetUp - Set ${gridEntityType} Pages Count" enabled="true">
+      <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
+        <collectionProp name="Arguments.arguments">
+          <elementProp name="namespace" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">${grid_namespace}</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">namespace</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
+          </elementProp>
+          <elementProp name="search" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value"/>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">search</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
+          </elementProp>
+          <elementProp name="filters[placeholder]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">true</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">filters[placeholder]</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
+          </elementProp>
+          <elementProp name="paging[pageSize]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">${grid_entity_page_size}</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">paging[pageSize]</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
+          </elementProp>
+          <elementProp name="paging[current]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">1</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">paging[current]</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
+          </elementProp>
+          <elementProp name="sorting[field]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">entity_id</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">sorting[field]</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
+          </elementProp>
+          <elementProp name="sorting[direction]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">asc</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">sorting[direction]</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
+          </elementProp>
+          <elementProp name="isAjax" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">true</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">isAjax</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
+          </elementProp>
+        </collectionProp>
+      </elementProp>
+      <stringProp name="HTTPSampler.domain"/>
+      <stringProp name="HTTPSampler.port"/>
+      <stringProp name="HTTPSampler.connect_timeout"/>
+      <stringProp name="HTTPSampler.response_timeout"/>
+      <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
+      <stringProp name="HTTPSampler.contentEncoding"/>
+      <stringProp name="HTTPSampler.path">${base_path}${admin_path}/mui/index/render/</stringProp>
+      <stringProp name="HTTPSampler.method">GET</stringProp>
+      <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
+      <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
+      <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
+      <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
+      <boolProp name="HTTPSampler.monitor">false</boolProp>
+      <stringProp name="HTTPSampler.embedded_url_re"/>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_grid_browsing/set_pages_count.jmx</stringProp></HTTPSamplerProxy>
+    <hashTree>
+      <com.atlantbh.jmeter.plugins.jsonutils.jsonpathassertion.JSONPathAssertion guiclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathassertion.gui.JSONPathAssertionGui" testclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathassertion.JSONPathAssertion" testname="Assert total records is not 0" enabled="true">
+        <stringProp name="JSON_PATH">$.totalRecords</stringProp>
+        <stringProp name="EXPECTED_VALUE">0</stringProp>
+        <boolProp name="JSONVALIDATION">true</boolProp>
+        <boolProp name="EXPECT_NULL">false</boolProp>
+        <boolProp name="INVERT">true</boolProp>
+      </com.atlantbh.jmeter.plugins.jsonutils.jsonpathassertion.JSONPathAssertion>
+      <hashTree/>
+      <com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor guiclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.gui.JSONPathExtractorGui" testclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor" testname="Extract total records" enabled="true">
+        <stringProp name="VAR">entity_total_records</stringProp>
+        <stringProp name="JSONPATH">$.totalRecords</stringProp>
+        <stringProp name="DEFAULT"/>
+        <stringProp name="VARIABLE"/>
+        <stringProp name="SUBJECT">BODY</stringProp>
+      </com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor>
+      <hashTree/>
+      <JSR223PostProcessor guiclass="TestBeanGUI" testclass="JSR223PreProcessor" testname="SetUp - Calculate ${gridEntityType} pages count" enabled="true">
+        <stringProp name="cacheKey"/>
+        <stringProp name="filename"/>
+        <stringProp name="parameters"/>
+        <stringProp name="script">
+          var pageSize = parseInt(vars.get("grid_entity_page_size")) || 20;
+          var totalsRecord = parseInt(vars.get("entity_total_records"));
+          var pageCount = Math.round(totalsRecord/pageSize);
+
+          vars.put("grid_pages_count", pageCount);
+        </stringProp>
+        <stringProp name="scriptLanguage">javascript</stringProp>
+      </JSR223PostProcessor>
+      <hashTree/>
+    </hashTree>
+  
+    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="SetUp - Set ${gridEntityType} Filtered Pages Count" enabled="true">
+      <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
+        <collectionProp name="Arguments.arguments">
+          <elementProp name="namespace" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">${grid_namespace}</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">namespace</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
+          </elementProp>
+          <elementProp name="search" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value"/>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">search</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
+          </elementProp>
+          <elementProp name="filters[placeholder]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">${grid_admin_browse_filter_text}</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">filters[placeholder]</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
+          </elementProp>
+          <elementProp name="paging[pageSize]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">${grid_entity_page_size}</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">paging[pageSize]</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
+          </elementProp>
+          <elementProp name="paging[current]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">1</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">paging[current]</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
+          </elementProp>
+          <elementProp name="sorting[field]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">entity_id</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">sorting[field]</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
+          </elementProp>
+          <elementProp name="sorting[direction]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">asc</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">sorting[direction]</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
+          </elementProp>
+          <elementProp name="isAjax" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">true</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">isAjax</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
+          </elementProp>
+        </collectionProp>
+      </elementProp>
+      <stringProp name="HTTPSampler.domain"/>
+      <stringProp name="HTTPSampler.port"/>
+      <stringProp name="HTTPSampler.connect_timeout"/>
+      <stringProp name="HTTPSampler.response_timeout"/>
+      <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
+      <stringProp name="HTTPSampler.contentEncoding"/>
+      <stringProp name="HTTPSampler.path">${base_path}${admin_path}/mui/index/render/</stringProp>
+      <stringProp name="HTTPSampler.method">GET</stringProp>
+      <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
+      <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
+      <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
+      <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
+      <boolProp name="HTTPSampler.monitor">false</boolProp>
+      <stringProp name="HTTPSampler.embedded_url_re"/>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_grid_browsing/set_filtered_pages_count.jmx</stringProp></HTTPSamplerProxy>
+    <hashTree>
+      <com.atlantbh.jmeter.plugins.jsonutils.jsonpathassertion.JSONPathAssertion guiclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathassertion.gui.JSONPathAssertionGui" testclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathassertion.JSONPathAssertion" testname="Assert total records is not 0" enabled="true">
+        <stringProp name="JSON_PATH">$.totalRecords</stringProp>
+        <stringProp name="EXPECTED_VALUE">0</stringProp>
+        <boolProp name="JSONVALIDATION">true</boolProp>
+        <boolProp name="EXPECT_NULL">false</boolProp>
+        <boolProp name="INVERT">true</boolProp>
+        <boolProp name="ISREGEX">true</boolProp>
+      </com.atlantbh.jmeter.plugins.jsonutils.jsonpathassertion.JSONPathAssertion>
+      <hashTree/>
+      <com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor guiclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.gui.JSONPathExtractorGui" testclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor" testname="Extract total records" enabled="true">
+        <stringProp name="VAR">entity_total_records</stringProp>
+        <stringProp name="JSONPATH">$.totalRecords</stringProp>
+        <stringProp name="DEFAULT"/>
+        <stringProp name="VARIABLE"/>
+        <stringProp name="SUBJECT">BODY</stringProp>
+      </com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor>
+      <hashTree/>
+      <JSR223PostProcessor guiclass="TestBeanGUI" testclass="JSR223PreProcessor" testname="SetUp - Calculate ${gridEntityType} filtered pages count" enabled="true">
+        <stringProp name="parameters"/>
+        <stringProp name="filename"/>
+        <stringProp name="script">
+          var pageSize = parseInt(vars.get("grid_entity_page_size")) || 20;
+var totalsRecord = parseInt(vars.get("entity_total_records"));
+var pageCount = Math.round(totalsRecord/pageSize);
+
+vars.put("grid_pages_count_filtered", pageCount);
+        </stringProp>
+        <stringProp name="scriptLanguage">javascript</stringProp>
+      </JSR223PostProcessor>
+      <hashTree/>
+    </hashTree>
+  
+    <CounterConfig guiclass="CounterConfigGui" testclass="CounterConfig" testname="SetUp - Select ${gridEntityType} Page Number" enabled="true">
+      <stringProp name="CounterConfig.start">1</stringProp>
+      <stringProp name="CounterConfig.end">${grid_pages_count}</stringProp>
+      <stringProp name="CounterConfig.incr">1</stringProp>
+      <stringProp name="CounterConfig.name">page_number</stringProp>
+      <stringProp name="CounterConfig.format"/>
+      <boolProp name="CounterConfig.per_user">true</boolProp>
+      <boolProp name="CounterConfig.reset_on_tg_iteration">false</boolProp>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_grid_browsing/select_page_number.jmx</stringProp></CounterConfig>
+    <hashTree/>
+  
+    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="View ${gridEntityType} page" enabled="true">
+      <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
+        <collectionProp name="Arguments.arguments">
+          <elementProp name="namespace" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">${grid_namespace}</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">namespace</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
+          </elementProp>
+          <elementProp name="search" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value"/>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">search</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
+          </elementProp>
+          <elementProp name="filters[placeholder]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">true</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">filters[placeholder]</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
+          </elementProp>
+          <elementProp name="paging[pageSize]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">${grid_entity_page_size}</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">paging[pageSize]</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
+          </elementProp>
+          <elementProp name="paging[current]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">${page_number}</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">paging[current]</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
+          </elementProp>
+          <elementProp name="sorting[field]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">entity_id</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">sorting[field]</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
+          </elementProp>
+          <elementProp name="sorting[direction]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">asc</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">sorting[direction]</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
+          </elementProp>
+          <elementProp name="isAjax" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">true</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">isAjax</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
+          </elementProp>
+        </collectionProp>
+      </elementProp>
+      <stringProp name="HTTPSampler.domain"/>
+      <stringProp name="HTTPSampler.port"/>
+      <stringProp name="HTTPSampler.connect_timeout"/>
+      <stringProp name="HTTPSampler.response_timeout"/>
+      <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
+      <stringProp name="HTTPSampler.contentEncoding"/>
+      <stringProp name="HTTPSampler.path">${base_path}${admin_path}/mui/index/render/</stringProp>
+      <stringProp name="HTTPSampler.method">GET</stringProp>
+      <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
+      <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
+      <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
+      <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
+      <boolProp name="HTTPSampler.monitor">false</boolProp>
+      <stringProp name="HTTPSampler.embedded_url_re"/>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_grid_browsing/admin_browse_grid.jmx</stringProp></HTTPSamplerProxy>
+    <hashTree>
+      <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Response Assertion" enabled="true">
+        <collectionProp name="Asserion.test_strings">
+          <stringProp name="1637639774">\"totalRecords\":[^0]\d*</stringProp>
+        </collectionProp>
+        <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
+        <boolProp name="Assertion.assume_success">false</boolProp>
+        <intProp name="Assertion.test_type">2</intProp>
+      </ResponseAssertion>
+      <hashTree/>
+    </hashTree>
+  
+    <CounterConfig guiclass="CounterConfigGui" testclass="CounterConfig" testname="SetUp - Select Filtered ${gridEntityType} Page Number" enabled="true">
+      <stringProp name="CounterConfig.start">1</stringProp>
+      <stringProp name="CounterConfig.end">${grid_pages_count_filtered}</stringProp>
+      <stringProp name="CounterConfig.incr">1</stringProp>
+      <stringProp name="CounterConfig.name">page_number</stringProp>
+      <stringProp name="CounterConfig.format"/>
+      <boolProp name="CounterConfig.per_user">true</boolProp>
+      <boolProp name="CounterConfig.reset_on_tg_iteration">false</boolProp>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_grid_browsing/select_filtered_page_number.jmx</stringProp></CounterConfig>
+    <hashTree/>
+  
+    <TestFragmentController guiclass="TestFragmentControllerGui" testclass="TestFragmentController" testname="View ${gridEntityType} page - Filtering + Sorting" enabled="true">
+  <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_grid_browsing/admin_browse_grid_sort_and_filter.jmx</stringProp>
+</TestFragmentController>
+    <hashTree>
+      <ForeachController guiclass="ForeachControlPanel" testclass="ForeachController" testname="ForEach Sort Field Defined" enabled="true">
+        <stringProp name="ForeachController.inputVal">grid_sort_field</stringProp>
+        <stringProp name="ForeachController.returnVal">grid_sort_field</stringProp>
+        <boolProp name="ForeachController.useSeparator">true</boolProp>
+        <stringProp name="ForeachController.startIndex">0</stringProp>
+        <stringProp name="ForeachController.endIndex">3</stringProp>
+      </ForeachController>
+      <hashTree>
+        <ForeachController guiclass="ForeachControlPanel" testclass="ForeachController" testname="ForEach Sort Order Defined" enabled="true">
+          <stringProp name="ForeachController.inputVal">grid_sort_order</stringProp>
+          <stringProp name="ForeachController.returnVal">grid_sort_order</stringProp>
+          <boolProp name="ForeachController.useSeparator">true</boolProp>
+          <stringProp name="ForeachController.startIndex">0</stringProp>
+          <stringProp name="ForeachController.endIndex">2</stringProp>
+        </ForeachController>
+        <hashTree>
+          <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="View ${gridEntityType} page - Filtering + Sort By ${grid_sort_field} ${grid_sort_order}" enabled="true">
+            <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
+              <collectionProp name="Arguments.arguments">
+                <elementProp name="namespace" elementType="HTTPArgument">
+                  <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                  <stringProp name="Argument.value">${grid_namespace}</stringProp>
+                  <stringProp name="Argument.metadata">=</stringProp>
+                  <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                  <stringProp name="Argument.name">namespace</stringProp>
+                  <stringProp name="Argument.desc">false</stringProp>
+                </elementProp>
+                <elementProp name="filters[${grid_filter_field}]" elementType="HTTPArgument">
+                  <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                  <stringProp name="Argument.value">${grid_admin_browse_filter_text}</stringProp>
+                  <stringProp name="Argument.metadata">=</stringProp>
+                  <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                  <stringProp name="Argument.name">filters[${grid_filter_field}]</stringProp>
+                  <stringProp name="Argument.desc">false</stringProp>
+                </elementProp>
+                <elementProp name="filters[placeholder]" elementType="HTTPArgument">
+                  <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">true</stringProp>
+                  <stringProp name="Argument.metadata">=</stringProp>
+                  <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                  <stringProp name="Argument.name">filters[placeholder]</stringProp>
+                  <stringProp name="Argument.desc">false</stringProp>
+                </elementProp>
+                <elementProp name="paging[pageSize]" elementType="HTTPArgument">
+                  <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                  <stringProp name="Argument.value">${grid_entity_page_size}</stringProp>
+                  <stringProp name="Argument.metadata">=</stringProp>
+                  <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                  <stringProp name="Argument.name">paging[pageSize]</stringProp>
+                  <stringProp name="Argument.desc">false</stringProp>
+                </elementProp>
+                <elementProp name="paging[current]" elementType="HTTPArgument">
+                  <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                  <stringProp name="Argument.value">${page_number}</stringProp>
+                  <stringProp name="Argument.metadata">=</stringProp>
+                  <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                  <stringProp name="Argument.name">paging[current]</stringProp>
+                  <stringProp name="Argument.desc">false</stringProp>
+                </elementProp>
+                <elementProp name="sorting[field]" elementType="HTTPArgument">
+                  <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                  <stringProp name="Argument.value">${grid_sort_field}</stringProp>
+                  <stringProp name="Argument.metadata">=</stringProp>
+                  <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                  <stringProp name="Argument.name">sorting[field]</stringProp>
+                  <stringProp name="Argument.desc">false</stringProp>
+                </elementProp>
+                <elementProp name="sorting[direction]" elementType="HTTPArgument">
+                  <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                  <stringProp name="Argument.value">${grid_sort_order}</stringProp>
+                  <stringProp name="Argument.metadata">=</stringProp>
+                  <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                  <stringProp name="Argument.name">sorting[direction]</stringProp>
+                  <stringProp name="Argument.desc">false</stringProp>
+                </elementProp>
+                <elementProp name="isAjax" elementType="HTTPArgument">
+                  <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                  <stringProp name="Argument.value">true</stringProp>
+                  <stringProp name="Argument.metadata">=</stringProp>
+                  <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                  <stringProp name="Argument.name">isAjax</stringProp>
+                  <stringProp name="Argument.desc">false</stringProp>
+                </elementProp>
+              </collectionProp>
+            </elementProp>
+            <stringProp name="HTTPSampler.domain"/>
+            <stringProp name="HTTPSampler.port"/>
+            <stringProp name="HTTPSampler.connect_timeout"/>
+            <stringProp name="HTTPSampler.response_timeout"/>
+            <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
+            <stringProp name="HTTPSampler.contentEncoding"/>
+            <stringProp name="HTTPSampler.path">${base_path}${admin_path}/mui/index/render/</stringProp>
+            <stringProp name="HTTPSampler.method">GET</stringProp>
+            <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
+            <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
+            <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
+            <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
+            <boolProp name="HTTPSampler.monitor">false</boolProp>
+            <stringProp name="HTTPSampler.embedded_url_re"/>
+          </HTTPSamplerProxy>
+          <hashTree>
+            <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Response Assertion" enabled="true">
+              <collectionProp name="Asserion.test_strings">
+                <stringProp name="1637639774">\"totalRecords\":[^0]\d*</stringProp>
+              </collectionProp>
+              <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
+              <boolProp name="Assertion.assume_success">false</boolProp>
+              <intProp name="Assertion.test_type">2</intProp>
+            </ResponseAssertion>
+            <hashTree/>
+          </hashTree>
+        </hashTree>
+      </hashTree>
+    </hashTree>
+  </hashTree>
+  
+    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Logout" enabled="true">
+      <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
+        <collectionProp name="Arguments.arguments"/>
+      </elementProp>
+      <stringProp name="HTTPSampler.domain"/>
+      <stringProp name="HTTPSampler.port"/>
+      <stringProp name="HTTPSampler.connect_timeout"/>
+      <stringProp name="HTTPSampler.response_timeout"/>
+      <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
+      <stringProp name="HTTPSampler.contentEncoding"/>
+      <stringProp name="HTTPSampler.path">${base_path}${admin_path}/admin/auth/logout/</stringProp>
+      <stringProp name="HTTPSampler.method">GET</stringProp>
+      <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
+      <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
+      <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
+      <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
+      <boolProp name="HTTPSampler.monitor">false</boolProp>
+      <stringProp name="HTTPSampler.embedded_url_re"/>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/setup/admin_logout.jmx</stringProp></HTTPSamplerProxy>
+    <hashTree>
+    
+    <BeanShellPostProcessor guiclass="TestBeanGUI" testclass="BeanShellPostProcessor" testname="Return Admin to Pool" enabled="true">
+        <boolProp name="resetInterpreter">false</boolProp>
+        <stringProp name="parameters"/>
+        <stringProp name="filename"/>
+        <stringProp name="script">
+adminUserList = props.get("adminUserList");
+adminUserList.add(vars.get("admin_user"));
+        </stringProp>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/common/return_admin_email_to_pool.jmx</stringProp></BeanShellPostProcessor>
+    <hashTree/>
+  </hashTree>
+  </hashTree>
+
+  
+    <ThroughputController guiclass="ThroughputControllerGui" testclass="ThroughputController" testname="Admin Create Order" enabled="true">
+      <intProp name="ThroughputController.style">1</intProp>
+      <boolProp name="ThroughputController.perThread">false</boolProp>
+      <intProp name="ThroughputController.maxThroughput">1</intProp>
+      <stringProp name="ThroughputController.percentThroughput">${adminCreateOrderPercentage}</stringProp>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/_system/scenario_controller_tmpl.jmx</stringProp></ThroughputController>
+    <hashTree>
+        <JSR223PreProcessor guiclass="TestBeanGUI" testclass="JSR223PreProcessor" testname="Set Test Label" enabled="true">
+            <stringProp name="script">
+var testLabel = "${testLabel}" ? " (${testLabel})" : "";
+if (testLabel
+    &amp;&amp; sampler.getClass().getName() == 'org.apache.jmeter.protocol.http.sampler.HTTPSamplerProxy'
+) {
+    if (sampler.getName().indexOf(testLabel) == -1) {
+       sampler.setName(sampler.getName() + testLabel);
+    }
+} else if (sampler.getName().indexOf("SetUp - ") == -1) {
+    sampler.setName("SetUp - " + sampler.getName());
+}
+            </stringProp>
+            <stringProp name="scriptLanguage">javascript</stringProp>
+        <stringProp name="TestPlan.comments">mpaf/tool/fragments/_system/setup_label.jmx</stringProp></JSR223PreProcessor>
         <hashTree/>
-        <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert address_region_id" enabled="true">
-          <collectionProp name="Asserion.test_strings">
-            <stringProp name="89649215">^\d+$</stringProp>
-          </collectionProp>
-          <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
-          <boolProp name="Assertion.assume_success">false</boolProp>
-          <intProp name="Assertion.test_type">1</intProp>
-          <stringProp name="Assertion.scope">variable</stringProp>
-          <stringProp name="Scope.variable">admin_customer_address_region_id</stringProp>
-        </ResponseAssertion>
+        <BeanShellSampler guiclass="BeanShellSamplerGui" testclass="BeanShellSampler" testname="SetUp - Set Label" enabled="true">
+            <stringProp name="BeanShellSampler.query">
+                vars.put("testLabel", "Admin Create Order");
+            </stringProp>
+            <boolProp name="BeanShellSampler.resetInterpreter">true</boolProp>
+        </BeanShellSampler>
         <hashTree/>
-        <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert address_street" enabled="true">
-          <collectionProp name="Asserion.test_strings">
-            <stringProp name="2845929">^.+$</stringProp>
-          </collectionProp>
-          <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
-          <boolProp name="Assertion.assume_success">false</boolProp>
-          <intProp name="Assertion.test_type">1</intProp>
-          <stringProp name="Assertion.scope">variable</stringProp>
-          <stringProp name="Scope.variable">admin_customer_address_street</stringProp>
-        </ResponseAssertion>
+    
+        <JSR223PostProcessor guiclass="TestBeanGUI" testclass="JSR223PostProcessor" testname="Get admin form key PostProcessor" enabled="true">
+        <stringProp name="script">
+        function getFormKeyFromResponse()
+        {
+            var url = prev.getUrlAsString(),
+            responseCode =  prev.getResponseCode(),
+            formKey = null;
+            searchPattern = /var FORM_KEY = '(.+)'/;
+            if (responseCode == "200" &amp;&amp; url) {
+                response = prev.getResponseDataAsString();
+                formKey = response  &amp;&amp; response.match(searchPattern) ? response.match(searchPattern)[1] : null;
+            }
+            return formKey;
+        }
+
+        formKey = vars.get("form_key_storage");
+
+	   currentFormKey = getFormKeyFromResponse();
+
+	   if (currentFormKey != null &amp;&amp; currentFormKey != formKey) {
+		  vars.put("form_key_storage", currentFormKey);
+	   }
+        </stringProp>
+        <stringProp name="scriptLanguage">javascript</stringProp>
+        <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin/handle_admin_form_key.jmx</stringProp></JSR223PostProcessor>
         <hashTree/>
-        <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert address_telephone" enabled="true">
-          <collectionProp name="Asserion.test_strings">
-            <stringProp name="2845929">^.+$</stringProp>
-          </collectionProp>
-          <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
-          <boolProp name="Assertion.assume_success">false</boolProp>
-          <intProp name="Assertion.test_type">1</intProp>
-          <stringProp name="Assertion.scope">variable</stringProp>
-          <stringProp name="Scope.variable">admin_customer_address_telephone</stringProp>
-        </ResponseAssertion>
+        <JSR223PreProcessor guiclass="TestBeanGUI" testclass="JSR223PreProcessor" testname="Set admin form key PreProcessor" enabled="true">
+            <stringProp name="script">
+                formKey =  vars.get("form_key_storage");
+                if (formKey
+                    &amp;&amp; sampler.getClass().getName() == 'org.apache.jmeter.protocol.http.sampler.HTTPSamplerProxy'
+                    &amp;&amp; sampler.getMethod() == "POST")
+                    {
+                        arguments = sampler.getArguments();
+                        for (i=0; i&lt;arguments.getArgumentCount(); i++)
+                        {
+                            argument = arguments.getArgument(i);
+                            if (argument.getName() == 'form_key' &amp;&amp; argument.getValue() != formKey) {
+                            log.info("admin form key updated: " + argument.getValue() + " =&gt; " + formKey);
+                            argument.setValue(formKey);
+                        }
+                    }
+                }
+            </stringProp>
+            <stringProp name="scriptLanguage">javascript</stringProp>
+        </JSR223PreProcessor>
         <hashTree/>
-        <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert address_customer_id" enabled="true">
-          <collectionProp name="Asserion.test_strings">
-            <stringProp name="89649215">^\d+$</stringProp>
-          </collectionProp>
-          <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
-          <boolProp name="Assertion.assume_success">false</boolProp>
-          <intProp name="Assertion.test_type">1</intProp>
-          <stringProp name="Assertion.scope">variable</stringProp>
-          <stringProp name="Scope.variable">admin_customer_address_customer_id</stringProp>
-        </ResponseAssertion>
+    
+    <CookieManager guiclass="CookiePanel" testclass="CookieManager" testname="HTTP Cookie Manager" enabled="true">
+      <collectionProp name="CookieManager.cookies"/>
+      <boolProp name="CookieManager.clearEachIteration">false</boolProp>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/http_cookie_manager_without_clear_each_iteration.jmx</stringProp></CookieManager>
+    <hashTree/>
+  
+    <GenericController guiclass="LogicControllerGui" testclass="GenericController" testname="Admin Login" enabled="true">
+  <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/simple_controller.jmx</stringProp>
+</GenericController>
+    <hashTree>
+    <CriticalSectionController guiclass="CriticalSectionControllerGui" testclass="CriticalSectionController" testname="Admin Login Lock" enabled="true">
+        <stringProp name="CriticalSectionController.lockName">get-admin-email</stringProp>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/lock_controller.jmx</stringProp></CriticalSectionController>
+    <hashTree>
+    
+    <BeanShellSampler guiclass="BeanShellSamplerGui" testclass="BeanShellSampler" testname="SetUp - Get Admin Email" enabled="true">
+      <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/get_admin_email.jmx</stringProp>
+      <stringProp name="BeanShellSampler.query">
+adminUserList = props.get("adminUserList");
+adminUser = adminUserList.poll();
+if (adminUser == null) {
+  SampleResult.setResponseMessage("adminUser list is empty");
+  SampleResult.setResponseData("adminUser list is empty","UTF-8");
+  IsSuccess=false;
+  SampleResult.setSuccessful(false);
+  SampleResult.setStopThread(true);
+}
+vars.put("admin_user", adminUser);
+      </stringProp>
+      <stringProp name="BeanShellSampler.filename"/>
+      <stringProp name="BeanShellSampler.parameters"/>
+      <boolProp name="BeanShellSampler.resetInterpreter">true</boolProp>
+    </BeanShellSampler>
+    <hashTree/>
+  </hashTree>
+  
+    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="SetUp - Login" enabled="true">
+      <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
+        <collectionProp name="Arguments.arguments"/>
+      </elementProp>
+      <stringProp name="HTTPSampler.domain"/>
+      <stringProp name="HTTPSampler.port"/>
+      <stringProp name="HTTPSampler.connect_timeout"/>
+      <stringProp name="HTTPSampler.response_timeout"/>
+      <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
+      <stringProp name="HTTPSampler.contentEncoding"/>
+      <stringProp name="HTTPSampler.path">${base_path}${admin_path}</stringProp>
+      <stringProp name="HTTPSampler.method">GET</stringProp>
+      <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
+      <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
+      <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
+      <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
+      <boolProp name="HTTPSampler.monitor">false</boolProp>
+      <stringProp name="HTTPSampler.embedded_url_re"/>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_login/admin_login.jmx</stringProp></HTTPSamplerProxy>
+    <hashTree>
+      <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert login form shown" enabled="true">
+        <collectionProp name="Asserion.test_strings">
+          <stringProp name="-1397214398">Welcome</stringProp>
+          <stringProp name="-515240035">&lt;title&gt;Magento Admin&lt;/title&gt;</stringProp>
+        </collectionProp>
+        <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
+        <boolProp name="Assertion.assume_success">false</boolProp>
+        <intProp name="Assertion.test_type">2</intProp>
+      </ResponseAssertion>
+      <hashTree/>
+      <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract form key" enabled="true">
+        <stringProp name="RegexExtractor.useHeaders">false</stringProp>
+        <stringProp name="RegexExtractor.refname">admin_form_key</stringProp>
+        <stringProp name="RegexExtractor.regex">&lt;input name="form_key" type="hidden" value="([^'"]+)" /&gt;</stringProp>
+        <stringProp name="RegexExtractor.template">$1$</stringProp>
+        <stringProp name="RegexExtractor.default"/>
+        <stringProp name="RegexExtractor.match_number">1</stringProp>
+      </RegexExtractor>
+      <hashTree/>
+      <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert form_key extracted" enabled="true">
+        <collectionProp name="Asserion.test_strings">
+          <stringProp name="2845929">^.+$</stringProp>
+        </collectionProp>
+        <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
+        <boolProp name="Assertion.assume_success">false</boolProp>
+        <intProp name="Assertion.test_type">1</intProp>
+        <stringProp name="Assertion.scope">variable</stringProp>
+        <stringProp name="Scope.variable">admin_form_key</stringProp>
+      </ResponseAssertion>
+      <hashTree/>
+    </hashTree>
+  
+    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="SetUp - Login Submit Form" enabled="true">
+      <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
+        <collectionProp name="Arguments.arguments">
+          <elementProp name="dummy" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value"/>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">dummy</stringProp>
+          </elementProp>
+          <elementProp name="form_key" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">${admin_form_key}</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">form_key</stringProp>
+          </elementProp>
+          <elementProp name="login[password]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">${admin_password}</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">login[password]</stringProp>
+          </elementProp>
+          <elementProp name="login[username]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">${admin_user}</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">login[username]</stringProp>
+          </elementProp>
+        </collectionProp>
+      </elementProp>
+      <stringProp name="HTTPSampler.domain"/>
+      <stringProp name="HTTPSampler.port"/>
+      <stringProp name="HTTPSampler.connect_timeout"/>
+      <stringProp name="HTTPSampler.response_timeout"/>
+      <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
+      <stringProp name="HTTPSampler.contentEncoding"/>
+      <stringProp name="HTTPSampler.path">${base_path}${admin_path}/admin/dashboard/</stringProp>
+      <stringProp name="HTTPSampler.method">POST</stringProp>
+      <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
+      <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
+      <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
+      <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
+      <stringProp name="HTTPSampler.implementation">Java</stringProp>
+      <boolProp name="HTTPSampler.monitor">false</boolProp>
+      <stringProp name="HTTPSampler.embedded_url_re"/>
+      <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_login/admin_login_submit_form.jmx</stringProp>
+    </HTTPSamplerProxy>
+    <hashTree>
+        <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract form key" enabled="true">
+            <stringProp name="RegexExtractor.useHeaders">false</stringProp>
+            <stringProp name="RegexExtractor.refname">admin_form_key</stringProp>
+            <stringProp name="RegexExtractor.regex">&lt;input name="form_key" type="hidden" value="([^'"]+)" /&gt;</stringProp>
+            <stringProp name="RegexExtractor.template">$1$</stringProp>
+            <stringProp name="RegexExtractor.default"/>
+            <stringProp name="RegexExtractor.match_number">1</stringProp>
+        <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_login/admin_retrieve_form_key.jmx</stringProp></RegexExtractor>
         <hashTree/>
+    </hashTree>
+  </hashTree>
+  
+    <GenericController guiclass="LogicControllerGui" testclass="GenericController" testname="Simple Controller" enabled="true">
+  <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/simple_controller.jmx</stringProp>
+</GenericController>
+    <hashTree>
+    <TestFragmentController guiclass="TestFragmentControllerGui" testclass="TestFragmentController" testname="Admin Create Order" enabled="true"/>
+    <hashTree>
+      <BeanShellSampler guiclass="BeanShellSamplerGui" testclass="BeanShellSampler" testname="SetUp - Set Arguments" enabled="true">
+        <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_create_order/admin_create_order.jmx</stringProp>
+        <stringProp name="BeanShellSampler.query">import org.apache.jmeter.samplers.SampleResult;
+import java.util.Random;
+Random random = new Random();
+if (${seedForRandom} &gt; 0) {
+  random.setSeed(${seedForRandom});
+}
+number = random.nextInt(props.get("simple_products_list").size());
+simpleList = props.get("simple_products_list").get(number);
+vars.put("simple_product_1_url_key", simpleList.get("url_key"));
+vars.put("simple_product_1_name", simpleList.get("title"));
+vars.put("simple_product_1_id", simpleList.get("id"));
+
+do {
+    number1 = random.nextInt(props.get("simple_products_list").size());
+} while(number == number1);
+simpleList = props.get("simple_products_list").get(number1);
+vars.put("simple_product_2_url_key", simpleList.get("url_key"));
+vars.put("simple_product_2_name", simpleList.get("title"));
+vars.put("simple_product_2_id", simpleList.get("id"));
+
+number = random.nextInt(props.get("configurable_products_list").size());
+configurableList = props.get("configurable_products_list").get(number);
+vars.put("configurable_product_1_url_key", configurableList.get("url_key"));
+vars.put("configurable_product_1_name", configurableList.get("title"));
+vars.put("configurable_product_1_id", configurableList.get("id"));
+vars.put("configurable_product_1_sku", configurableList.get("sku"));
+vars.put("configurable_attribute_id", configurableList.get("attribute_id"));
+vars.put("configurable_option_id", configurableList.get("attribute_option_id"));
+
+
+customers_index = 0;
+if (!props.containsKey("customer_ids_index")) {
+	props.put("customer_ids_index", customers_index);
+}
+
+try {
+	customers_index = props.get("customer_ids_index");
+	customers_list = props.get("customer_ids_list");
+
+	if (customers_index == customers_list.size()) {
+		customers_index=0;
+	}
+	vars.put("customer_id", customers_list.get(customers_index));
+	props.put("customer_ids_index", ++customers_index);
+}
+catch (java.lang.Exception e) {
+	   log.error("Caught Exception in 'Admin Create Order' thread.");
+	   SampleResult.setStopThread(true);
+}</stringProp>
+        <stringProp name="BeanShellSampler.filename"/>
+        <stringProp name="BeanShellSampler.parameters"/>
+        <boolProp name="BeanShellSampler.resetInterpreter">true</boolProp>
+      </BeanShellSampler>
+      <hashTree/>
+      <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Start Order" enabled="true">
+        <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
+          <collectionProp name="Arguments.arguments"/>
+        </elementProp>
+        <stringProp name="HTTPSampler.domain"/>
+        <stringProp name="HTTPSampler.port"/>
+        <stringProp name="HTTPSampler.connect_timeout"/>
+        <stringProp name="HTTPSampler.response_timeout"/>
+        <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
+        <stringProp name="HTTPSampler.contentEncoding"/>
+        <stringProp name="HTTPSampler.path">${base_path}${admin_path}/sales/order_create/start/</stringProp>
+        <stringProp name="HTTPSampler.method">GET</stringProp>
+        <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
+        <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
+        <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
+        <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
+        <boolProp name="HTTPSampler.monitor">false</boolProp>
+        <stringProp name="HTTPSampler.embedded_url_re"/>
+        <stringProp name="TestPlan.comments">Detected the start of a redirect chain</stringProp>
+      </HTTPSamplerProxy>
+      <hashTree/>
+      <GenericController guiclass="LogicControllerGui" testclass="GenericController" testname="SetUp - Get Configurable Product Options" enabled="true"/>
+      <hashTree>
         <HeaderManager guiclass="HeaderPanel" testclass="HeaderManager" testname="HTTP Header Manager" enabled="true">
           <collectionProp name="HeaderManager.headers">
-            <elementProp name="Accept-Language" elementType="Header">
-              <stringProp name="Header.name">Accept-Language</stringProp>
-              <stringProp name="Header.value">en-US,en;q=0.5</stringProp>
+            <elementProp name="" elementType="Header">
+              <stringProp name="Header.name">Content-Type</stringProp>
+              <stringProp name="Header.value">application/json</stringProp>
             </elementProp>
-            <elementProp name="Accept" elementType="Header">
+            <elementProp name="" elementType="Header">
               <stringProp name="Header.name">Accept</stringProp>
-              <stringProp name="Header.value">text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8</stringProp>
-            </elementProp>
-            <elementProp name="User-Agent" elementType="Header">
-              <stringProp name="Header.name">User-Agent</stringProp>
-              <stringProp name="Header.value">Mozilla/5.0 (Windows NT 6.1; WOW64; rv:27.0) Gecko/20100101 Firefox/27.0</stringProp>
-            </elementProp>
-            <elementProp name="Accept-Encoding" elementType="Header">
-              <stringProp name="Header.name">Accept-Encoding</stringProp>
-              <stringProp name="Header.value">gzip, deflate</stringProp>
+              <stringProp name="Header.value">*/*</stringProp>
             </elementProp>
           </collectionProp>
         </HeaderManager>
         <hashTree/>
-      </hashTree>
-      <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Customer Validate" enabled="true">
-        <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
-          <collectionProp name="Arguments.arguments">
-            <elementProp name="isAjax   " elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">true</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">isAjax   </stringProp>
-            </elementProp>
-            <elementProp name="customer[entity_id]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">${admin_customer_entity_id}</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">customer[entity_id]</stringProp>
-            </elementProp>
-            <elementProp name="customer[website_id]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">${admin_customer_website_id}</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">customer[website_id]</stringProp>
-            </elementProp>
-            <elementProp name="customer[email]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">${admin_customer_email}</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">customer[email]</stringProp>
-            </elementProp>
-            <elementProp name="customer[group_id]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">${admin_customer_group_id}</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">customer[group_id]</stringProp>
-            </elementProp>
-            <elementProp name="customer[store_id]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">${admin_customer_store_id}</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">customer[store_id]</stringProp>
-            </elementProp>
-            <elementProp name="customer[created_at]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">${admin_customer_created_at}</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">customer[created_at]</stringProp>
-            </elementProp>
-            <elementProp name="customer[updated_at]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">${admin_customer_updated_at}</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">customer[updated_at]</stringProp>
-            </elementProp>
-            <elementProp name="customer[is_active]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">${admin_customer_is_active}</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">customer[is_active]</stringProp>
-            </elementProp>
-            <elementProp name="customer[disable_auto_group_change]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">${admin_customer_disable_auto_group_change}</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">customer[disable_auto_group_change]</stringProp>
-            </elementProp>
-            <elementProp name="customer[created_in]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">${admin_customer_created_in}</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">customer[created_in]</stringProp>
-            </elementProp>
-            <elementProp name="customer[prefix]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">customer[prefix]</stringProp>
-            </elementProp>
-            <elementProp name="customer[firstname]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">${admin_customer_firstname} 1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">customer[firstname]</stringProp>
-            </elementProp>
-            <elementProp name="customer[middlename]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">customer[middlename]</stringProp>
-            </elementProp>
-            <elementProp name="customer[lastname]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">${admin_customer_lastname} 1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">customer[lastname]</stringProp>
-            </elementProp>
-            <elementProp name="customer[suffix]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">customer[suffix]</stringProp>
-            </elementProp>
-            <elementProp name="customer[dob]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">${admin_customer_dob}</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">customer[dob]</stringProp>
-            </elementProp>
-            <elementProp name="customer[default_billing]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">${admin_customer_default_billing}</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">customer[default_billing]</stringProp>
-            </elementProp>
-            <elementProp name="customer[default_shipping]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">${admin_customer_default_shipping}</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">customer[default_shipping]</stringProp>
-            </elementProp>
-            <elementProp name="customer[taxvat]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">customer[taxvat]</stringProp>
-            </elementProp>
-            <elementProp name="customer[gender]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">${admin_customer_gender}</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">customer[gender]</stringProp>
-            </elementProp>
-            <elementProp name="customer[failures_num]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">${admin_customer_failures_num}</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">customer[failures_num]</stringProp>
-            </elementProp>
-            <elementProp name="customer[sendemail_store_id]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">${admin_customer_store_id}</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">customer[sendemail_store_id]</stringProp>
-            </elementProp>
-            <elementProp name="address[${admin_customer_address_entity_id}][entity_id]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">${admin_customer_address_entity_id}</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">address[${admin_customer_address_entity_id}][entity_id]</stringProp>
-            </elementProp>
-            <elementProp name="address[${admin_customer_address_entity_id}][created_at]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">${admin_customer_address_created_at}</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">address[${admin_customer_address_entity_id}][created_at]</stringProp>
-            </elementProp>
-            <elementProp name="address[${admin_customer_address_entity_id}][updated_at]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">${admin_customer_address_updated_at}</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">address[${admin_customer_address_entity_id}][updated_at]</stringProp>
-            </elementProp>
-            <elementProp name="address[${admin_customer_address_entity_id}][is_active]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">${admin_customer_address_is_active}</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">address[${admin_customer_address_entity_id}][is_active]</stringProp>
-            </elementProp>
-            <elementProp name="address[${admin_customer_address_entity_id}][city]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">${admin_customer_address_city}</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">address[${admin_customer_address_entity_id}][city]</stringProp>
-            </elementProp>
-            <elementProp name="address[${admin_customer_address_entity_id}][company]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">address[${admin_customer_address_entity_id}][company]</stringProp>
-            </elementProp>
-            <elementProp name="address[${admin_customer_address_entity_id}][country_id]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">${admin_customer_address_country_id}</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">address[${admin_customer_address_entity_id}][country_id]</stringProp>
-            </elementProp>
-            <elementProp name="address[${admin_customer_address_entity_id}][firstname]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">${admin_customer_address_firstname}</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">address[${admin_customer_address_entity_id}][firstname]</stringProp>
-            </elementProp>
-            <elementProp name="address[${admin_customer_address_entity_id}][lastname]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">${admin_customer_address_lastname}</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">address[${admin_customer_address_entity_id}][lastname]</stringProp>
-            </elementProp>
-            <elementProp name="address[${admin_customer_address_entity_id}][middlename]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">address[${admin_customer_address_entity_id}][middlename]</stringProp>
-            </elementProp>
-            <elementProp name="address[${admin_customer_address_entity_id}][postcode]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">${admin_customer_address_postcode}</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">address[${admin_customer_address_entity_id}][postcode]</stringProp>
-            </elementProp>
-            <elementProp name="address[${admin_customer_address_entity_id}][prefix]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">address[${admin_customer_address_entity_id}][prefix]</stringProp>
-            </elementProp>
-            <elementProp name="address[${admin_customer_address_entity_id}][region]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">${admin_customer_address_region}</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">address[${admin_customer_address_entity_id}][region]</stringProp>
-            </elementProp>
-            <elementProp name="address[${admin_customer_address_entity_id}][region_id]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">${admin_customer_address_region_id}</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">address[${admin_customer_address_entity_id}][region_id]</stringProp>
-            </elementProp>
-            <elementProp name="address[${admin_customer_address_entity_id}][street][0]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">${admin_customer_address_street}</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">address[${admin_customer_address_entity_id}][street][0]</stringProp>
-            </elementProp>
-            <elementProp name="address[${admin_customer_address_entity_id}][street][1]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">address[${admin_customer_address_entity_id}][street][1]</stringProp>
-            </elementProp>
-            <elementProp name="address[${admin_customer_address_entity_id}][suffix]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">address[${admin_customer_address_entity_id}][suffix]</stringProp>
+        <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="SetUp - Admin Token Retrieval" enabled="true">
+          <boolProp name="HTTPSampler.postBodyRaw">true</boolProp>
+          <elementProp name="HTTPsampler.Arguments" elementType="Arguments">
+            <collectionProp name="Arguments.arguments">
+              <elementProp name="" elementType="HTTPArgument">
+                <boolProp name="HTTPArgument.always_encode">false</boolProp>
+                <stringProp name="Argument.value">{"username":"${admin_user}","password":"${admin_password}"}</stringProp>
+                <stringProp name="Argument.metadata">=</stringProp>
+              </elementProp>
+            </collectionProp>
+          </elementProp>
+          <stringProp name="HTTPSampler.domain"/>
+          <stringProp name="HTTPSampler.port"/>
+          <stringProp name="HTTPSampler.connect_timeout"/>
+          <stringProp name="HTTPSampler.response_timeout"/>
+          <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
+          <stringProp name="HTTPSampler.contentEncoding"/>
+          <stringProp name="HTTPSampler.path">${base_path}rest/V1/integration/admin/token</stringProp>
+          <stringProp name="HTTPSampler.method">POST</stringProp>
+          <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
+          <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
+          <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
+          <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
+          <boolProp name="HTTPSampler.monitor">false</boolProp>
+          <stringProp name="HTTPSampler.embedded_url_re"/>
+        </HTTPSamplerProxy>
+        <hashTree>
+          <com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor guiclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.gui.JSONPathExtractorGui" testclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor" testname="jp@gc - JSON Path Extractor" enabled="true">
+            <stringProp name="VAR">admin_token</stringProp>
+            <stringProp name="JSONPATH">$</stringProp>
+            <stringProp name="DEFAULT"/>
+            <stringProp name="VARIABLE"/>
+            <stringProp name="SUBJECT">BODY</stringProp>
+          </com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor>
+          <hashTree/>
+          <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert token not null" enabled="true">
+            <collectionProp name="Asserion.test_strings">
+              <stringProp name="484395188">^[a-z0-9-]+$</stringProp>
+            </collectionProp>
+            <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
+            <boolProp name="Assertion.assume_success">false</boolProp>
+            <intProp name="Assertion.test_type">1</intProp>
+            <stringProp name="Assertion.scope">variable</stringProp>
+            <stringProp name="Scope.variable">admin_token</stringProp>
+          </ResponseAssertion>
+          <hashTree/>
+        </hashTree>
+        <HeaderManager guiclass="HeaderPanel" testclass="HeaderManager" testname="HTTP Header Manager" enabled="true">
+          <collectionProp name="HeaderManager.headers">
+            <elementProp name="" elementType="Header">
+              <stringProp name="Header.name">Authorization</stringProp>
+              <stringProp name="Header.value">Bearer ${admin_token}</stringProp>
             </elementProp>
-            <elementProp name="address[${admin_customer_address_entity_id}][telephone]" elementType="HTTPArgument">
+          </collectionProp>
+        </HeaderManager>
+        <hashTree/>
+        <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="SetUp - Get Configurable Product Options" enabled="true">
+          <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
+            <collectionProp name="Arguments.arguments"/>
+          </elementProp>
+          <stringProp name="HTTPSampler.domain"/>
+          <stringProp name="HTTPSampler.port"/>
+          <stringProp name="HTTPSampler.connect_timeout"/>
+          <stringProp name="HTTPSampler.response_timeout"/>
+          <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
+          <stringProp name="HTTPSampler.contentEncoding"/>
+          <stringProp name="HTTPSampler.path">${base_path}rest/V1/configurable-products/${configurable_product_1_sku}/options/all</stringProp>
+          <stringProp name="HTTPSampler.method">GET</stringProp>
+          <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
+          <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
+          <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
+          <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
+          <boolProp name="HTTPSampler.monitor">false</boolProp>
+          <stringProp name="HTTPSampler.embedded_url_re"/>
+        </HTTPSamplerProxy>
+        <hashTree>
+          <com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor guiclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.gui.JSONPathExtractorGui" testclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor" testname="JSON Path Extractor: Extract attribute_ids" enabled="true">
+            <stringProp name="VAR">attribute_ids</stringProp>
+            <stringProp name="JSONPATH">$.[*].attribute_id</stringProp>
+            <stringProp name="DEFAULT">NO_VALUE</stringProp>
+            <stringProp name="VARIABLE"/>
+            <stringProp name="SUBJECT">BODY</stringProp>
+          </com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor>
+          <hashTree/>
+          <com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor guiclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.gui.JSONPathExtractorGui" testclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor" testname="JSON Path Extractor: Extract option_values" enabled="true">
+            <stringProp name="VAR">option_values</stringProp>
+            <stringProp name="JSONPATH">$.[*].values[0].value_index</stringProp>
+            <stringProp name="DEFAULT">NO_VALUE</stringProp>
+            <stringProp name="VARIABLE"/>
+            <stringProp name="SUBJECT">BODY</stringProp>
+          </com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor>
+          <hashTree/>
+        </hashTree>
+      </hashTree>
+      <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Add Products" enabled="true">
+        <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
+          <collectionProp name="Arguments.arguments">
+            <elementProp name="item[${simple_product_1_id}][qty]" elementType="HTTPArgument">
               <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">${admin_customer_address_telephone}</stringProp>
+              <stringProp name="Argument.name">item[${simple_product_1_id}][qty]</stringProp>
+              <stringProp name="Argument.value">1</stringProp>
               <stringProp name="Argument.metadata">=</stringProp>
               <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">address[${admin_customer_address_entity_id}][telephone]</stringProp>
             </elementProp>
-            <elementProp name="address[${admin_customer_address_entity_id}][vat_id]" elementType="HTTPArgument">
+            <elementProp name="item[${simple_product_2_id}][qty]" elementType="HTTPArgument">
               <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
+              <stringProp name="Argument.name">item[${simple_product_2_id}][qty]</stringProp>
+              <stringProp name="Argument.value">1</stringProp>
               <stringProp name="Argument.metadata">=</stringProp>
               <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">address[${admin_customer_address_entity_id}][vat_id]</stringProp>
             </elementProp>
-            <elementProp name="address[${admin_customer_address_entity_id}][customer_id]" elementType="HTTPArgument">
+            <elementProp name="item[${configurable_product_1_id}][qty]" elementType="HTTPArgument">
               <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">${admin_customer_address_customer_id}</stringProp>
+              <stringProp name="Argument.name">item[${configurable_product_1_id}][qty]</stringProp>
+              <stringProp name="Argument.value">1</stringProp>
               <stringProp name="Argument.metadata">=</stringProp>
               <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">address[${admin_customer_address_entity_id}][customer_id]</stringProp>
             </elementProp>
-            <elementProp name="address[${admin_customer_address_entity_id}][default_billing]" elementType="HTTPArgument">
+            <elementProp name="customer_id" elementType="HTTPArgument">
               <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">true</stringProp>
+              <stringProp name="Argument.name">customer_id</stringProp>
+              <stringProp name="Argument.value">${customer_id}</stringProp>
               <stringProp name="Argument.metadata">=</stringProp>
               <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">address[${admin_customer_address_entity_id}][default_billing]</stringProp>
             </elementProp>
-            <elementProp name="address[${admin_customer_address_entity_id}][default_shipping]" elementType="HTTPArgument">
+            <elementProp name="store_id" elementType="HTTPArgument">
               <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">true</stringProp>
+              <stringProp name="Argument.name">store_id</stringProp>
+              <stringProp name="Argument.value">1</stringProp>
               <stringProp name="Argument.metadata">=</stringProp>
               <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">address[${admin_customer_address_entity_id}][default_shipping]</stringProp>
             </elementProp>
-            <elementProp name="address[new_0][prefix]" elementType="HTTPArgument">
+            <elementProp name="currency_id" elementType="HTTPArgument">
               <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.name">currency_id</stringProp>
               <stringProp name="Argument.value"/>
               <stringProp name="Argument.metadata">=</stringProp>
               <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">address[new_0][prefix]</stringProp>
-            </elementProp>
-            <elementProp name="address[new_0][firstname]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">John</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">address[new_0][firstname]</stringProp>
             </elementProp>
-            <elementProp name="address[new_0][middlename]" elementType="HTTPArgument">
+            <elementProp name="form_key" elementType="HTTPArgument">
               <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
+              <stringProp name="Argument.name">form_key</stringProp>
+              <stringProp name="Argument.value">${admin_form_key}</stringProp>
               <stringProp name="Argument.metadata">=</stringProp>
               <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">address[new_0][middlename]</stringProp>
             </elementProp>
-            <elementProp name="address[new_0][lastname]" elementType="HTTPArgument">
+            <elementProp name="payment[method]" elementType="HTTPArgument">
               <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">Doe</stringProp>
+              <stringProp name="Argument.name">payment[method]</stringProp>
+              <stringProp name="Argument.value">checkmo</stringProp>
               <stringProp name="Argument.metadata">=</stringProp>
               <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">address[new_0][lastname]</stringProp>
             </elementProp>
-            <elementProp name="address[new_0][suffix]" elementType="HTTPArgument">
+            <elementProp name="reset_shipping" elementType="HTTPArgument">
               <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
+              <stringProp name="Argument.name">reset_shipping</stringProp>
+              <stringProp name="Argument.value">1</stringProp>
               <stringProp name="Argument.metadata">=</stringProp>
               <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">address[new_0][suffix]</stringProp>
             </elementProp>
-            <elementProp name="address[new_0][company]" elementType="HTTPArgument">
+            <elementProp name="json" elementType="HTTPArgument">
               <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">Test Company</stringProp>
+              <stringProp name="Argument.name">json</stringProp>
+              <stringProp name="Argument.value">1</stringProp>
               <stringProp name="Argument.metadata">=</stringProp>
               <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">address[new_0][company]</stringProp>
             </elementProp>
-            <elementProp name="address[new_0][city]" elementType="HTTPArgument">
+            <elementProp name="as_js_varname" elementType="HTTPArgument">
               <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">Folsom</stringProp>
+              <stringProp name="Argument.name">as_js_varname</stringProp>
+              <stringProp name="Argument.value">iFrameResponse</stringProp>
               <stringProp name="Argument.metadata">=</stringProp>
               <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">address[new_0][city]</stringProp>
             </elementProp>
-            <elementProp name="address[new_0][postcode]" elementType="HTTPArgument">
+            <elementProp name="form_key" elementType="HTTPArgument">
               <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">95630</stringProp>
+              <stringProp name="Argument.name">form_key</stringProp>
+              <stringProp name="Argument.value">${admin_form_key}</stringProp>
               <stringProp name="Argument.metadata">=</stringProp>
               <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">address[new_0][postcode]</stringProp>
             </elementProp>
-            <elementProp name="address[new_0][telephone]" elementType="HTTPArgument">
+          </collectionProp>
+        </elementProp>
+        <stringProp name="HTTPSampler.domain"/>
+        <stringProp name="HTTPSampler.port"/>
+        <stringProp name="HTTPSampler.connect_timeout"/>
+        <stringProp name="HTTPSampler.response_timeout"/>
+        <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
+        <stringProp name="HTTPSampler.contentEncoding"/>
+        <stringProp name="HTTPSampler.path">${base_path}${admin_path}/sales/order_create/loadBlock/block/search,items,shipping_method,totals,giftmessage,billing_method?isAjax=true</stringProp>
+        <stringProp name="HTTPSampler.method">POST</stringProp>
+        <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
+        <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
+        <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
+        <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
+        <boolProp name="HTTPSampler.monitor">false</boolProp>
+        <stringProp name="HTTPSampler.embedded_url_re"/>
+        <stringProp name="TestPlan.comments">Detected the start of a redirect chain</stringProp>
+      </HTTPSamplerProxy>
+      <hashTree>
+        <BeanShellPreProcessor guiclass="TestBeanGUI" testclass="BeanShellPreProcessor" testname="Configure product options" enabled="true">
+          <boolProp name="resetInterpreter">false</boolProp>
+          <stringProp name="parameters"/>
+          <stringProp name="filename"/>
+          <stringProp name="script">try {
+	attribute_ids = vars.get("attribute_ids");
+	option_values = vars.get("option_values");
+	attribute_ids = attribute_ids.replace("[","").replace("]","").replace("\"", "");
+	option_values = option_values.replace("[","").replace("]","").replace("\"", "");
+	attribute_ids_array = attribute_ids.split(",");
+	option_values_array = option_values.split(",");
+	args = ctx.getCurrentSampler().getArguments();
+	it = args.iterator();
+	while (it.hasNext()) {
+	    argument = it.next();
+	    if (argument.getStringValue().contains("${")) {
+	        args.removeArgument(argument.getName());
+	    }
+	}
+	for (int i = 0; i &lt; attribute_ids_array.length; i++) {
+
+    ctx.getCurrentSampler().addArgument("item[" + vars.get("configurable_product_1_id") + "][super_attribute][" + attribute_ids_array[i] + "]", option_values_array[i]);
+	}
+} catch (Exception e) {
+    log.error("error???", e);
+}</stringProp>
+        </BeanShellPreProcessor>
+        <hashTree/>
+      </hashTree>
+      <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Collect Shipping Rates" enabled="true">
+        <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
+          <collectionProp name="Arguments.arguments">
+            <elementProp name="collect_shipping_rates" elementType="HTTPArgument">
               <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1234567890</stringProp>
+              <stringProp name="Argument.name">collect_shipping_rates</stringProp>
+              <stringProp name="Argument.value">1</stringProp>
               <stringProp name="Argument.metadata">=</stringProp>
               <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">address[new_0][telephone]</stringProp>
             </elementProp>
-            <elementProp name="address[new_0][vat_id]" elementType="HTTPArgument">
+            <elementProp name="customer_id" elementType="HTTPArgument">
               <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
+              <stringProp name="Argument.name">customer_id</stringProp>
+              <stringProp name="Argument.value">${customer_id}</stringProp>
               <stringProp name="Argument.metadata">=</stringProp>
               <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">address[new_0][vat_id]</stringProp>
             </elementProp>
-            <elementProp name="address[new_0][default_billing]" elementType="HTTPArgument">
+            <elementProp name="store_id" elementType="HTTPArgument">
               <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">false</stringProp>
+              <stringProp name="Argument.name">store_id</stringProp>
+              <stringProp name="Argument.value">1</stringProp>
               <stringProp name="Argument.metadata">=</stringProp>
               <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">address[new_0][default_billing]</stringProp>
             </elementProp>
-            <elementProp name="address[new_0][default_shipping]" elementType="HTTPArgument">
+            <elementProp name="currency_id" elementType="HTTPArgument">
               <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.name">currency_id</stringProp>
               <stringProp name="Argument.value">false</stringProp>
               <stringProp name="Argument.metadata">=</stringProp>
               <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">address[new_0][default_shipping]</stringProp>
-            </elementProp>
-            <elementProp name="address[new_0][street][0]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">123 Main</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">address[new_0][street][0]</stringProp>
-            </elementProp>
-            <elementProp name="address[new_0][street][1]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">address[new_0][street][1]</stringProp>
-            </elementProp>
-            <elementProp name="address[new_0][region]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">address[new_0][region]</stringProp>
             </elementProp>
-            <elementProp name="address[new_0][country_id]" elementType="HTTPArgument">
+            <elementProp name="form_key" elementType="HTTPArgument">
               <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">US</stringProp>
+              <stringProp name="Argument.name">form_key</stringProp>
+              <stringProp name="Argument.value">${admin_form_key}</stringProp>
               <stringProp name="Argument.metadata">=</stringProp>
               <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">address[new_0][country_id]</stringProp>
             </elementProp>
-            <elementProp name="address[new_0][region_id]" elementType="HTTPArgument">
+            <elementProp name="payment[method]" elementType="HTTPArgument">
               <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">12</stringProp>
+              <stringProp name="Argument.name">payment[method]</stringProp>
+              <stringProp name="Argument.value">checkmo</stringProp>
               <stringProp name="Argument.metadata">=</stringProp>
               <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">address[new_0][region_id]</stringProp>
             </elementProp>
-            <elementProp name="form_key" elementType="HTTPArgument">
+            <elementProp name="json" elementType="HTTPArgument">
               <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">${admin_form_key}</stringProp>
+              <stringProp name="Argument.name">json</stringProp>
+              <stringProp name="Argument.value">true</stringProp>
               <stringProp name="Argument.metadata">=</stringProp>
               <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">form_key</stringProp>
             </elementProp>
           </collectionProp>
         </elementProp>
@@ -24420,7 +14686,7 @@ if (testLabel
         <stringProp name="HTTPSampler.response_timeout"/>
         <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
         <stringProp name="HTTPSampler.contentEncoding"/>
-        <stringProp name="HTTPSampler.path">${base_path}${admin_path}/customer/index/validate/</stringProp>
+        <stringProp name="HTTPSampler.path">${base_path}${admin_path}/sales/order_create/loadBlock/block/shipping_method,totals?isAjax=true</stringProp>
         <stringProp name="HTTPSampler.method">POST</stringProp>
         <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
         <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
@@ -24430,460 +14696,569 @@ if (testLabel
         <stringProp name="HTTPSampler.embedded_url_re"/>
       </HTTPSamplerProxy>
       <hashTree>
-        <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Response Assertion" enabled="true">
+        <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert Shipping Method" enabled="true">
           <collectionProp name="Asserion.test_strings">
-            <stringProp name="49586">200</stringProp>
+            <stringProp name="-1987784558">shipping_method</stringProp>
+            <stringProp name="818779431">Flat Rate</stringProp>
           </collectionProp>
-          <stringProp name="Assertion.test_field">Assertion.response_code</stringProp>
+          <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
           <boolProp name="Assertion.assume_success">false</boolProp>
-          <intProp name="Assertion.test_type">16</intProp>
+          <intProp name="Assertion.test_type">2</intProp>
         </ResponseAssertion>
         <hashTree/>
       </hashTree>
-      <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Customer Save" enabled="true">
+      <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Save Order" enabled="true">
         <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
           <collectionProp name="Arguments.arguments">
-            <elementProp name="isAjax   " elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">true</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">isAjax   </stringProp>
-            </elementProp>
-            <elementProp name="customer[entity_id]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">${admin_customer_entity_id}</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">customer[entity_id]</stringProp>
-            </elementProp>
-            <elementProp name="customer[website_id]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">${admin_customer_website_id}</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">customer[website_id]</stringProp>
-            </elementProp>
-            <elementProp name="customer[email]" elementType="HTTPArgument">
+            <elementProp name="form_key" elementType="HTTPArgument">
               <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">${admin_customer_email}</stringProp>
+              <stringProp name="Argument.name">form_key</stringProp>
+              <stringProp name="Argument.value">${admin_form_key}</stringProp>
               <stringProp name="Argument.metadata">=</stringProp>
               <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">customer[email]</stringProp>
             </elementProp>
-            <elementProp name="customer[group_id]" elementType="HTTPArgument">
+            <elementProp name="limit" elementType="HTTPArgument">
               <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">${admin_customer_group_id}</stringProp>
+              <stringProp name="Argument.name">limit</stringProp>
+              <stringProp name="Argument.value">20</stringProp>
               <stringProp name="Argument.metadata">=</stringProp>
               <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">customer[group_id]</stringProp>
             </elementProp>
-            <elementProp name="customer[store_id]" elementType="HTTPArgument">
+            <elementProp name="entity_id" elementType="HTTPArgument">
               <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">${admin_customer_store_id}</stringProp>
+              <stringProp name="Argument.name">entity_id</stringProp>
+              <stringProp name="Argument.value"/>
               <stringProp name="Argument.metadata">=</stringProp>
               <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">customer[store_id]</stringProp>
             </elementProp>
-            <elementProp name="customer[created_at]" elementType="HTTPArgument">
+            <elementProp name="name" elementType="HTTPArgument">
               <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">${admin_customer_created_at}</stringProp>
+              <stringProp name="Argument.name">name</stringProp>
+              <stringProp name="Argument.value"/>
               <stringProp name="Argument.metadata">=</stringProp>
               <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">customer[created_at]</stringProp>
             </elementProp>
-            <elementProp name="customer[updated_at]" elementType="HTTPArgument">
+            <elementProp name="email" elementType="HTTPArgument">
               <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">${admin_customer_updated_at}</stringProp>
+              <stringProp name="Argument.name">email</stringProp>
+              <stringProp name="Argument.value"/>
               <stringProp name="Argument.metadata">=</stringProp>
               <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">customer[updated_at]</stringProp>
             </elementProp>
-            <elementProp name="customer[is_active]" elementType="HTTPArgument">
+            <elementProp name="Telephone" elementType="HTTPArgument">
               <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">${admin_customer_is_active}</stringProp>
+              <stringProp name="Argument.name">Telephone</stringProp>
+              <stringProp name="Argument.value"/>
               <stringProp name="Argument.metadata">=</stringProp>
               <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">customer[is_active]</stringProp>
             </elementProp>
-            <elementProp name="customer[disable_auto_group_change]" elementType="HTTPArgument">
+            <elementProp name="billing_postcode" elementType="HTTPArgument">
               <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">${admin_customer_disable_auto_group_change}</stringProp>
+              <stringProp name="Argument.name">billing_postcode</stringProp>
+              <stringProp name="Argument.value"/>
               <stringProp name="Argument.metadata">=</stringProp>
               <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">customer[disable_auto_group_change]</stringProp>
             </elementProp>
-            <elementProp name="customer[created_in]" elementType="HTTPArgument">
+            <elementProp name="billing_country_id" elementType="HTTPArgument">
               <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">${admin_customer_created_in}</stringProp>
+              <stringProp name="Argument.name">billing_country_id</stringProp>
+              <stringProp name="Argument.value"/>
               <stringProp name="Argument.metadata">=</stringProp>
               <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">customer[created_in]</stringProp>
             </elementProp>
-            <elementProp name="customer[prefix]" elementType="HTTPArgument">
+            <elementProp name="billing_regione" elementType="HTTPArgument">
               <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.name">billing_regione</stringProp>
               <stringProp name="Argument.value"/>
               <stringProp name="Argument.metadata">=</stringProp>
               <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">customer[prefix]</stringProp>
             </elementProp>
-            <elementProp name="customer[firstname]" elementType="HTTPArgument">
+            <elementProp name="store_name" elementType="HTTPArgument">
               <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">${admin_customer_firstname} 1</stringProp>
+              <stringProp name="Argument.name">store_name</stringProp>
+              <stringProp name="Argument.value"/>
               <stringProp name="Argument.metadata">=</stringProp>
               <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">customer[firstname]</stringProp>
             </elementProp>
-            <elementProp name="customer[middlename]" elementType="HTTPArgument">
+            <elementProp name="page" elementType="HTTPArgument">
               <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
+              <stringProp name="Argument.name">page</stringProp>
+              <stringProp name="Argument.value">1</stringProp>
               <stringProp name="Argument.metadata">=</stringProp>
               <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">customer[middlename]</stringProp>
             </elementProp>
-            <elementProp name="customer[lastname]" elementType="HTTPArgument">
+            <elementProp name="order[currency]" elementType="HTTPArgument">
               <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">${admin_customer_lastname} 1</stringProp>
+              <stringProp name="Argument.name">order[currency]</stringProp>
+              <stringProp name="Argument.value">USD</stringProp>
               <stringProp name="Argument.metadata">=</stringProp>
               <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">customer[lastname]</stringProp>
             </elementProp>
-            <elementProp name="customer[suffix]" elementType="HTTPArgument">
+            <elementProp name="sku" elementType="HTTPArgument">
               <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.name">sku</stringProp>
               <stringProp name="Argument.value"/>
               <stringProp name="Argument.metadata">=</stringProp>
               <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">customer[suffix]</stringProp>
             </elementProp>
-            <elementProp name="customer[dob]" elementType="HTTPArgument">
+            <elementProp name="qty" elementType="HTTPArgument">
               <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">${admin_customer_dob}</stringProp>
+              <stringProp name="Argument.name">qty</stringProp>
+              <stringProp name="Argument.value"/>
               <stringProp name="Argument.metadata">=</stringProp>
               <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">customer[dob]</stringProp>
             </elementProp>
-            <elementProp name="customer[default_billing]" elementType="HTTPArgument">
+            <elementProp name="limit" elementType="HTTPArgument">
               <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">${admin_customer_default_billing}</stringProp>
+              <stringProp name="Argument.name">limit</stringProp>
+              <stringProp name="Argument.value">20</stringProp>
               <stringProp name="Argument.metadata">=</stringProp>
               <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">customer[default_billing]</stringProp>
             </elementProp>
-            <elementProp name="customer[default_shipping]" elementType="HTTPArgument">
+            <elementProp name="entity_id" elementType="HTTPArgument">
               <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">${admin_customer_default_shipping}</stringProp>
+              <stringProp name="Argument.name">entity_id</stringProp>
+              <stringProp name="Argument.value"/>
               <stringProp name="Argument.metadata">=</stringProp>
               <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">customer[default_shipping]</stringProp>
             </elementProp>
-            <elementProp name="customer[taxvat]" elementType="HTTPArgument">
+            <elementProp name="name" elementType="HTTPArgument">
               <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.name">name</stringProp>
               <stringProp name="Argument.value"/>
               <stringProp name="Argument.metadata">=</stringProp>
               <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">customer[taxvat]</stringProp>
             </elementProp>
-            <elementProp name="customer[gender]" elementType="HTTPArgument">
+            <elementProp name="sku" elementType="HTTPArgument">
               <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">${admin_customer_gender}</stringProp>
+              <stringProp name="Argument.name">sku</stringProp>
+              <stringProp name="Argument.value"/>
               <stringProp name="Argument.metadata">=</stringProp>
               <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">customer[gender]</stringProp>
             </elementProp>
-            <elementProp name="customer[failures_num]" elementType="HTTPArgument">
+            <elementProp name="price[from]" elementType="HTTPArgument">
               <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">${admin_customer_failures_num}</stringProp>
+              <stringProp name="Argument.name">price[from]</stringProp>
+              <stringProp name="Argument.value"/>
               <stringProp name="Argument.metadata">=</stringProp>
               <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">customer[failures_num]</stringProp>
             </elementProp>
-            <elementProp name="customer[sendemail_store_id]" elementType="HTTPArgument">
+            <elementProp name="price[to]" elementType="HTTPArgument">
               <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">${admin_customer_store_id}</stringProp>
+              <stringProp name="Argument.name">price[to]</stringProp>
+              <stringProp name="Argument.value"/>
               <stringProp name="Argument.metadata">=</stringProp>
               <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">customer[sendemail_store_id]</stringProp>
             </elementProp>
-            <elementProp name="address[${admin_customer_address_entity_id}][entity_id]" elementType="HTTPArgument">
+            <elementProp name="in_products" elementType="HTTPArgument">
               <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">${admin_customer_address_entity_id}</stringProp>
+              <stringProp name="Argument.name">in_products</stringProp>
+              <stringProp name="Argument.value"/>
               <stringProp name="Argument.metadata">=</stringProp>
               <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">address[${admin_customer_address_entity_id}][entity_id]</stringProp>
             </elementProp>
-
-            <elementProp name="address[${admin_customer_address_entity_id}][created_at]" elementType="HTTPArgument">
+            <elementProp name="page" elementType="HTTPArgument">
               <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">${admin_customer_address_created_at}</stringProp>
+              <stringProp name="Argument.name">page</stringProp>
+              <stringProp name="Argument.value">1</stringProp>
               <stringProp name="Argument.metadata">=</stringProp>
               <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">address[${admin_customer_address_entity_id}][created_at]</stringProp>
             </elementProp>
-            <elementProp name="address[${admin_customer_address_entity_id}][updated_at]" elementType="HTTPArgument">
+            <elementProp name="coupon_code" elementType="HTTPArgument">
               <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">${admin_customer_address_updated_at}</stringProp>
+              <stringProp name="Argument.name">coupon_code</stringProp>
+              <stringProp name="Argument.value"/>
               <stringProp name="Argument.metadata">=</stringProp>
               <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">address[${admin_customer_address_entity_id}][updated_at]</stringProp>
             </elementProp>
-            <elementProp name="address[${admin_customer_address_entity_id}][is_active]" elementType="HTTPArgument">
+            <elementProp name="order[account][group_id]" elementType="HTTPArgument">
               <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">${admin_customer_address_is_active}</stringProp>
+              <stringProp name="Argument.name">order[account][group_id]</stringProp>
+              <stringProp name="Argument.value">1</stringProp>
               <stringProp name="Argument.metadata">=</stringProp>
               <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">address[${admin_customer_address_entity_id}][is_active]</stringProp>
             </elementProp>
-            <elementProp name="address[${admin_customer_address_entity_id}][city]" elementType="HTTPArgument">
+            <elementProp name="order[account][email]" elementType="HTTPArgument">
               <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">${admin_customer_address_city}</stringProp>
+              <stringProp name="Argument.name">order[account][email]</stringProp>
+              <stringProp name="Argument.value">user_${customer_id}@example.com</stringProp>
               <stringProp name="Argument.metadata">=</stringProp>
               <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">address[${admin_customer_address_entity_id}][city]</stringProp>
             </elementProp>
-            <elementProp name="address[${admin_customer_address_entity_id}][company]" elementType="HTTPArgument">
+            <elementProp name="order[billing_address][customer_address_id]" elementType="HTTPArgument">
               <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.name">order[billing_address][customer_address_id]</stringProp>
               <stringProp name="Argument.value"/>
               <stringProp name="Argument.metadata">=</stringProp>
               <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">address[${admin_customer_address_entity_id}][company]</stringProp>
-            </elementProp>
-            <elementProp name="address[${admin_customer_address_entity_id}][country_id]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">${admin_customer_address_country_id}</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">address[${admin_customer_address_entity_id}][country_id]</stringProp>
             </elementProp>
-            <elementProp name="address[${admin_customer_address_entity_id}][firstname]" elementType="HTTPArgument">
+            <elementProp name="order[billing_address][prefix]" elementType="HTTPArgument">
               <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">${admin_customer_address_firstname}</stringProp>
+              <stringProp name="Argument.name">order[billing_address][prefix]</stringProp>
+              <stringProp name="Argument.value"/>
               <stringProp name="Argument.metadata">=</stringProp>
               <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">address[${admin_customer_address_entity_id}][firstname]</stringProp>
             </elementProp>
-            <elementProp name="address[${admin_customer_address_entity_id}][lastname]" elementType="HTTPArgument">
+            <elementProp name="order[billing_address][firstname]" elementType="HTTPArgument">
               <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">${admin_customer_address_lastname}</stringProp>
+              <stringProp name="Argument.name">order[billing_address][firstname]</stringProp>
+              <stringProp name="Argument.value">Anthony</stringProp>
               <stringProp name="Argument.metadata">=</stringProp>
               <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">address[${admin_customer_address_entity_id}][lastname]</stringProp>
             </elementProp>
-            <elementProp name="address[${admin_customer_address_entity_id}][middlename]" elementType="HTTPArgument">
+            <elementProp name="order[billing_address][middlename]" elementType="HTTPArgument">
               <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.name">order[billing_address][middlename]</stringProp>
               <stringProp name="Argument.value"/>
               <stringProp name="Argument.metadata">=</stringProp>
               <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">address[${admin_customer_address_entity_id}][middlename]</stringProp>
             </elementProp>
-            <elementProp name="address[${admin_customer_address_entity_id}][postcode]" elementType="HTTPArgument">
+            <elementProp name="order[billing_address][lastname]" elementType="HTTPArgument">
               <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">${admin_customer_address_postcode}</stringProp>
+              <stringProp name="Argument.name">order[billing_address][lastname]</stringProp>
+              <stringProp name="Argument.value">Nealy</stringProp>
               <stringProp name="Argument.metadata">=</stringProp>
               <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">address[${admin_customer_address_entity_id}][postcode]</stringProp>
             </elementProp>
-            <elementProp name="address[${admin_customer_address_entity_id}][prefix]" elementType="HTTPArgument">
+            <elementProp name="order[billing_address][suffix]" elementType="HTTPArgument">
               <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.name">order[billing_address][suffix]</stringProp>
               <stringProp name="Argument.value"/>
               <stringProp name="Argument.metadata">=</stringProp>
               <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">address[${admin_customer_address_entity_id}][prefix]</stringProp>
-            </elementProp>
-            <elementProp name="address[${admin_customer_address_entity_id}][region]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">${admin_customer_address_region}</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">address[${admin_customer_address_entity_id}][region]</stringProp>
             </elementProp>
-            <elementProp name="address[${admin_customer_address_entity_id}][region_id]" elementType="HTTPArgument">
+            <elementProp name="order[billing_address][company]" elementType="HTTPArgument">
               <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">${admin_customer_address_region_id}</stringProp>
+              <stringProp name="Argument.name">order[billing_address][company]</stringProp>
+              <stringProp name="Argument.value"/>
               <stringProp name="Argument.metadata">=</stringProp>
               <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">address[${admin_customer_address_entity_id}][region_id]</stringProp>
             </elementProp>
-            <elementProp name="address[${admin_customer_address_entity_id}][street][0]" elementType="HTTPArgument">
+            <elementProp name="order[billing_address][street][0]" elementType="HTTPArgument">
               <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">${admin_customer_address_street}</stringProp>
+              <stringProp name="Argument.name">order[billing_address][street][0]</stringProp>
+              <stringProp name="Argument.value">123 Freedom Blvd. #123</stringProp>
               <stringProp name="Argument.metadata">=</stringProp>
               <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">address[${admin_customer_address_entity_id}][street][0]</stringProp>
             </elementProp>
-            <elementProp name="address[${admin_customer_address_entity_id}][street][1]" elementType="HTTPArgument">
+            <elementProp name="order[billing_address][street][1]" elementType="HTTPArgument">
               <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.name">order[billing_address][street][1]</stringProp>
               <stringProp name="Argument.value"/>
               <stringProp name="Argument.metadata">=</stringProp>
               <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">address[${admin_customer_address_entity_id}][street][1]</stringProp>
             </elementProp>
-            <elementProp name="address[${admin_customer_address_entity_id}][suffix]" elementType="HTTPArgument">
+            <elementProp name="order[billing_address][city]" elementType="HTTPArgument">
               <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
+              <stringProp name="Argument.name">order[billing_address][city]</stringProp>
+              <stringProp name="Argument.value">Fayetteville</stringProp>
               <stringProp name="Argument.metadata">=</stringProp>
               <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">address[${admin_customer_address_entity_id}][suffix]</stringProp>
             </elementProp>
-            <elementProp name="address[${admin_customer_address_entity_id}][telephone]" elementType="HTTPArgument">
+            <elementProp name="order[billing_address][country_id]" elementType="HTTPArgument">
               <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">${admin_customer_address_telephone}</stringProp>
+              <stringProp name="Argument.name">order[billing_address][country_id]</stringProp>
+              <stringProp name="Argument.value">US</stringProp>
               <stringProp name="Argument.metadata">=</stringProp>
               <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">address[${admin_customer_address_entity_id}][telephone]</stringProp>
             </elementProp>
-            <elementProp name="address[${admin_customer_address_entity_id}][vat_id]" elementType="HTTPArgument">
+            <elementProp name="order[billing_address][region]" elementType="HTTPArgument">
               <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.name">order[billing_address][region]</stringProp>
               <stringProp name="Argument.value"/>
               <stringProp name="Argument.metadata">=</stringProp>
               <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">address[${admin_customer_address_entity_id}][vat_id]</stringProp>
             </elementProp>
-            <elementProp name="address[${admin_customer_address_entity_id}][customer_id]" elementType="HTTPArgument">
+            <elementProp name="order[billing_address][region_id]" elementType="HTTPArgument">
               <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">${admin_customer_address_customer_id}</stringProp>
+              <stringProp name="Argument.name">order[billing_address][region_id]</stringProp>
+              <stringProp name="Argument.value">5</stringProp>
               <stringProp name="Argument.metadata">=</stringProp>
               <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">address[${admin_customer_address_entity_id}][customer_id]</stringProp>
             </elementProp>
-            <elementProp name="address[${admin_customer_address_entity_id}][default_billing]" elementType="HTTPArgument">
+            <elementProp name="order[billing_address][postcode]" elementType="HTTPArgument">
               <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">true</stringProp>
+              <stringProp name="Argument.name">order[billing_address][postcode]</stringProp>
+              <stringProp name="Argument.value">123123</stringProp>
               <stringProp name="Argument.metadata">=</stringProp>
               <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">address[${admin_customer_address_entity_id}][default_billing]</stringProp>
             </elementProp>
-            <elementProp name="address[${admin_customer_address_entity_id}][default_shipping]" elementType="HTTPArgument">
+            <elementProp name="order[billing_address][telephone]" elementType="HTTPArgument">
               <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">true</stringProp>
+              <stringProp name="Argument.name">order[billing_address][telephone]</stringProp>
+              <stringProp name="Argument.value">022-333-4455</stringProp>
               <stringProp name="Argument.metadata">=</stringProp>
               <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">address[${admin_customer_address_entity_id}][default_shipping]</stringProp>
             </elementProp>
-            <elementProp name="address[new_0][prefix]" elementType="HTTPArgument">
+            <elementProp name="order[billing_address][fax]" elementType="HTTPArgument">
               <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.name">order[billing_address][fax]</stringProp>
               <stringProp name="Argument.value"/>
               <stringProp name="Argument.metadata">=</stringProp>
               <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">address[new_0][prefix]</stringProp>
             </elementProp>
-            <elementProp name="address[new_0][firstname]" elementType="HTTPArgument">
+            <elementProp name="order[billing_address][vat_id]" elementType="HTTPArgument">
               <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">John</stringProp>
+              <stringProp name="Argument.name">order[billing_address][vat_id]</stringProp>
+              <stringProp name="Argument.value"/>
               <stringProp name="Argument.metadata">=</stringProp>
               <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">address[new_0][firstname]</stringProp>
             </elementProp>
-            <elementProp name="address[new_0][middlename]" elementType="HTTPArgument">
+            <elementProp name="shipping_same_as_billing" elementType="HTTPArgument">
               <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
+              <stringProp name="Argument.name">shipping_same_as_billing</stringProp>
+              <stringProp name="Argument.value">on</stringProp>
               <stringProp name="Argument.metadata">=</stringProp>
               <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">address[new_0][middlename]</stringProp>
             </elementProp>
-            <elementProp name="address[new_0][lastname]" elementType="HTTPArgument">
+            <elementProp name="payment[method]" elementType="HTTPArgument">
               <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">Doe</stringProp>
+              <stringProp name="Argument.name">payment[method]</stringProp>
+              <stringProp name="Argument.value">checkmo</stringProp>
               <stringProp name="Argument.metadata">=</stringProp>
               <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">address[new_0][lastname]</stringProp>
             </elementProp>
-            <elementProp name="address[new_0][suffix]" elementType="HTTPArgument">
+            <elementProp name="order[shipping_method]" elementType="HTTPArgument">
               <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
+              <stringProp name="Argument.name">order[shipping_method]</stringProp>
+              <stringProp name="Argument.value">flatrate_flatrate</stringProp>
               <stringProp name="Argument.metadata">=</stringProp>
               <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">address[new_0][suffix]</stringProp>
             </elementProp>
-            <elementProp name="address[new_0][company]" elementType="HTTPArgument">
+            <elementProp name="order[comment][customer_note]" elementType="HTTPArgument">
               <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">Test Company</stringProp>
+              <stringProp name="Argument.name">order[comment][customer_note]</stringProp>
+              <stringProp name="Argument.value"/>
               <stringProp name="Argument.metadata">=</stringProp>
               <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">address[new_0][company]</stringProp>
             </elementProp>
-            <elementProp name="address[new_0][city]" elementType="HTTPArgument">
+            <elementProp name="order[comment][customer_note_notify]" elementType="HTTPArgument">
               <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">Folsom</stringProp>
+              <stringProp name="Argument.name">order[comment][customer_note_notify]</stringProp>
+              <stringProp name="Argument.value">1</stringProp>
               <stringProp name="Argument.metadata">=</stringProp>
               <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">address[new_0][city]</stringProp>
             </elementProp>
-            <elementProp name="address[new_0][postcode]" elementType="HTTPArgument">
+            <elementProp name="order[send_confirmation]" elementType="HTTPArgument">
               <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">95630</stringProp>
+              <stringProp name="Argument.name">order[send_confirmation]</stringProp>
+              <stringProp name="Argument.value">1</stringProp>
               <stringProp name="Argument.metadata">=</stringProp>
               <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">address[new_0][postcode]</stringProp>
             </elementProp>
-            <elementProp name="address[new_0][telephone]" elementType="HTTPArgument">
+          </collectionProp>
+        </elementProp>
+        <stringProp name="HTTPSampler.domain"/>
+        <stringProp name="HTTPSampler.port"/>
+        <stringProp name="HTTPSampler.connect_timeout"/>
+        <stringProp name="HTTPSampler.response_timeout"/>
+        <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
+        <stringProp name="HTTPSampler.contentEncoding"/>
+        <stringProp name="HTTPSampler.path">${base_path}${admin_path}/sales/order_create/save/</stringProp>
+        <stringProp name="HTTPSampler.method">POST</stringProp>
+        <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
+        <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
+        <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
+        <boolProp name="HTTPSampler.DO_MULTIPART_POST">true</boolProp>
+        <boolProp name="HTTPSampler.monitor">false</boolProp>
+        <stringProp name="HTTPSampler.embedded_url_re"/>
+        <stringProp name="TestPlan.comments">Detected the start of a redirect chain</stringProp>
+      </HTTPSamplerProxy>
+      <hashTree>
+        <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract Order Id" enabled="true">
+          <stringProp name="RegexExtractor.useHeaders">false</stringProp>
+          <stringProp name="RegexExtractor.refname">order_id</stringProp>
+          <stringProp name="RegexExtractor.regex">${host}${base_path}${admin_path}/sales/order/index/order_id/(\d+)/</stringProp>
+          <stringProp name="RegexExtractor.template">$1$</stringProp>
+          <stringProp name="RegexExtractor.default"/>
+          <stringProp name="RegexExtractor.match_number">1</stringProp>
+        </RegexExtractor>
+        <hashTree/>
+        <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract Order Item 1" enabled="true">
+          <stringProp name="RegexExtractor.useHeaders">false</stringProp>
+          <stringProp name="RegexExtractor.refname">order_item_1</stringProp>
+          <stringProp name="RegexExtractor.regex">order_item_(\d+)_title</stringProp>
+          <stringProp name="RegexExtractor.template">$1$</stringProp>
+          <stringProp name="RegexExtractor.default"/>
+          <stringProp name="RegexExtractor.match_number">1</stringProp>
+        </RegexExtractor>
+        <hashTree/>
+        <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract Order Item 2" enabled="true">
+          <stringProp name="RegexExtractor.useHeaders">false</stringProp>
+          <stringProp name="RegexExtractor.refname">order_item_2</stringProp>
+          <stringProp name="RegexExtractor.regex">order_item_(\d+)_title</stringProp>
+          <stringProp name="RegexExtractor.template">$1$</stringProp>
+          <stringProp name="RegexExtractor.default"/>
+          <stringProp name="RegexExtractor.match_number">2</stringProp>
+        </RegexExtractor>
+        <hashTree/>
+        <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract Order Item 3" enabled="true">
+          <stringProp name="RegexExtractor.useHeaders">false</stringProp>
+          <stringProp name="RegexExtractor.refname">order_item_3</stringProp>
+          <stringProp name="RegexExtractor.regex">order_item_(\d+)_title</stringProp>
+          <stringProp name="RegexExtractor.template">$1$</stringProp>
+          <stringProp name="RegexExtractor.default"/>
+          <stringProp name="RegexExtractor.match_number">3</stringProp>
+        </RegexExtractor>
+        <hashTree/>
+        <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert Order Id" enabled="true">
+          <collectionProp name="Asserion.test_strings">
+            <stringProp name="89649215">^\d+$</stringProp>
+          </collectionProp>
+          <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
+          <boolProp name="Assertion.assume_success">false</boolProp>
+          <intProp name="Assertion.test_type">1</intProp>
+          <stringProp name="Assertion.scope">variable</stringProp>
+          <stringProp name="Scope.variable">order_id</stringProp>
+        </ResponseAssertion>
+        <hashTree/>
+        <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert Order Item 1" enabled="true">
+          <collectionProp name="Asserion.test_strings">
+            <stringProp name="89649215">^\d+$</stringProp>
+          </collectionProp>
+          <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
+          <boolProp name="Assertion.assume_success">false</boolProp>
+          <intProp name="Assertion.test_type">1</intProp>
+          <stringProp name="Assertion.scope">variable</stringProp>
+          <stringProp name="Scope.variable">order_item_1</stringProp>
+        </ResponseAssertion>
+        <hashTree/>
+        <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert Order Item 2" enabled="true">
+          <collectionProp name="Asserion.test_strings">
+            <stringProp name="89649215">^\d+$</stringProp>
+          </collectionProp>
+          <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
+          <boolProp name="Assertion.assume_success">false</boolProp>
+          <intProp name="Assertion.test_type">1</intProp>
+          <stringProp name="Assertion.scope">variable</stringProp>
+          <stringProp name="Scope.variable">order_item_2</stringProp>
+        </ResponseAssertion>
+        <hashTree/>
+        <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert Order Item 3" enabled="true">
+          <collectionProp name="Asserion.test_strings">
+            <stringProp name="89649215">^\d+$</stringProp>
+          </collectionProp>
+          <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
+          <boolProp name="Assertion.assume_success">false</boolProp>
+          <intProp name="Assertion.test_type">1</intProp>
+          <stringProp name="Assertion.scope">variable</stringProp>
+          <stringProp name="Scope.variable">order_item_3</stringProp>
+        </ResponseAssertion>
+        <hashTree/>
+        <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert Order Created" enabled="true">
+          <collectionProp name="Asserion.test_strings">
+            <stringProp name="563107624">You created the order.</stringProp>
+          </collectionProp>
+          <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
+          <boolProp name="Assertion.assume_success">false</boolProp>
+          <intProp name="Assertion.test_type">2</intProp>
+        </ResponseAssertion>
+        <hashTree/>
+      </hashTree>
+      <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Save Invoice" enabled="true">
+        <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
+          <collectionProp name="Arguments.arguments">
+            <elementProp name="form_key" elementType="HTTPArgument">
               <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1234567890</stringProp>
+              <stringProp name="Argument.name">form_key</stringProp>
+              <stringProp name="Argument.value">${admin_form_key}</stringProp>
               <stringProp name="Argument.metadata">=</stringProp>
               <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">address[new_0][telephone]</stringProp>
             </elementProp>
-            <elementProp name="address[new_0][vat_id]" elementType="HTTPArgument">
+            <elementProp name="invoice[items][${order_item_1}]" elementType="HTTPArgument">
               <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
+              <stringProp name="Argument.name">invoice[items][${order_item_1}]</stringProp>
+              <stringProp name="Argument.value">1</stringProp>
               <stringProp name="Argument.metadata">=</stringProp>
               <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">address[new_0][vat_id]</stringProp>
             </elementProp>
-            <elementProp name="address[new_0][default_billing]" elementType="HTTPArgument">
+            <elementProp name="invoice[items][${order_item_2}]" elementType="HTTPArgument">
               <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">false</stringProp>
+              <stringProp name="Argument.name">invoice[items][${order_item_2}]</stringProp>
+              <stringProp name="Argument.value">1</stringProp>
               <stringProp name="Argument.metadata">=</stringProp>
               <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">address[new_0][default_billing]</stringProp>
             </elementProp>
-            <elementProp name="address[new_0][default_shipping]" elementType="HTTPArgument">
+            <elementProp name="invoice[items][${order_item_3}]" elementType="HTTPArgument">
               <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">false</stringProp>
+              <stringProp name="Argument.name">invoice[items][${order_item_3}]</stringProp>
+              <stringProp name="Argument.value">1</stringProp>
               <stringProp name="Argument.metadata">=</stringProp>
               <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">address[new_0][default_shipping]</stringProp>
             </elementProp>
-            <elementProp name="address[new_0][street][0]" elementType="HTTPArgument">
+            <elementProp name="invoice[comment_text]" elementType="HTTPArgument">
               <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">123 Main</stringProp>
+              <stringProp name="Argument.name">invoice[comment_text]</stringProp>
+              <stringProp name="Argument.value"/>
               <stringProp name="Argument.metadata">=</stringProp>
               <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">address[new_0][street][0]</stringProp>
             </elementProp>
-            <elementProp name="address[new_0][street][1]" elementType="HTTPArgument">
+          </collectionProp>
+        </elementProp>
+        <stringProp name="HTTPSampler.domain"/>
+        <stringProp name="HTTPSampler.port"/>
+        <stringProp name="HTTPSampler.connect_timeout"/>
+        <stringProp name="HTTPSampler.response_timeout"/>
+        <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
+        <stringProp name="HTTPSampler.contentEncoding"/>
+        <stringProp name="HTTPSampler.path">${base_path}${admin_path}/sales/order_invoice/save/order_id/${order_id}/</stringProp>
+        <stringProp name="HTTPSampler.method">POST</stringProp>
+        <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
+        <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
+        <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
+        <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
+        <boolProp name="HTTPSampler.monitor">false</boolProp>
+        <stringProp name="HTTPSampler.embedded_url_re"/>
+        <stringProp name="TestPlan.comments">Detected the start of a redirect chain</stringProp>
+      </HTTPSamplerProxy>
+      <hashTree>
+        <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert Invoice Created" enabled="true">
+          <collectionProp name="Asserion.test_strings">
+            <stringProp name="-1878312078">The invoice has been created.</stringProp>
+          </collectionProp>
+          <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
+          <boolProp name="Assertion.assume_success">false</boolProp>
+          <intProp name="Assertion.test_type">2</intProp>
+        </ResponseAssertion>
+        <hashTree/>
+      </hashTree>
+      <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Save Shipment" enabled="true">
+        <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
+          <collectionProp name="Arguments.arguments">
+            <elementProp name="form_key" elementType="HTTPArgument">
               <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
+              <stringProp name="Argument.name">form_key</stringProp>
+              <stringProp name="Argument.value">${admin_form_key}</stringProp>
               <stringProp name="Argument.metadata">=</stringProp>
               <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">address[new_0][street][1]</stringProp>
             </elementProp>
-            <elementProp name="address[new_0][region]" elementType="HTTPArgument">
+            <elementProp name="shipment[items][${order_item_1}]" elementType="HTTPArgument">
               <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
+              <stringProp name="Argument.name">shipment[items][${order_item_1}]</stringProp>
+              <stringProp name="Argument.value">1</stringProp>
               <stringProp name="Argument.metadata">=</stringProp>
               <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">address[new_0][region]</stringProp>
             </elementProp>
-            <elementProp name="address[new_0][country_id]" elementType="HTTPArgument">
+            <elementProp name="shipment[items][${order_item_2}]" elementType="HTTPArgument">
               <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">US</stringProp>
+              <stringProp name="Argument.name">shipment[items][${order_item_2}]</stringProp>
+              <stringProp name="Argument.value">1</stringProp>
               <stringProp name="Argument.metadata">=</stringProp>
               <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">address[new_0][country_id]</stringProp>
             </elementProp>
-            <elementProp name="address[new_0][region_id]" elementType="HTTPArgument">
+            <elementProp name="shipment[items][${order_item_3}]" elementType="HTTPArgument">
               <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">12</stringProp>
+              <stringProp name="Argument.name">shipment[items][${order_item_3}]</stringProp>
+              <stringProp name="Argument.value">1</stringProp>
               <stringProp name="Argument.metadata">=</stringProp>
               <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">address[new_0][region_id]</stringProp>
             </elementProp>
-            <elementProp name="form_key" elementType="HTTPArgument">
+            <elementProp name="shipment[comment_text]" elementType="HTTPArgument">
               <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">${admin_form_key}</stringProp>
+              <stringProp name="Argument.name">shipment[comment_text]</stringProp>
+              <stringProp name="Argument.value"/>
               <stringProp name="Argument.metadata">=</stringProp>
               <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">form_key</stringProp>
             </elementProp>
           </collectionProp>
         </elementProp>
@@ -24893,19 +15268,20 @@ if (testLabel
         <stringProp name="HTTPSampler.response_timeout"/>
         <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
         <stringProp name="HTTPSampler.contentEncoding"/>
-        <stringProp name="HTTPSampler.path">${base_path}${admin_path}/customer/index/save/</stringProp>
+        <stringProp name="HTTPSampler.path">${base_path}${admin_path}/admin/order_shipment/save/order_id/${order_id}/</stringProp>
         <stringProp name="HTTPSampler.method">POST</stringProp>
         <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
         <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
         <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
-        <boolProp name="HTTPSampler.DO_MULTIPART_POST">true</boolProp>
+        <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
         <boolProp name="HTTPSampler.monitor">false</boolProp>
         <stringProp name="HTTPSampler.embedded_url_re"/>
+        <stringProp name="TestPlan.comments">Detected the start of a redirect chain</stringProp>
       </HTTPSamplerProxy>
       <hashTree>
-        <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert customer saved" enabled="true">
+        <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert Shipment Created" enabled="true">
           <collectionProp name="Asserion.test_strings">
-            <stringProp name="292987815">You saved the customer.</stringProp>
+            <stringProp name="-348539683">The shipment has been created.</stringProp>
           </collectionProp>
           <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
           <boolProp name="Assertion.assume_success">false</boolProp>
@@ -24913,22 +15289,169 @@ if (testLabel
         </ResponseAssertion>
         <hashTree/>
       </hashTree>
-      <TestAction guiclass="TestActionGui" testclass="TestAction" testname="Pause" enabled="true">
-        <intProp name="ActionProcessor.action">1</intProp>
-        <intProp name="ActionProcessor.target">0</intProp>
-        <stringProp name="ActionProcessor.duration">${__javaScript(Math.round(${adminCustomerManagementDelay}*1000))}</stringProp>
-      </TestAction>
-      <hashTree/>
     </hashTree>
   </hashTree>
+  
+    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Logout" enabled="true">
+      <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
+        <collectionProp name="Arguments.arguments"/>
+      </elementProp>
+      <stringProp name="HTTPSampler.domain"/>
+      <stringProp name="HTTPSampler.port"/>
+      <stringProp name="HTTPSampler.connect_timeout"/>
+      <stringProp name="HTTPSampler.response_timeout"/>
+      <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
+      <stringProp name="HTTPSampler.contentEncoding"/>
+      <stringProp name="HTTPSampler.path">${base_path}${admin_path}/admin/auth/logout/</stringProp>
+      <stringProp name="HTTPSampler.method">GET</stringProp>
+      <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
+      <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
+      <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
+      <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
+      <boolProp name="HTTPSampler.monitor">false</boolProp>
+      <stringProp name="HTTPSampler.embedded_url_re"/>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/setup/admin_logout.jmx</stringProp></HTTPSamplerProxy>
+    <hashTree>
+    
+    <BeanShellPostProcessor guiclass="TestBeanGUI" testclass="BeanShellPostProcessor" testname="Return Admin to Pool" enabled="true">
+        <boolProp name="resetInterpreter">false</boolProp>
+        <stringProp name="parameters"/>
+        <stringProp name="filename"/>
+        <stringProp name="script">
+adminUserList = props.get("adminUserList");
+adminUserList.add(vars.get("admin_user"));
+        </stringProp>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/common/return_admin_email_to_pool.jmx</stringProp></BeanShellPostProcessor>
+    <hashTree/>
+  </hashTree>
+  </hashTree>
+
   </hashTree>
 
+    
+        <ThreadGroup guiclass="ThreadGroupGui" testclass="ThreadGroup" testname="API" enabled="true">
+            <stringProp name="ThreadGroup.on_sample_error">continue</stringProp>
+            <elementProp name="ThreadGroup.main_controller" elementType="LoopController" guiclass="LoopControlPanel" testclass="LoopController" testname="Loop Controller" enabled="true">
+                <boolProp name="LoopController.continue_forever">false</boolProp>
+                <stringProp name="LoopController.loops">${loops}</stringProp>
+            </elementProp>
+            <stringProp name="ThreadGroup.num_threads">${apiPoolUsers}</stringProp>
+            <stringProp name="ThreadGroup.ramp_time">${ramp_period}</stringProp>
+            <longProp name="ThreadGroup.start_time">1505803944000</longProp>
+            <longProp name="ThreadGroup.end_time">1505803944000</longProp>
+            <boolProp name="ThreadGroup.scheduler">false</boolProp>
+            <stringProp name="ThreadGroup.duration"/>
+            <stringProp name="ThreadGroup.delay"/>
+        <stringProp name="TestPlan.comments">mpaf/tool/fragments/_system/thread_group.jmx</stringProp></ThreadGroup>
+        <hashTree>
+    <ThroughputController guiclass="ThroughputControllerGui" testclass="ThroughputController" testname="API" enabled="true">
+      <intProp name="ThroughputController.style">1</intProp>
+      <boolProp name="ThroughputController.perThread">false</boolProp>
+      <intProp name="ThroughputController.maxThroughput">1</intProp>
+      <stringProp name="ThroughputController.percentThroughput">${apiBasePercentage}</stringProp>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/_system/scenario_controller_tmpl.jmx</stringProp></ThroughputController>
+    <hashTree>
+        <JSR223PreProcessor guiclass="TestBeanGUI" testclass="JSR223PreProcessor" testname="Set Test Label" enabled="true">
+            <stringProp name="script">
+var testLabel = "${testLabel}" ? " (${testLabel})" : "";
+if (testLabel
+    &amp;&amp; sampler.getClass().getName() == 'org.apache.jmeter.protocol.http.sampler.HTTPSamplerProxy'
+) {
+    if (sampler.getName().indexOf(testLabel) == -1) {
+       sampler.setName(sampler.getName() + testLabel);
+    }
+} else if (sampler.getName().indexOf("SetUp - ") == -1) {
+    sampler.setName("SetUp - " + sampler.getName());
+}
+            </stringProp>
+            <stringProp name="scriptLanguage">javascript</stringProp>
+        <stringProp name="TestPlan.comments">mpaf/tool/fragments/_system/setup_label.jmx</stringProp></JSR223PreProcessor>
+        <hashTree/>
+        <BeanShellSampler guiclass="BeanShellSamplerGui" testclass="BeanShellSampler" testname="SetUp - Set Label" enabled="true">
+            <stringProp name="BeanShellSampler.query">
+                vars.put("testLabel", "API");
+            </stringProp>
+            <boolProp name="BeanShellSampler.resetInterpreter">true</boolProp>
+        </BeanShellSampler>
+        <hashTree/>
+    
+    <HeaderManager guiclass="HeaderPanel" testclass="HeaderManager" testname="HTTP Header Manager" enabled="true">
+      <collectionProp name="HeaderManager.headers">
+        <elementProp name="" elementType="Header">
+          <stringProp name="Header.name">Content-Type</stringProp>
+          <stringProp name="Header.value">application/json</stringProp>
+        </elementProp>
+        <elementProp name="" elementType="Header">
+          <stringProp name="Header.name">Accept</stringProp>
+          <stringProp name="Header.value">*/*</stringProp>
+        </elementProp>
+      </collectionProp>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/api/header_manager_before_token.jmx</stringProp></HeaderManager>
+    <hashTree/>
   
-    <ThroughputController guiclass="ThroughputControllerGui" testclass="ThroughputController" testname="Admin CMS Management" enabled="true">
+    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="SetUp - Admin Token Retrieval" enabled="true">
+      <boolProp name="HTTPSampler.postBodyRaw">true</boolProp>
+      <elementProp name="HTTPsampler.Arguments" elementType="Arguments">
+        <collectionProp name="Arguments.arguments">
+          <elementProp name="" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">false</boolProp>
+            <stringProp name="Argument.value">{"username":"${admin_user}","password":"${admin_password}"}</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+          </elementProp>
+        </collectionProp>
+      </elementProp>
+      <stringProp name="HTTPSampler.domain"/>
+      <stringProp name="HTTPSampler.port"/>
+      <stringProp name="HTTPSampler.connect_timeout"/>
+      <stringProp name="HTTPSampler.response_timeout"/>
+      <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
+      <stringProp name="HTTPSampler.contentEncoding"/>
+      <stringProp name="HTTPSampler.path">${base_path}rest/V1/integration/admin/token</stringProp>
+      <stringProp name="HTTPSampler.method">POST</stringProp>
+      <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
+      <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
+      <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
+      <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
+      <boolProp name="HTTPSampler.monitor">false</boolProp>
+      <stringProp name="HTTPSampler.embedded_url_re"/>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/api/admin_token_retrieval.jmx</stringProp></HTTPSamplerProxy>
+    <hashTree>
+      <com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor guiclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.gui.JSONPathExtractorGui" testclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor" testname="jp@gc - JSON Path Extractor" enabled="true">
+        <stringProp name="VAR">admin_token</stringProp>
+        <stringProp name="JSONPATH">$</stringProp>
+        <stringProp name="DEFAULT"/>
+        <stringProp name="VARIABLE"/>
+        <stringProp name="SUBJECT">BODY</stringProp>
+      </com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor>
+      <hashTree/>
+      <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert token not null" enabled="true">
+        <collectionProp name="Asserion.test_strings">
+          <stringProp name="484395188">^[a-z0-9-]+$</stringProp>
+        </collectionProp>
+        <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
+        <boolProp name="Assertion.assume_success">false</boolProp>
+        <intProp name="Assertion.test_type">1</intProp>
+        <stringProp name="Assertion.scope">variable</stringProp>
+        <stringProp name="Scope.variable">admin_token</stringProp>
+      </ResponseAssertion>
+      <hashTree/>
+    </hashTree>
+  
+    <HeaderManager guiclass="HeaderPanel" testclass="HeaderManager" testname="HTTP Header Manager" enabled="true">
+      <collectionProp name="HeaderManager.headers">
+        <elementProp name="" elementType="Header">
+          <stringProp name="Header.name">Authorization</stringProp>
+          <stringProp name="Header.value">Bearer ${admin_token}</stringProp>
+        </elementProp>
+      </collectionProp>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/api/header_manager.jmx</stringProp></HeaderManager>
+    <hashTree/>
+  
+    <ThroughputController guiclass="ThroughputControllerGui" testclass="ThroughputController" testname="API Create Customer" enabled="true">
       <intProp name="ThroughputController.style">1</intProp>
       <boolProp name="ThroughputController.perThread">false</boolProp>
       <intProp name="ThroughputController.maxThroughput">1</intProp>
-      <stringProp name="ThroughputController.percentThroughput">${adminCMSManagementPercentage}</stringProp>
+      <stringProp name="ThroughputController.percentThroughput">100</stringProp>
     <stringProp name="TestPlan.comments">mpaf/tool/fragments/_system/scenario_controller_tmpl.jmx</stringProp></ThroughputController>
     <hashTree>
         <JSR223PreProcessor guiclass="TestBeanGUI" testclass="JSR223PreProcessor" testname="Set Test Label" enabled="true">
@@ -24949,72 +15472,133 @@ if (testLabel
         <hashTree/>
         <BeanShellSampler guiclass="BeanShellSamplerGui" testclass="BeanShellSampler" testname="SetUp - Set Label" enabled="true">
             <stringProp name="BeanShellSampler.query">
-                vars.put("testLabel", "Admin CMS Management");
+                vars.put("testLabel", "API Create Customer");
             </stringProp>
             <boolProp name="BeanShellSampler.resetInterpreter">true</boolProp>
         </BeanShellSampler>
         <hashTree/>
     
-        <JSR223PostProcessor guiclass="TestBeanGUI" testclass="JSR223PostProcessor" testname="Get admin form key PostProcessor" enabled="true">
-        <stringProp name="script">
-        function getFormKeyFromResponse()
-        {
-            var url = prev.getUrlAsString(),
-            responseCode =  prev.getResponseCode(),
-            formKey = null;
-            searchPattern = /var FORM_KEY = '(.+)'/;
-            if (responseCode == "200" &amp;&amp; url) {
-                response = prev.getResponseDataAsString();
-                formKey = response  &amp;&amp; response.match(searchPattern) ? response.match(searchPattern)[1] : null;
-            }
-            return formKey;
-        }
-
-        formKey = vars.get("form_key_storage");
-
-	   currentFormKey = getFormKeyFromResponse();
+    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Create customer" enabled="true">
+      <boolProp name="HTTPSampler.postBodyRaw">true</boolProp>
+      <elementProp name="HTTPsampler.Arguments" elementType="Arguments">
+        <collectionProp name="Arguments.arguments">
+          <elementProp name="" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">false</boolProp>
+            <stringProp name="Argument.value">{&#xD;
+    "customer": {&#xD;
+&#xD;
+        "email": "customer_${__time()}-${__threadNum}-${__Random(1,1000000)}@example.com",&#xD;
+        "firstname": "test_${__time()}-${__threadNum}-${__Random(1,1000000)}",&#xD;
+        "lastname": "Doe"&#xD;
+    },&#xD;
+    "password": "test@123"&#xD;
+}</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+          </elementProp>
+        </collectionProp>
+      </elementProp>
+      <stringProp name="HTTPSampler.domain"/>
+      <stringProp name="HTTPSampler.port"/>
+      <stringProp name="HTTPSampler.connect_timeout"/>
+      <stringProp name="HTTPSampler.response_timeout"/>
+      <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
+      <stringProp name="HTTPSampler.contentEncoding"/>
+      <stringProp name="HTTPSampler.path">${base_path}rest/default/V1/customers</stringProp>
+      <stringProp name="HTTPSampler.method">POST</stringProp>
+      <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
+      <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
+      <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
+      <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
+      <boolProp name="HTTPSampler.monitor">false</boolProp>
+      <stringProp name="HTTPSampler.embedded_url_re"/>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/api/create_customer.jmx</stringProp></HTTPSamplerProxy>
+    <hashTree>
+      <com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor guiclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.gui.JSONPathExtractorGui" testclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor" testname="Extract customer id" enabled="true">
+        <stringProp name="VAR">customer_id</stringProp>
+        <stringProp name="JSONPATH">$.id</stringProp>
+        <stringProp name="DEFAULT"/>
+        <stringProp name="VARIABLE"/>
+        <stringProp name="SUBJECT">BODY</stringProp>
+      </com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor>
+      <hashTree/>
+      <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert customer id not null" enabled="true">
+        <collectionProp name="Asserion.test_strings">
+          <stringProp name="89649215">^\d+$</stringProp>
+        </collectionProp>
+        <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
+        <boolProp name="Assertion.assume_success">false</boolProp>
+        <intProp name="Assertion.test_type">1</intProp>
+        <stringProp name="Assertion.scope">variable</stringProp>
+        <stringProp name="Scope.variable">customer_id</stringProp>
+      </ResponseAssertion>
+      <hashTree/>
+    </hashTree>
+  
+    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Check customer" enabled="true">
+      <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
+        <collectionProp name="Arguments.arguments"/>
+      </elementProp>
+      <stringProp name="HTTPSampler.domain"/>
+      <stringProp name="HTTPSampler.port"/>
+      <stringProp name="HTTPSampler.connect_timeout"/>
+      <stringProp name="HTTPSampler.response_timeout"/>
+      <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
+      <stringProp name="HTTPSampler.contentEncoding"/>
+      <stringProp name="HTTPSampler.path">${base_path}rest/default/V1/customers/${customer_id}</stringProp>
+      <stringProp name="HTTPSampler.method">GET</stringProp>
+      <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
+      <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
+      <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
+      <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
+      <boolProp name="HTTPSampler.monitor">false</boolProp>
+      <stringProp name="HTTPSampler.embedded_url_re"/>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/api/check_customer.jmx</stringProp></HTTPSamplerProxy>
+    <hashTree>
+      <com.atlantbh.jmeter.plugins.jsonutils.jsonpathassertion.JSONPathAssertion guiclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathassertion.gui.JSONPathAssertionGui" testclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathassertion.JSONPathAssertion" testname="jp@gc - JSON Path Assertion" enabled="true">
+        <stringProp name="JSON_PATH">$.id</stringProp>
+        <stringProp name="EXPECTED_VALUE">${customer_id}</stringProp>
+        <boolProp name="JSONVALIDATION">true</boolProp>
+        <boolProp name="EXPECT_NULL">false</boolProp>
+        <boolProp name="INVERT">false</boolProp>
+      </com.atlantbh.jmeter.plugins.jsonutils.jsonpathassertion.JSONPathAssertion>
+      <hashTree/>
+    </hashTree>
+  </hashTree>
 
-	   if (currentFormKey != null &amp;&amp; currentFormKey != formKey) {
-		  vars.put("form_key_storage", currentFormKey);
-	   }
-        </stringProp>
-        <stringProp name="scriptLanguage">javascript</stringProp>
-        <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin/handle_admin_form_key.jmx</stringProp></JSR223PostProcessor>
-        <hashTree/>
-        <JSR223PreProcessor guiclass="TestBeanGUI" testclass="JSR223PreProcessor" testname="Set admin form key PreProcessor" enabled="true">
-            <stringProp name="script">
-                formKey =  vars.get("form_key_storage");
-                if (formKey
-                    &amp;&amp; sampler.getClass().getName() == 'org.apache.jmeter.protocol.http.sampler.HTTPSamplerProxy'
-                    &amp;&amp; sampler.getMethod() == "POST")
-                    {
-                        arguments = sampler.getArguments();
-                        for (i=0; i&lt;arguments.getArgumentCount(); i++)
-                        {
-                            argument = arguments.getArgument(i);
-                            if (argument.getName() == 'form_key' &amp;&amp; argument.getValue() != formKey) {
-                            log.info("admin form key updated: " + argument.getValue() + " =&gt; " + formKey);
-                            argument.setValue(formKey);
-                        }
-                    }
-                }
+  
+    <ThroughputController guiclass="ThroughputControllerGui" testclass="ThroughputController" testname="API Catalog Browsing" enabled="true">
+      <intProp name="ThroughputController.style">1</intProp>
+      <boolProp name="ThroughputController.perThread">false</boolProp>
+      <intProp name="ThroughputController.maxThroughput">1</intProp>
+      <stringProp name="ThroughputController.percentThroughput">100</stringProp>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/_system/scenario_controller_tmpl.jmx</stringProp></ThroughputController>
+    <hashTree>
+        <JSR223PreProcessor guiclass="TestBeanGUI" testclass="JSR223PreProcessor" testname="Set Test Label" enabled="true">
+            <stringProp name="script">
+var testLabel = "${testLabel}" ? " (${testLabel})" : "";
+if (testLabel
+    &amp;&amp; sampler.getClass().getName() == 'org.apache.jmeter.protocol.http.sampler.HTTPSamplerProxy'
+) {
+    if (sampler.getName().indexOf(testLabel) == -1) {
+       sampler.setName(sampler.getName() + testLabel);
+    }
+} else if (sampler.getName().indexOf("SetUp - ") == -1) {
+    sampler.setName("SetUp - " + sampler.getName());
+}
             </stringProp>
             <stringProp name="scriptLanguage">javascript</stringProp>
-        </JSR223PreProcessor>
+        <stringProp name="TestPlan.comments">mpaf/tool/fragments/_system/setup_label.jmx</stringProp></JSR223PreProcessor>
+        <hashTree/>
+        <BeanShellSampler guiclass="BeanShellSamplerGui" testclass="BeanShellSampler" testname="SetUp - Set Label" enabled="true">
+            <stringProp name="BeanShellSampler.query">
+                vars.put("testLabel", "API Catalog Browsing");
+            </stringProp>
+            <boolProp name="BeanShellSampler.resetInterpreter">true</boolProp>
+        </BeanShellSampler>
         <hashTree/>
     
-    <CookieManager guiclass="CookiePanel" testclass="CookieManager" testname="HTTP Cookie Manager" enabled="true">
-      <collectionProp name="CookieManager.cookies"/>
-      <boolProp name="CookieManager.clearEachIteration">false</boolProp>
-    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/http_cookie_manager_without_clear_each_iteration.jmx</stringProp></CookieManager>
-    <hashTree/>
-  
-    <OnceOnlyController guiclass="OnceOnlyControllerGui" testclass="OnceOnlyController" testname="Once Only Controller" enabled="true">
-  <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/once_only_controller.jmx</stringProp>
-</OnceOnlyController>
-    <hashTree>
-    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="SetUp - Login" enabled="true">
-      <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
+    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Get categories" enabled="true">
+      <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" testname="User Defined Variables" enabled="true">
         <collectionProp name="Arguments.arguments"/>
       </elementProp>
       <stringProp name="HTTPSampler.domain"/>
@@ -25023,7 +15607,7 @@ if (testLabel
       <stringProp name="HTTPSampler.response_timeout"/>
       <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
       <stringProp name="HTTPSampler.contentEncoding"/>
-      <stringProp name="HTTPSampler.path">${base_path}${admin_path}</stringProp>
+      <stringProp name="HTTPSampler.path">${base_path}rest/default/V1/categories</stringProp>
       <stringProp name="HTTPSampler.method">GET</stringProp>
       <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
       <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
@@ -25031,70 +15615,193 @@ if (testLabel
       <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
       <boolProp name="HTTPSampler.monitor">false</boolProp>
       <stringProp name="HTTPSampler.embedded_url_re"/>
-    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_login/admin_login.jmx</stringProp></HTTPSamplerProxy>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/api/get_categories.jmx</stringProp></HTTPSamplerProxy>
     <hashTree>
-      <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert login form shown" enabled="true">
+      <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert results are present" enabled="true">
         <collectionProp name="Asserion.test_strings">
-          <stringProp name="-1397214398">Welcome</stringProp>
-          <stringProp name="-515240035">&lt;title&gt;Magento Admin&lt;/title&gt;</stringProp>
+          <stringProp name="-1294635157">errors</stringProp>
         </collectionProp>
         <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
         <boolProp name="Assertion.assume_success">false</boolProp>
-        <intProp name="Assertion.test_type">2</intProp>
+        <intProp name="Assertion.test_type">6</intProp>
+        <stringProp name="Assertion.scope">variable</stringProp>
+        <stringProp name="Scope.variable"/>
       </ResponseAssertion>
       <hashTree/>
-      <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract form key" enabled="true">
-        <stringProp name="RegexExtractor.useHeaders">false</stringProp>
-        <stringProp name="RegexExtractor.refname">admin_form_key</stringProp>
-        <stringProp name="RegexExtractor.regex">&lt;input name="form_key" type="hidden" value="([^'"]+)" /&gt;</stringProp>
-        <stringProp name="RegexExtractor.template">$1$</stringProp>
-        <stringProp name="RegexExtractor.default"/>
-        <stringProp name="RegexExtractor.match_number">1</stringProp>
-      </RegexExtractor>
+      <com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor guiclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.gui.JSONPathExtractorGui" testclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor" testname="Extract search category id" enabled="true">
+        <stringProp name="VAR">search_category_id</stringProp>
+        <stringProp name="JSONPATH">$.id</stringProp>
+        <stringProp name="DEFAULT"/>
+        <stringProp name="VARIABLE"/>
+        <stringProp name="SUBJECT">BODY</stringProp>
+      </com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor>
       <hashTree/>
-      <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert form_key extracted" enabled="true">
+      <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert search category id is not null" enabled="true">
         <collectionProp name="Asserion.test_strings">
-          <stringProp name="2845929">^.+$</stringProp>
+          <stringProp name="89649215">^\d+$</stringProp>
         </collectionProp>
         <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
         <boolProp name="Assertion.assume_success">false</boolProp>
         <intProp name="Assertion.test_type">1</intProp>
         <stringProp name="Assertion.scope">variable</stringProp>
-        <stringProp name="Scope.variable">admin_form_key</stringProp>
+        <stringProp name="Scope.variable">search_category_id</stringProp>
       </ResponseAssertion>
       <hashTree/>
     </hashTree>
   
-    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="SetUp - Login Submit Form" enabled="true">
+    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Get category" enabled="true">
+      <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" testname="User Defined Variables" enabled="true">
+        <collectionProp name="Arguments.arguments"/>
+      </elementProp>
+      <stringProp name="HTTPSampler.domain"/>
+      <stringProp name="HTTPSampler.port"/>
+      <stringProp name="HTTPSampler.connect_timeout"/>
+      <stringProp name="HTTPSampler.response_timeout"/>
+      <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
+      <stringProp name="HTTPSampler.contentEncoding"/>
+      <stringProp name="HTTPSampler.path">${base_path}rest/default/V1/categories/${search_category_id}</stringProp>
+      <stringProp name="HTTPSampler.method">GET</stringProp>
+      <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
+      <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
+      <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
+      <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
+      <boolProp name="HTTPSampler.monitor">false</boolProp>
+      <stringProp name="HTTPSampler.embedded_url_re"/>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/api/get_category.jmx</stringProp></HTTPSamplerProxy>
+    <hashTree>
+      <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert results are present" enabled="true">
+        <collectionProp name="Asserion.test_strings">
+          <stringProp name="-1294635157">errors</stringProp>
+        </collectionProp>
+        <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
+        <boolProp name="Assertion.assume_success">false</boolProp>
+        <intProp name="Assertion.test_type">6</intProp>
+        <stringProp name="Assertion.scope">variable</stringProp>
+        <stringProp name="Scope.variable"/>
+      </ResponseAssertion>
+      <hashTree/>
+    </hashTree>
+  
+    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Get products" enabled="true">
+      <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" testname="User Defined Variables" enabled="true">
+        <collectionProp name="Arguments.arguments">
+          <elementProp name="searchCriteria[page_size]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">20</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">searchCriteria[page_size]</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
+          </elementProp>
+          <elementProp name="searchCriteria[current_page]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">1</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">searchCriteria[current_page]</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
+          </elementProp>
+        </collectionProp>
+      </elementProp>
+      <stringProp name="HTTPSampler.domain"/>
+      <stringProp name="HTTPSampler.port"/>
+      <stringProp name="HTTPSampler.connect_timeout"/>
+      <stringProp name="HTTPSampler.response_timeout"/>
+      <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
+      <stringProp name="HTTPSampler.contentEncoding"/>
+      <stringProp name="HTTPSampler.path">${base_path}rest/default/V1/products</stringProp>
+      <stringProp name="HTTPSampler.method">GET</stringProp>
+      <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
+      <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
+      <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
+      <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
+      <boolProp name="HTTPSampler.monitor">false</boolProp>
+      <stringProp name="HTTPSampler.embedded_url_re"/>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/api/get_products.jmx</stringProp></HTTPSamplerProxy>
+    <hashTree>
+      <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert results are present" enabled="true">
+        <collectionProp name="Asserion.test_strings">
+          <stringProp name="-1294635157">errors</stringProp>
+        </collectionProp>
+        <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
+        <boolProp name="Assertion.assume_success">false</boolProp>
+        <intProp name="Assertion.test_type">6</intProp>
+        <stringProp name="Assertion.scope">variable</stringProp>
+        <stringProp name="Scope.variable"/>
+      </ResponseAssertion>
+      <hashTree/>
+    </hashTree>
+  </hashTree>
+
+  
+    <ThroughputController guiclass="ThroughputControllerGui" testclass="ThroughputController" testname="API Search" enabled="true">
+      <intProp name="ThroughputController.style">1</intProp>
+      <boolProp name="ThroughputController.perThread">false</boolProp>
+      <intProp name="ThroughputController.maxThroughput">1</intProp>
+      <stringProp name="ThroughputController.percentThroughput">100</stringProp>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/_system/scenario_controller_tmpl.jmx</stringProp></ThroughputController>
+    <hashTree>
+        <JSR223PreProcessor guiclass="TestBeanGUI" testclass="JSR223PreProcessor" testname="Set Test Label" enabled="true">
+            <stringProp name="script">
+var testLabel = "${testLabel}" ? " (${testLabel})" : "";
+if (testLabel
+    &amp;&amp; sampler.getClass().getName() == 'org.apache.jmeter.protocol.http.sampler.HTTPSamplerProxy'
+) {
+    if (sampler.getName().indexOf(testLabel) == -1) {
+       sampler.setName(sampler.getName() + testLabel);
+    }
+} else if (sampler.getName().indexOf("SetUp - ") == -1) {
+    sampler.setName("SetUp - " + sampler.getName());
+}
+            </stringProp>
+            <stringProp name="scriptLanguage">javascript</stringProp>
+        <stringProp name="TestPlan.comments">mpaf/tool/fragments/_system/setup_label.jmx</stringProp></JSR223PreProcessor>
+        <hashTree/>
+        <BeanShellSampler guiclass="BeanShellSamplerGui" testclass="BeanShellSampler" testname="SetUp - Set Label" enabled="true">
+            <stringProp name="BeanShellSampler.query">
+                vars.put("testLabel", "API Search");
+            </stringProp>
+            <boolProp name="BeanShellSampler.resetInterpreter">true</boolProp>
+        </BeanShellSampler>
+        <hashTree/>
+    
+    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Search for simple product on frontend" enabled="true">
       <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
         <collectionProp name="Arguments.arguments">
-          <elementProp name="dummy" elementType="HTTPArgument">
+          <elementProp name="searchCriteria[request_name]" elementType="HTTPArgument">
             <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value"/>
+            <stringProp name="Argument.value">quick_search_container</stringProp>
             <stringProp name="Argument.metadata">=</stringProp>
             <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">dummy</stringProp>
+            <stringProp name="Argument.name">searchCriteria[request_name]</stringProp>
           </elementProp>
-          <elementProp name="form_key" elementType="HTTPArgument">
+          <elementProp name="searchCriteria[filter_groups][0][filters][0][field]" elementType="HTTPArgument">
             <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">${admin_form_key}</stringProp>
+            <stringProp name="Argument.value">search_term</stringProp>
             <stringProp name="Argument.metadata">=</stringProp>
             <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">form_key</stringProp>
+            <stringProp name="Argument.name">searchCriteria[filter_groups][0][filters][0][field]</stringProp>
           </elementProp>
-          <elementProp name="login[password]" elementType="HTTPArgument">
+          <elementProp name="searchCriteria[filter_groups][0][filters][0][value]" elementType="HTTPArgument">
             <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">${admin_password}</stringProp>
+            <stringProp name="Argument.value">Simple</stringProp>
             <stringProp name="Argument.metadata">=</stringProp>
             <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">login[password]</stringProp>
+            <stringProp name="Argument.name">searchCriteria[filter_groups][0][filters][0][value]</stringProp>
           </elementProp>
-          <elementProp name="login[username]" elementType="HTTPArgument">
+          <elementProp name="searchCriteria[page_size]" elementType="HTTPArgument">
             <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">${admin_user}</stringProp>
+            <stringProp name="Argument.value">20</stringProp>
             <stringProp name="Argument.metadata">=</stringProp>
             <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">login[username]</stringProp>
+            <stringProp name="Argument.name">searchCriteria[page_size]</stringProp>
+          </elementProp>
+          <elementProp name="searchCriteria[current_page]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">1</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">searchCriteria[current_page]</stringProp>
           </elementProp>
         </collectionProp>
       </elementProp>
@@ -25104,237 +15811,52 @@ if (testLabel
       <stringProp name="HTTPSampler.response_timeout"/>
       <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
       <stringProp name="HTTPSampler.contentEncoding"/>
-      <stringProp name="HTTPSampler.path">${base_path}${admin_path}/admin/dashboard/</stringProp>
-      <stringProp name="HTTPSampler.method">POST</stringProp>
+      <stringProp name="HTTPSampler.path">${base_path}rest/default/V1/search</stringProp>
+      <stringProp name="HTTPSampler.method">GET</stringProp>
       <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
       <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
       <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
       <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
-      <stringProp name="HTTPSampler.implementation">Java</stringProp>
       <boolProp name="HTTPSampler.monitor">false</boolProp>
       <stringProp name="HTTPSampler.embedded_url_re"/>
-      <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_login/admin_login_submit_form.jmx</stringProp>
-    </HTTPSamplerProxy>
-    <hashTree>
-        <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract form key" enabled="true">
-            <stringProp name="RegexExtractor.useHeaders">false</stringProp>
-            <stringProp name="RegexExtractor.refname">admin_form_key</stringProp>
-            <stringProp name="RegexExtractor.regex">&lt;input name="form_key" type="hidden" value="([^'"]+)" /&gt;</stringProp>
-            <stringProp name="RegexExtractor.template">$1$</stringProp>
-            <stringProp name="RegexExtractor.default"/>
-            <stringProp name="RegexExtractor.match_number">1</stringProp>
-        <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_login/admin_retrieve_form_key.jmx</stringProp></RegexExtractor>
-        <hashTree/>
-    </hashTree>
-  </hashTree>
-  
-    <GenericController guiclass="LogicControllerGui" testclass="GenericController" testname="Simple Controller" enabled="true">
-  <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/simple_controller.jmx</stringProp>
-</GenericController>
-    <hashTree>
-    <TestFragmentController guiclass="TestFragmentControllerGui" testclass="TestFragmentController" testname="Admin CMS Management" enabled="true">
-  <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_cms_management/admin_cms_management.jmx</stringProp>
-</TestFragmentController>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/api/search_for_product_frontend.jmx</stringProp></HTTPSamplerProxy>
     <hashTree>
-      <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Landing Page" enabled="true">
-        <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
-          <collectionProp name="Arguments.arguments"/>
-        </elementProp>
-        <stringProp name="HTTPSampler.domain"/>
-        <stringProp name="HTTPSampler.port"/>
-        <stringProp name="HTTPSampler.connect_timeout"/>
-        <stringProp name="HTTPSampler.response_timeout"/>
-        <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
-        <stringProp name="HTTPSampler.contentEncoding"/>
-        <stringProp name="HTTPSampler.path">${base_path}${admin_path}/cms/page/</stringProp>
-        <stringProp name="HTTPSampler.method">GET</stringProp>
-        <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
-        <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
-        <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
-        <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
-        <boolProp name="HTTPSampler.monitor">false</boolProp>
-        <stringProp name="HTTPSampler.embedded_url_re"/>
-      </HTTPSamplerProxy>
+      <com.atlantbh.jmeter.plugins.jsonutils.jsonpathassertion.JSONPathAssertion guiclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathassertion.gui.JSONPathAssertionGui" testclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathassertion.JSONPathAssertion" testname="Assert results are present" enabled="true">
+        <stringProp name="JSON_PATH">$.total_count</stringProp>
+        <stringProp name="EXPECTED_VALUE">0</stringProp>
+        <boolProp name="JSONVALIDATION">true</boolProp>
+        <boolProp name="EXPECT_NULL">false</boolProp>
+        <boolProp name="INVERT">true</boolProp>
+      </com.atlantbh.jmeter.plugins.jsonutils.jsonpathassertion.JSONPathAssertion>
       <hashTree/>
-      <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Create New" enabled="true">
-        <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
-          <collectionProp name="Arguments.arguments"/>
-        </elementProp>
-        <stringProp name="HTTPSampler.domain"/>
-        <stringProp name="HTTPSampler.port"/>
-        <stringProp name="HTTPSampler.connect_timeout"/>
-        <stringProp name="HTTPSampler.response_timeout"/>
-        <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
-        <stringProp name="HTTPSampler.contentEncoding"/>
-        <stringProp name="HTTPSampler.path">${base_path}${admin_path}/cms/page/new</stringProp>
-        <stringProp name="HTTPSampler.method">GET</stringProp>
-        <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
-        <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
-        <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
-        <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
-        <boolProp name="HTTPSampler.monitor">false</boolProp>
-        <stringProp name="HTTPSampler.embedded_url_re"/>
-      </HTTPSamplerProxy>
+      <com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor guiclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.gui.JSONPathExtractorGui" testclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor" testname="Extract search product id" enabled="true">
+        <stringProp name="VAR">search_product_id</stringProp>
+        <stringProp name="JSONPATH">$.items[0].id</stringProp>
+        <stringProp name="DEFAULT"/>
+        <stringProp name="VARIABLE"/>
+        <stringProp name="SUBJECT">BODY</stringProp>
+      </com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor>
       <hashTree/>
-      <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Save" enabled="true">
-        <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
-          <collectionProp name="Arguments.arguments">
-            <elementProp name="content" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">&lt;p&gt;CMS Content ${__time(YMDHMS)}-${__threadNum}-${__Random(1,1000000)}&lt;/p&gt;</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">content</stringProp>
-            </elementProp>
-            <elementProp name="content_heading" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">content_heading</stringProp>
-            </elementProp>
-            <elementProp name="form_key" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">${admin_form_key}</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">form_key</stringProp>
-            </elementProp>
-            <elementProp name="identifier" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">identifier</stringProp>
-            </elementProp>
-            <elementProp name="is_active" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">is_active</stringProp>
-            </elementProp>
-            <elementProp name="layout_update_xml" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">layout_update_xml</stringProp>
-            </elementProp>
-            <elementProp name="meta_description" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">meta_description</stringProp>
-            </elementProp>
-            <elementProp name="meta_keywords" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">meta_keywords</stringProp>
-            </elementProp>
-            <elementProp name="meta_title" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">meta_title</stringProp>
-            </elementProp>
-            <elementProp name="nodes_data" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">false</boolProp>
-              <stringProp name="Argument.value">{}</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">nodes_data</stringProp>
-            </elementProp>
-            <elementProp name="node_ids" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">node_ids</stringProp>
-            </elementProp>
-            <elementProp name="page_id" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value"/>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">page_id</stringProp>
-            </elementProp>
-            <elementProp name="page_layout" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">1column</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">page_layout</stringProp>
-            </elementProp>
-            <elementProp name="store_id[0]" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">0</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">store_id[0]</stringProp>
-            </elementProp>
-            <elementProp name="title" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">CMS Title ${__time(YMDHMS)}-${__threadNum}-${__Random(1,1000000)}</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">title</stringProp>
-            </elementProp>
-            <elementProp name="website_root" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">true</boolProp>
-              <stringProp name="Argument.value">0</stringProp>
-              <stringProp name="Argument.metadata">=</stringProp>
-              <boolProp name="HTTPArgument.use_equals">true</boolProp>
-              <stringProp name="Argument.name">website_root</stringProp>
-            </elementProp>
-          </collectionProp>
-        </elementProp>
-        <stringProp name="HTTPSampler.domain"/>
-        <stringProp name="HTTPSampler.port"/>
-        <stringProp name="HTTPSampler.connect_timeout"/>
-        <stringProp name="HTTPSampler.response_timeout"/>
-        <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
-        <stringProp name="HTTPSampler.contentEncoding"/>
-        <stringProp name="HTTPSampler.path">${base_path}${admin_path}/cms/page/save/</stringProp>
-        <stringProp name="HTTPSampler.method">POST</stringProp>
-        <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
-        <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
-        <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
-        <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
-        <boolProp name="HTTPSampler.monitor">false</boolProp>
-        <stringProp name="HTTPSampler.embedded_url_re"/>
-      </HTTPSamplerProxy>
-      <hashTree>
-        <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Response Assertion" enabled="true">
-          <collectionProp name="Asserion.test_strings">
-            <stringProp name="-398886250">You saved the page.</stringProp>
-          </collectionProp>
-          <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
-          <boolProp name="Assertion.assume_success">false</boolProp>
-          <intProp name="Assertion.test_type">16</intProp>
-        </ResponseAssertion>
-        <hashTree/>
-      </hashTree>
-      <TestAction guiclass="TestActionGui" testclass="TestAction" testname="Pause" enabled="true">
-        <intProp name="ActionProcessor.action">1</intProp>
-        <intProp name="ActionProcessor.target">0</intProp>
-        <stringProp name="ActionProcessor.duration">${__javaScript(Math.round(${adminCMSManagementDelay}*1000))}</stringProp>
-      </TestAction>
+      <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert search product id is not null" enabled="true">
+        <collectionProp name="Asserion.test_strings">
+          <stringProp name="89649215">^\d+$</stringProp>
+        </collectionProp>
+        <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
+        <boolProp name="Assertion.assume_success">false</boolProp>
+        <intProp name="Assertion.test_type">1</intProp>
+        <stringProp name="Assertion.scope">variable</stringProp>
+        <stringProp name="Scope.variable">search_product_id</stringProp>
+      </ResponseAssertion>
       <hashTree/>
     </hashTree>
   </hashTree>
-  </hashTree>
 
   
-    <ThroughputController guiclass="ThroughputControllerGui" testclass="ThroughputController" testname="Product Review By Customer" enabled="true">
+    <ThroughputController guiclass="ThroughputControllerGui" testclass="ThroughputController" testname="API Checkout" enabled="true">
       <intProp name="ThroughputController.style">1</intProp>
       <boolProp name="ThroughputController.perThread">false</boolProp>
       <intProp name="ThroughputController.maxThroughput">1</intProp>
-      <stringProp name="ThroughputController.percentThroughput">${reviewByCustomerPercentage}</stringProp>
+      <stringProp name="ThroughputController.percentThroughput">100</stringProp>
     <stringProp name="TestPlan.comments">mpaf/tool/fragments/_system/scenario_controller_tmpl.jmx</stringProp></ThroughputController>
     <hashTree>
         <JSR223PreProcessor guiclass="TestBeanGUI" testclass="JSR223PreProcessor" testname="Set Test Label" enabled="true">
@@ -25355,37 +15877,12 @@ if (testLabel
         <hashTree/>
         <BeanShellSampler guiclass="BeanShellSamplerGui" testclass="BeanShellSampler" testname="SetUp - Set Label" enabled="true">
             <stringProp name="BeanShellSampler.query">
-                vars.put("testLabel", "Product Review By Customer");
+                vars.put("testLabel", "API Checkout");
             </stringProp>
             <boolProp name="BeanShellSampler.resetInterpreter">true</boolProp>
         </BeanShellSampler>
         <hashTree/>
     
-    <CookieManager guiclass="CookiePanel" testclass="CookieManager" testname="HTTP Cookie Manager" enabled="true">
-      <collectionProp name="CookieManager.cookies">
-        <elementProp name="product_list_limit" elementType="Cookie" testname="product_list_limit">
-          <stringProp name="Cookie.value">30</stringProp>
-          <stringProp name="Cookie.domain">${host}</stringProp>
-          <stringProp name="Cookie.path">/</stringProp>
-          <boolProp name="Cookie.secure">false</boolProp>
-          <longProp name="Cookie.expires">0</longProp>
-          <boolProp name="Cookie.path_specified">true</boolProp>
-          <boolProp name="Cookie.domain_specified">true</boolProp>
-        </elementProp>
-        <elementProp name="product_list_limit" elementType="Cookie" testname="form_key">
-          <stringProp name="Cookie.value">${form_key}</stringProp>
-          <stringProp name="Cookie.domain">${host}</stringProp>
-          <stringProp name="Cookie.path">${base_path}</stringProp>
-          <boolProp name="Cookie.secure">false</boolProp>
-          <longProp name="Cookie.expires">0</longProp>
-          <boolProp name="Cookie.path_specified">true</boolProp>
-          <boolProp name="Cookie.domain_specified">true</boolProp>
-        </elementProp>
-      </collectionProp>
-      <boolProp name="CookieManager.clearEachIteration">true</boolProp>
-    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/http_cookie_manager.jmx</stringProp></CookieManager>
-    <hashTree/>
-  
       <BeanShellSampler guiclass="BeanShellSamplerGui" testclass="BeanShellSampler" testname="SetUp - Init Random Generator" enabled="true">
         <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/common/init_random_generator_setup.jmx</stringProp>
         <stringProp name="BeanShellSampler.query">
@@ -25404,46 +15901,27 @@ vars.putObject("randomIntGenerator", random);
       </BeanShellSampler>
       <hashTree/>
     
-    <BeanShellSampler guiclass="BeanShellSamplerGui" testclass="BeanShellSampler" testname="SetUp - Get Customer Email" enabled="true">
-      <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/get_customer_email.jmx</stringProp>
-      <stringProp name="BeanShellSampler.query">import org.apache.jmeter.samplers.SampleResult;
-
-String siterator = vars.get("customer_emails_index");
-int iterator;
-if(siterator == null){
-    iterator = 0;
-    vars.put("customer_emails_index", "0");
-} else {
-    iterator = Integer.parseInt(siterator);
-    iterator ++;
-    vars.put("customer_emails_index", iterator.toString());
-}
+    <BeanShellSampler guiclass="BeanShellSamplerGui" testclass="BeanShellSampler" testname="SetUp - Prepare Simple Product Data" enabled="true">
+      <stringProp name="BeanShellSampler.query">
+import java.util.Random;
 
-emails_list = props.get("customer_emails_list");
+Random random = vars.getObject("randomIntGenerator");
+number = random.nextInt(props.get("simple_products_list").size());
+product = props.get("simple_products_list").get(number);
 
-threadsNumber = ctx.getThreadGroup().getNumThreads();
-emailsCount = emails_list.size();
-if (threadsNumber &gt; emailsCount) {
-    log.error(" There are not enough customers for this scenario.");
-} else {
-    clusterLength = Math.round(emailsCount / threadsNumber);
-    threadNum = ctx.getThreadNum();
-    emails_index = clusterLength * threadNum + iterator;
-    maxLimit = clusterLength * (threadNum + 1);
-    if (emails_index &gt;= maxLimit) {
-        iterator = 0;
-        emails_index = clusterLength * threadNum + iterator;
-        vars.put("customer_emails_index", iterator.toString());
-    }
-}
-vars.put("customer_email", emails_list.get(emails_index));</stringProp>
+vars.put("product_url_key", product.get("url_key"));
+vars.put("product_id", product.get("id"));
+vars.put("product_name", product.get("title"));
+vars.put("product_uenc", product.get("uenc"));
+vars.put("product_sku", product.get("sku"));
+      </stringProp>
       <stringProp name="BeanShellSampler.filename"/>
       <stringProp name="BeanShellSampler.parameters"/>
       <boolProp name="BeanShellSampler.resetInterpreter">true</boolProp>
-    </BeanShellSampler>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/product_browsing_and_adding_items_to_the_cart/simple_products_setup.jmx</stringProp></BeanShellSampler>
     <hashTree/>
   
-    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Open Login Page" enabled="true">
+    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Create quote" enabled="true">
       <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
         <collectionProp name="Arguments.arguments"/>
       </elementProp>
@@ -25453,57 +15931,122 @@ vars.put("customer_email", emails_list.get(emails_index));</stringProp>
       <stringProp name="HTTPSampler.response_timeout"/>
       <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
       <stringProp name="HTTPSampler.contentEncoding"/>
-      <stringProp name="HTTPSampler.path">${base_path}customer/account/login/</stringProp>
-      <stringProp name="HTTPSampler.method">GET</stringProp>
+      <stringProp name="HTTPSampler.path">${base_path}rest/default/V1/carts</stringProp>
+      <stringProp name="HTTPSampler.method">POST</stringProp>
       <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
       <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
       <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
       <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
       <boolProp name="HTTPSampler.monitor">false</boolProp>
       <stringProp name="HTTPSampler.embedded_url_re"/>
-    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/common/open_login_page.jmx</stringProp></HTTPSamplerProxy>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/api/create_quote.jmx</stringProp></HTTPSamplerProxy>
     <hashTree>
+      <com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor guiclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.gui.JSONPathExtractorGui" testclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor" testname="Extract cart id" enabled="true">
+        <stringProp name="VAR">quote_id</stringProp>
+        <stringProp name="JSONPATH">$</stringProp>
+        <stringProp name="DEFAULT"/>
+        <stringProp name="VARIABLE"/>
+        <stringProp name="SUBJECT">BODY</stringProp>
+      </com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor>
+      <hashTree/>
       <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Response Assertion" enabled="true">
         <collectionProp name="Asserion.test_strings">
-          <stringProp name="637394530">&lt;title&gt;Customer Login&lt;/title&gt;</stringProp>
+          <stringProp name="89649215">^\d+$</stringProp>
         </collectionProp>
         <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
         <boolProp name="Assertion.assume_success">false</boolProp>
-        <intProp name="Assertion.test_type">2</intProp>
+        <intProp name="Assertion.test_type">1</intProp>
+        <stringProp name="Assertion.scope">variable</stringProp>
+        <stringProp name="Scope.variable">quote_id</stringProp>
       </ResponseAssertion>
       <hashTree/>
     </hashTree>
   
-    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Login" enabled="true">
-      <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
+    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Add product to quote" enabled="true">
+      <boolProp name="HTTPSampler.postBodyRaw">true</boolProp>
+      <elementProp name="HTTPsampler.Arguments" elementType="Arguments">
         <collectionProp name="Arguments.arguments">
-          <elementProp name="form_key" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">${form_key}</stringProp>
-            <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">form_key</stringProp>
-          </elementProp>
-          <elementProp name="login[username]" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">${customer_email}</stringProp>
-            <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">login[username]</stringProp>
-          </elementProp>
-          <elementProp name="login[password]" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">${customer_password}</stringProp>
+          <elementProp name="" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">false</boolProp>
+            <stringProp name="Argument.value">{&#xD;
+	"cartItem": {&#xD;
+		"sku": "${product_sku}",&#xD;
+		"qty":"1",&#xD;
+		"quote_id":"${quote_id}"&#xD;
+	}&#xD;
+}&#xD;
+</stringProp>
             <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">login[password]</stringProp>
           </elementProp>
-          <elementProp name="send" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value"/>
+        </collectionProp>
+      </elementProp>
+      <stringProp name="HTTPSampler.domain"/>
+      <stringProp name="HTTPSampler.port"/>
+      <stringProp name="HTTPSampler.connect_timeout"/>
+      <stringProp name="HTTPSampler.response_timeout"/>
+      <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
+      <stringProp name="HTTPSampler.contentEncoding"/>
+      <stringProp name="HTTPSampler.path">${base_path}rest/default/V1/carts/${quote_id}/items</stringProp>
+      <stringProp name="HTTPSampler.method">POST</stringProp>
+      <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
+      <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
+      <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
+      <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
+      <boolProp name="HTTPSampler.monitor">false</boolProp>
+      <stringProp name="HTTPSampler.embedded_url_re"/>
+      <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/api/add_product_to_quote_hardwired_sku.jmx</stringProp>
+    </HTTPSamplerProxy>
+    <hashTree>
+      <com.atlantbh.jmeter.plugins.jsonutils.jsonpathassertion.JSONPathAssertion guiclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathassertion.gui.JSONPathAssertionGui" testclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathassertion.JSONPathAssertion" testname="jp@gc - JSON Path Assertion" enabled="true">
+        <stringProp name="JSON_PATH">$.sku</stringProp>
+        <stringProp name="EXPECTED_VALUE">${product_sku}</stringProp>
+        <boolProp name="JSONVALIDATION">true</boolProp>
+        <boolProp name="EXPECT_NULL">false</boolProp>
+        <boolProp name="INVERT">false</boolProp>
+      </com.atlantbh.jmeter.plugins.jsonutils.jsonpathassertion.JSONPathAssertion>
+      <hashTree/>
+    </hashTree>
+  
+    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Check products in quote" enabled="true">
+      <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
+        <collectionProp name="Arguments.arguments"/>
+      </elementProp>
+      <stringProp name="HTTPSampler.domain"/>
+      <stringProp name="HTTPSampler.port"/>
+      <stringProp name="HTTPSampler.connect_timeout"/>
+      <stringProp name="HTTPSampler.response_timeout"/>
+      <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
+      <stringProp name="HTTPSampler.contentEncoding"/>
+      <stringProp name="HTTPSampler.path">${base_path}rest/default/V1/carts/${quote_id}/items</stringProp>
+      <stringProp name="HTTPSampler.method">GET</stringProp>
+      <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
+      <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
+      <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
+      <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
+      <boolProp name="HTTPSampler.monitor">false</boolProp>
+      <stringProp name="HTTPSampler.embedded_url_re"/>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/api/check_product_in_quote_hardwired_sku.jmx</stringProp></HTTPSamplerProxy>
+    <hashTree>
+      <com.atlantbh.jmeter.plugins.jsonutils.jsonpathassertion.JSONPathAssertion guiclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathassertion.gui.JSONPathAssertionGui" testclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathassertion.JSONPathAssertion" testname="jp@gc - JSON Path Assertion" enabled="true">
+        <stringProp name="JSON_PATH">$[0].sku</stringProp>
+        <stringProp name="EXPECTED_VALUE">${product_sku}</stringProp>
+        <boolProp name="JSONVALIDATION">true</boolProp>
+        <boolProp name="EXPECT_NULL">false</boolProp>
+        <boolProp name="INVERT">false</boolProp>
+      </com.atlantbh.jmeter.plugins.jsonutils.jsonpathassertion.JSONPathAssertion>
+      <hashTree/>
+    </hashTree>
+  
+    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Create Guest Cart" enabled="true">
+      <boolProp name="HTTPSampler.postBodyRaw">true</boolProp>
+      <elementProp name="HTTPsampler.Arguments" elementType="Arguments">
+        <collectionProp name="Arguments.arguments">
+          <elementProp name="" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">false</boolProp>
+            <stringProp name="Argument.value">{&#xD;
+    "storeId": 1&#xD;
+}</stringProp>
             <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">send</stringProp>
           </elementProp>
         </collectionProp>
       </elementProp>
@@ -25513,7 +16056,7 @@ vars.put("customer_email", emails_list.get(emails_index));</stringProp>
       <stringProp name="HTTPSampler.response_timeout"/>
       <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
       <stringProp name="HTTPSampler.contentEncoding"/>
-      <stringProp name="HTTPSampler.path">${base_path}customer/account/loginPost/</stringProp>
+      <stringProp name="HTTPSampler.path">${base_path}rest/default/V1/guest-carts/</stringProp>
       <stringProp name="HTTPSampler.method">POST</stringProp>
       <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
       <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
@@ -25521,27 +16064,17 @@ vars.put("customer_email", emails_list.get(emails_index));</stringProp>
       <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
       <boolProp name="HTTPSampler.monitor">false</boolProp>
       <stringProp name="HTTPSampler.embedded_url_re"/>
-    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/common/login.jmx</stringProp></HTTPSamplerProxy>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/api/create_guest_cart.jmx</stringProp></HTTPSamplerProxy>
     <hashTree>
-      <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Response Assertion" enabled="true">
-        <collectionProp name="Asserion.test_strings">
-          <stringProp name="1312950388">&lt;title&gt;My Account&lt;/title&gt;</stringProp>
-        </collectionProp>
-        <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
-        <boolProp name="Assertion.assume_success">false</boolProp>
-        <intProp name="Assertion.test_type">2</intProp>
-      </ResponseAssertion>
-      <hashTree/>
-      <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract Address" enabled="true">
-        <stringProp name="RegexExtractor.useHeaders">false</stringProp>
-        <stringProp name="RegexExtractor.refname">addressId</stringProp>
-        <stringProp name="RegexExtractor.regex">customer/address/edit/id/([^'"]+)/</stringProp>
-        <stringProp name="RegexExtractor.template">$1$</stringProp>
-        <stringProp name="RegexExtractor.default"/>
-        <stringProp name="RegexExtractor.match_number">1</stringProp>
-      </RegexExtractor>
+      <com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor guiclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.gui.JSONPathExtractorGui" testclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor" testname="jp@gc - JSON Path Extractor" enabled="true">
+        <stringProp name="VAR">cart_id</stringProp>
+        <stringProp name="JSONPATH">$</stringProp>
+        <stringProp name="DEFAULT"/>
+        <stringProp name="VARIABLE"/>
+        <stringProp name="SUBJECT">BODY</stringProp>
+      </com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor>
       <hashTree/>
-      <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert addressId extracted" enabled="true">
+      <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert Guest Cart Id extracted" enabled="true">
         <collectionProp name="Asserion.test_strings">
           <stringProp name="2845929">^.+$</stringProp>
         </collectionProp>
@@ -25549,33 +16082,26 @@ vars.put("customer_email", emails_list.get(emails_index));</stringProp>
         <boolProp name="Assertion.assume_success">false</boolProp>
         <intProp name="Assertion.test_type">1</intProp>
         <stringProp name="Assertion.scope">variable</stringProp>
-        <stringProp name="Scope.variable">addressId</stringProp>
+        <stringProp name="Scope.variable">cart_id</stringProp>
       </ResponseAssertion>
       <hashTree/>
     </hashTree>
-    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Load Customer Private Data" enabled="true">
-      <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
+  
+    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Add product to Guest Cart" enabled="true">
+      <boolProp name="HTTPSampler.postBodyRaw">true</boolProp>
+      <elementProp name="HTTPsampler.Arguments" elementType="Arguments">
         <collectionProp name="Arguments.arguments">
-          <elementProp name="sections" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value"/>
-            <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">sections</stringProp>
-          </elementProp>
-          <elementProp name="update_section_id" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">false</stringProp>
-            <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">update_section_id</stringProp>
-          </elementProp>
-          <elementProp name="_" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">${__time()}${__Random(1,1000000)}</stringProp>
+          <elementProp name="" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">false</boolProp>
+            <stringProp name="Argument.value">{&#xD;
+	"cartItem": {&#xD;
+		"sku": "${product_sku}",&#xD;
+		"qty":"1",&#xD;
+		"quote_id":"${cart_id}"&#xD;
+	}&#xD;
+}&#xD;
+</stringProp>
             <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">_</stringProp>
           </elementProp>
         </collectionProp>
       </elementProp>
@@ -25585,128 +16111,39 @@ vars.put("customer_email", emails_list.get(emails_index));</stringProp>
       <stringProp name="HTTPSampler.response_timeout"/>
       <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
       <stringProp name="HTTPSampler.contentEncoding"/>
-      <stringProp name="HTTPSampler.path">${base_path}customer/section/load/</stringProp>
-      <stringProp name="HTTPSampler.method">GET</stringProp>
+      <stringProp name="HTTPSampler.path">${base_path}rest/default/V1/guest-carts/${cart_id}/items</stringProp>
+      <stringProp name="HTTPSampler.method">POST</stringProp>
       <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
       <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
       <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
       <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
       <boolProp name="HTTPSampler.monitor">false</boolProp>
       <stringProp name="HTTPSampler.embedded_url_re"/>
-    </HTTPSamplerProxy>
-    <hashTree/>
-  
-    <LoopController guiclass="LoopControlPanel" testclass="LoopController" testname="Review Simple Products" enabled="true">
-      <boolProp name="LoopController.continue_forever">true</boolProp>
-      <stringProp name="LoopController.loops">1</stringProp>
-    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/loop_controller.jmx</stringProp></LoopController>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/api/add_product_to_guest_cart_hardwired_sku.jmx</stringProp></HTTPSamplerProxy>
     <hashTree>
-      <CounterConfig guiclass="CounterConfigGui" testclass="CounterConfig" testname="Counter" enabled="true">
-        <stringProp name="CounterConfig.start">1</stringProp>
-        <stringProp name="CounterConfig.end"/>
-        <stringProp name="CounterConfig.incr">1</stringProp>
-        <stringProp name="CounterConfig.name">_counter</stringProp>
-        <stringProp name="CounterConfig.format"/>
-        <boolProp name="CounterConfig.per_user">true</boolProp>
-        <boolProp name="CounterConfig.reset_on_tg_iteration">true</boolProp>
-      </CounterConfig>
+      <com.atlantbh.jmeter.plugins.jsonutils.jsonpathassertion.JSONPathAssertion guiclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathassertion.gui.JSONPathAssertionGui" testclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathassertion.JSONPathAssertion" testname="jp@gc - JSON Path Assertion" enabled="true">
+        <stringProp name="JSON_PATH">$.quote_id</stringProp>
+        <stringProp name="EXPECTED_VALUE">^[a-z0-9-]+$</stringProp>
+        <boolProp name="JSONVALIDATION">true</boolProp>
+        <boolProp name="EXPECT_NULL">false</boolProp>
+        <boolProp name="INVERT">false</boolProp>
+      </com.atlantbh.jmeter.plugins.jsonutils.jsonpathassertion.JSONPathAssertion>
       <hashTree/>
-    
-    <BeanShellSampler guiclass="BeanShellSamplerGui" testclass="BeanShellSampler" testname="SetUp - Prepare Simple Product Data" enabled="true">
-      <stringProp name="BeanShellSampler.query">
-import java.util.Random;
-
-Random random = vars.getObject("randomIntGenerator");
-number = random.nextInt(props.get("simple_products_list").size());
-product = props.get("simple_products_list").get(number);
-
-vars.put("product_url_key", product.get("url_key"));
-vars.put("product_id", product.get("id"));
-vars.put("product_name", product.get("title"));
-vars.put("product_uenc", product.get("uenc"));
-vars.put("product_sku", product.get("sku"));
-      </stringProp>
-      <stringProp name="BeanShellSampler.filename"/>
-      <stringProp name="BeanShellSampler.parameters"/>
-      <boolProp name="BeanShellSampler.resetInterpreter">true</boolProp>
-    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/product_browsing_and_adding_items_to_the_cart/simple_products_setup.jmx</stringProp></BeanShellSampler>
-    <hashTree/>
+    </hashTree>
   
-        <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Simple Product ${_counter} View" enabled="true">
-            <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
-                <collectionProp name="Arguments.arguments"/>
-            </elementProp>
-            <stringProp name="HTTPSampler.domain"/>
-            <stringProp name="HTTPSampler.port"/>
-            <stringProp name="HTTPSampler.connect_timeout"/>
-            <stringProp name="HTTPSampler.response_timeout"/>
-            <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
-            <stringProp name="HTTPSampler.contentEncoding"/>
-            <stringProp name="HTTPSampler.path">${base_path}${product_url_key}${url_suffix}</stringProp>
-            <stringProp name="HTTPSampler.method">GET</stringProp>
-            <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
-            <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
-            <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
-            <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
-            <boolProp name="HTTPSampler.monitor">false</boolProp>
-            <stringProp name="HTTPSampler.embedded_url_re"/>
-        <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/product_browsing_and_adding_items_to_the_cart/product_view.jmx</stringProp></HTTPSamplerProxy>
-        <hashTree>
-            <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Response Assertion" enabled="true">
-                <collectionProp name="Asserion.test_strings">
-                    <stringProp name="-1787050162">&lt;span&gt;In stock&lt;/span&gt;</stringProp>
-                </collectionProp>
-                <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
-                <boolProp name="Assertion.assume_success">false</boolProp>
-                <intProp name="Assertion.test_type">2</intProp>
-            </ResponseAssertion>
-            <hashTree/>
-        </hashTree>
-    
-    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Simple Product 1 Rate and Review" enabled="true">
-      <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
+    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Add Gift Message to Guest Cart" enabled="true">
+      <boolProp name="HTTPSampler.postBodyRaw">true</boolProp>
+      <elementProp name="HTTPsampler.Arguments" elementType="Arguments">
         <collectionProp name="Arguments.arguments">
-          <elementProp name="form_key" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">${form_key}</stringProp>
-            <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">form_key</stringProp>
-          </elementProp>
-          <elementProp name="ratings[1]" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">3</stringProp>
-            <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">ratings[1]</stringProp>
-          </elementProp>
-          <elementProp name="validate_rating" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value"/>
-            <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">validate_rating</stringProp>
-          </elementProp>
-          <elementProp name="nickname" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">FirstName</stringProp>
-            <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">nickname</stringProp>
-          </elementProp>
-          <elementProp name="title" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">Some Review Title</stringProp>
-            <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">title</stringProp>
-          </elementProp>
-          <elementProp name="detail" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">Some Review Text</stringProp>
+          <elementProp name="" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">false</boolProp>
+            <stringProp name="Argument.value">{&#xD;
+	"sender": "John Doe",&#xD;
+	"recipient": "Jane Roe",&#xD;
+	"giftMessage": "Gift Message Text"&#xD;
+}&#xD;
+</stringProp>
             <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">detail</stringProp>
           </elementProp>
         </collectionProp>
       </elementProp>
@@ -25716,7 +16153,7 @@ vars.put("product_sku", product.get("sku"));
       <stringProp name="HTTPSampler.response_timeout"/>
       <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
       <stringProp name="HTTPSampler.contentEncoding"/>
-      <stringProp name="HTTPSampler.path">${base_path}review/product/post/id/${product_id}</stringProp>
+      <stringProp name="HTTPSampler.path">${base_path}rest/default/V1/guest-carts/${cart_id}/gift-message</stringProp>
       <stringProp name="HTTPSampler.method">POST</stringProp>
       <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
       <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
@@ -25724,42 +16161,26 @@ vars.put("product_sku", product.get("sku"));
       <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
       <boolProp name="HTTPSampler.monitor">false</boolProp>
       <stringProp name="HTTPSampler.embedded_url_re"/>
-    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/product_review/product_review.jmx</stringProp></HTTPSamplerProxy>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/api/add_gift_message_to_guest_cart.jmx</stringProp></HTTPSamplerProxy>
     <hashTree>
-      <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Response Assertion" enabled="true">
-        <collectionProp name="Asserion.test_strings">
-          <stringProp name="-1606201635">HTTP/1.1 200 OK</stringProp>
-        </collectionProp>
-        <stringProp name="Assertion.test_field">Assertion.response_headers</stringProp>
-        <boolProp name="Assertion.assume_success">false</boolProp>
-        <intProp name="Assertion.test_type">16</intProp>
-      </ResponseAssertion>
+      <com.atlantbh.jmeter.plugins.jsonutils.jsonpathassertion.JSONPathAssertion guiclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathassertion.gui.JSONPathAssertionGui" testclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathassertion.JSONPathAssertion" testname="jp@gc - JSON Path Assertion" enabled="true">
+        <stringProp name="JSON_PATH">$</stringProp>
+        <stringProp name="EXPECTED_VALUE">true</stringProp>
+        <boolProp name="JSONVALIDATION">true</boolProp>
+        <boolProp name="EXPECT_NULL">false</boolProp>
+        <boolProp name="INVERT">false</boolProp>
+      </com.atlantbh.jmeter.plugins.jsonutils.jsonpathassertion.JSONPathAssertion>
       <hashTree/>
     </hashTree>
   
-    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Load Review Section" enabled="true">
-      <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
+    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Checkout Estimate Shipping Methods" enabled="true">
+      <boolProp name="HTTPSampler.postBodyRaw">true</boolProp>
+      <elementProp name="HTTPsampler.Arguments" elementType="Arguments">
         <collectionProp name="Arguments.arguments">
-          <elementProp name="sections" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">review,messages</stringProp>
-            <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">sections</stringProp>
-          </elementProp>
-          <elementProp name="update_section_id" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">false</stringProp>
-            <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">update_section_id</stringProp>
-          </elementProp>
-          <elementProp name="_" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">${__time()}${__Random(1,1000000)}</stringProp>
+          <elementProp name="" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">false</boolProp>
+            <stringProp name="Argument.value">{"address":{"country_id":"US","postcode":"95630"}}</stringProp>
             <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">_</stringProp>
           </elementProp>
         </collectionProp>
       </elementProp>
@@ -25769,28 +16190,58 @@ vars.put("product_sku", product.get("sku"));
       <stringProp name="HTTPSampler.response_timeout"/>
       <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
       <stringProp name="HTTPSampler.contentEncoding"/>
-      <stringProp name="HTTPSampler.path">${base_path}customer/section/load/</stringProp>
-      <stringProp name="HTTPSampler.method">GET</stringProp>
+      <stringProp name="HTTPSampler.path">${base_path}rest/default/V1/guest-carts/${cart_id}/estimate-shipping-methods</stringProp>
+      <stringProp name="HTTPSampler.method">POST</stringProp>
       <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
       <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
       <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
       <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
       <boolProp name="HTTPSampler.monitor">false</boolProp>
       <stringProp name="HTTPSampler.embedded_url_re"/>
-    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/product_review/load_review.jmx</stringProp></HTTPSamplerProxy>
-    <hashTree/>
-  
-    <TestAction guiclass="TestActionGui" testclass="TestAction" testname="Product Rating and Review - Pause" enabled="true">
-      <intProp name="ActionProcessor.action">1</intProp>
-      <intProp name="ActionProcessor.target">0</intProp>
-      <stringProp name="ActionProcessor.duration">${__javaScript(Math.round(${reviewDelay}*1000))}</stringProp>
-    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/product_review/product_review_pause.jmx</stringProp></TestAction>
-    <hashTree/>
-  </hashTree>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/guest_checkout/checkout_estimate_shipping_methods_with_postal_code.jmx</stringProp></HTTPSamplerProxy>
+    <hashTree>
+      <HeaderManager guiclass="HeaderPanel" testclass="HeaderManager" testname="HTTP Header Manager" enabled="true">
+        <collectionProp name="HeaderManager.headers">
+          <elementProp name="" elementType="Header">
+            <stringProp name="Header.name">Referer</stringProp>
+            <stringProp name="Header.value">${base_path}checkout/onepage/</stringProp>
+          </elementProp>
+          <elementProp name="Content-Type" elementType="Header">
+            <stringProp name="Header.name">Content-Type</stringProp>
+            <stringProp name="Header.value">application/json; charset=UTF-8</stringProp>
+          </elementProp>
+          <elementProp name="X-Requested-With" elementType="Header">
+            <stringProp name="Header.name">X-Requested-With</stringProp>
+            <stringProp name="Header.value">XMLHttpRequest</stringProp>
+          </elementProp>
+          <elementProp name="Accept" elementType="Header">
+            <stringProp name="Header.name">Accept</stringProp>
+            <stringProp name="Header.value">application/json</stringProp>
+          </elementProp>
+        </collectionProp>
+      </HeaderManager>
+      <hashTree/>
+      <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert success" enabled="true">
+        <collectionProp name="Asserion.test_strings">
+          <stringProp name="-1224567411">"available":true</stringProp>
+        </collectionProp>
+        <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
+        <boolProp name="Assertion.assume_success">false</boolProp>
+        <intProp name="Assertion.test_type">2</intProp>
+      </ResponseAssertion>
+      <hashTree/>
+    </hashTree>
   
-    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Logout" enabled="true">
-      <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
-        <collectionProp name="Arguments.arguments"/>
+    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Checkout Billing/Shipping Information" enabled="true">
+      <boolProp name="HTTPSampler.postBodyRaw">true</boolProp>
+      <elementProp name="HTTPsampler.Arguments" elementType="Arguments">
+        <collectionProp name="Arguments.arguments">
+          <elementProp name="" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">false</boolProp>
+            <stringProp name="Argument.value">{"addressInformation":{"shipping_address":{"countryId":"US","regionId":"12","regionCode":"CA","region":"California","street":["10441 Jefferson Blvd ste 200"],"company":"","telephone":"3109450345","fax":"","postcode":"90232","city":"Culver City","firstname":"Name","lastname":"Lastname"},"shipping_method_code":"flatrate","shipping_carrier_code":"flatrate"}}</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+          </elementProp>
+        </collectionProp>
       </elementProp>
       <stringProp name="HTTPSampler.domain"/>
       <stringProp name="HTTPSampler.port"/>
@@ -25798,81 +16249,55 @@ vars.put("product_sku", product.get("sku"));
       <stringProp name="HTTPSampler.response_timeout"/>
       <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
       <stringProp name="HTTPSampler.contentEncoding"/>
-      <stringProp name="HTTPSampler.path">${base_path}customer/account/logout/</stringProp>
-      <stringProp name="HTTPSampler.method">GET</stringProp>
+      <stringProp name="HTTPSampler.path">${base_path}rest/default/V1/guest-carts/${cart_id}/shipping-information</stringProp>
+      <stringProp name="HTTPSampler.method">POST</stringProp>
       <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
       <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
       <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
       <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
       <boolProp name="HTTPSampler.monitor">false</boolProp>
       <stringProp name="HTTPSampler.embedded_url_re"/>
-    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/common/logout.jmx</stringProp></HTTPSamplerProxy>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/guest_checkout/checkout_billing_shipping_information.jmx</stringProp></HTTPSamplerProxy>
     <hashTree>
+      <HeaderManager guiclass="HeaderPanel" testclass="HeaderManager" testname="HTTP Header Manager" enabled="true">
+        <collectionProp name="HeaderManager.headers">
+          <elementProp name="" elementType="Header">
+            <stringProp name="Header.name">Referer</stringProp>
+            <stringProp name="Header.value">${base_path}checkout/onepage/</stringProp>
+          </elementProp>
+          <elementProp name="Content-Type" elementType="Header">
+            <stringProp name="Header.name">Content-Type</stringProp>
+            <stringProp name="Header.value">application/json; charset=UTF-8</stringProp>
+          </elementProp>
+          <elementProp name="X-Requested-With" elementType="Header">
+            <stringProp name="Header.name">X-Requested-With</stringProp>
+            <stringProp name="Header.value">XMLHttpRequest</stringProp>
+          </elementProp>
+          <elementProp name="Accept" elementType="Header">
+            <stringProp name="Header.name">Accept</stringProp>
+            <stringProp name="Header.value">application/json</stringProp>
+          </elementProp>
+        </collectionProp>
+      </HeaderManager>
+      <hashTree/>
       <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert success" enabled="true">
         <collectionProp name="Asserion.test_strings">
-          <stringProp name="1723813687">You are signed out.</stringProp>
+          <stringProp name="-1494218646">{"payment_methods":</stringProp>
         </collectionProp>
         <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
         <boolProp name="Assertion.assume_success">false</boolProp>
-        <intProp name="Assertion.test_type">2</intProp>
-      </ResponseAssertion>
-      <hashTree/>
-    </hashTree>
-  </hashTree>
-
-  
-    <ThroughputController guiclass="ThroughputControllerGui" testclass="ThroughputController" testname="API" enabled="true">
-      <intProp name="ThroughputController.style">1</intProp>
-      <boolProp name="ThroughputController.perThread">false</boolProp>
-      <intProp name="ThroughputController.maxThroughput">1</intProp>
-      <stringProp name="ThroughputController.percentThroughput">${apiBasePercentage}</stringProp>
-    <stringProp name="TestPlan.comments">mpaf/tool/fragments/_system/scenario_controller_tmpl.jmx</stringProp></ThroughputController>
-    <hashTree>
-        <JSR223PreProcessor guiclass="TestBeanGUI" testclass="JSR223PreProcessor" testname="Set Test Label" enabled="true">
-            <stringProp name="script">
-var testLabel = "${testLabel}" ? " (${testLabel})" : "";
-if (testLabel
-    &amp;&amp; sampler.getClass().getName() == 'org.apache.jmeter.protocol.http.sampler.HTTPSamplerProxy'
-) {
-    if (sampler.getName().indexOf(testLabel) == -1) {
-       sampler.setName(sampler.getName() + testLabel);
-    }
-} else if (sampler.getName().indexOf("SetUp - ") == -1) {
-    sampler.setName("SetUp - " + sampler.getName());
-}
-            </stringProp>
-            <stringProp name="scriptLanguage">javascript</stringProp>
-        <stringProp name="TestPlan.comments">mpaf/tool/fragments/_system/setup_label.jmx</stringProp></JSR223PreProcessor>
-        <hashTree/>
-        <BeanShellSampler guiclass="BeanShellSamplerGui" testclass="BeanShellSampler" testname="SetUp - Set Label" enabled="true">
-            <stringProp name="BeanShellSampler.query">
-                vars.put("testLabel", "API");
-            </stringProp>
-            <boolProp name="BeanShellSampler.resetInterpreter">true</boolProp>
-        </BeanShellSampler>
-        <hashTree/>
-    
-    <HeaderManager guiclass="HeaderPanel" testclass="HeaderManager" testname="HTTP Header Manager" enabled="true">
-      <collectionProp name="HeaderManager.headers">
-        <elementProp name="" elementType="Header">
-          <stringProp name="Header.name">Content-Type</stringProp>
-          <stringProp name="Header.value">application/json</stringProp>
-        </elementProp>
-        <elementProp name="" elementType="Header">
-          <stringProp name="Header.name">Accept</stringProp>
-          <stringProp name="Header.value">*/*</stringProp>
-        </elementProp>
-      </collectionProp>
-    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/api/header_manager_before_token.jmx</stringProp></HeaderManager>
-    <hashTree/>
+        <intProp name="Assertion.test_type">2</intProp>
+      </ResponseAssertion>
+      <hashTree/>
+    </hashTree>
   
-    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="SetUp - Admin Token Retrieval" enabled="true">
+    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Checkout Payment Info/Place Order" enabled="true">
       <boolProp name="HTTPSampler.postBodyRaw">true</boolProp>
       <elementProp name="HTTPsampler.Arguments" elementType="Arguments">
         <collectionProp name="Arguments.arguments">
           <elementProp name="" elementType="HTTPArgument">
             <boolProp name="HTTPArgument.always_encode">false</boolProp>
-            <stringProp name="Argument.value">{"username":"${admin_user}","password":"${admin_password}"}</stringProp>
+            <stringProp name="Argument.value">{"cartId":"${cart_id}","email":"test@example.com","paymentMethod":{"method":"checkmo","po_number":null,"additional_data":null},"billingAddress":{"countryId":"US","regionId":"12","regionCode":"CA","region":"California","street":["10441 Jefferson Blvd ste 200"],"company":"","telephone":"3109450345","fax":"","postcode":"90232","city":"Culver City","firstname":"Name","lastname":"Lastname","save_in_address_book":0}}</stringProp>
             <stringProp name="Argument.metadata">=</stringProp>
           </elementProp>
         </collectionProp>
@@ -25883,7 +16308,7 @@ if (testLabel
       <stringProp name="HTTPSampler.response_timeout"/>
       <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
       <stringProp name="HTTPSampler.contentEncoding"/>
-      <stringProp name="HTTPSampler.path">${base_path}rest/V1/integration/admin/token</stringProp>
+      <stringProp name="HTTPSampler.path">${base_path}rest/default/V1/guest-carts/${cart_id}/payment-information</stringProp>
       <stringProp name="HTTPSampler.method">POST</stringProp>
       <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
       <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
@@ -25891,44 +16316,85 @@ if (testLabel
       <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
       <boolProp name="HTTPSampler.monitor">false</boolProp>
       <stringProp name="HTTPSampler.embedded_url_re"/>
-    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/api/admin_token_retrieval.jmx</stringProp></HTTPSamplerProxy>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/api/checkout_payment_info_place_order.jmx</stringProp></HTTPSamplerProxy>
     <hashTree>
-      <com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor guiclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.gui.JSONPathExtractorGui" testclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor" testname="jp@gc - JSON Path Extractor" enabled="true">
-        <stringProp name="VAR">admin_token</stringProp>
+      <HeaderManager guiclass="HeaderPanel" testclass="HeaderManager" testname="HTTP Header Manager" enabled="true">
+        <collectionProp name="HeaderManager.headers">
+          <elementProp name="" elementType="Header">
+            <stringProp name="Header.name">Referer</stringProp>
+            <stringProp name="Header.value">${base_path}checkout/onepage/</stringProp>
+          </elementProp>
+          <elementProp name="Content-Type" elementType="Header">
+            <stringProp name="Header.name">Content-Type</stringProp>
+            <stringProp name="Header.value">application/json; charset=UTF-8</stringProp>
+          </elementProp>
+          <elementProp name="X-Requested-With" elementType="Header">
+            <stringProp name="Header.name">X-Requested-With</stringProp>
+            <stringProp name="Header.value">XMLHttpRequest</stringProp>
+          </elementProp>
+          <elementProp name="Accept" elementType="Header">
+            <stringProp name="Header.name">Accept</stringProp>
+            <stringProp name="Header.value">application/json</stringProp>
+          </elementProp>
+        </collectionProp>
+      </HeaderManager>
+      <hashTree/>
+      <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert success" enabled="true">
+        <collectionProp name="Asserion.test_strings">
+          <stringProp name="-297987887">"[0-9]+"</stringProp>
+        </collectionProp>
+        <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
+        <boolProp name="Assertion.assume_success">false</boolProp>
+        <intProp name="Assertion.test_type">2</intProp>
+      </ResponseAssertion>
+      <hashTree/>
+      <com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor guiclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.gui.JSONPathExtractorGui" testclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor" testname="Extract cart id" enabled="true">
+        <stringProp name="VAR">order_id</stringProp>
         <stringProp name="JSONPATH">$</stringProp>
         <stringProp name="DEFAULT"/>
         <stringProp name="VARIABLE"/>
         <stringProp name="SUBJECT">BODY</stringProp>
       </com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor>
       <hashTree/>
-      <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert token not null" enabled="true">
+      <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Response Assertion" enabled="true">
         <collectionProp name="Asserion.test_strings">
-          <stringProp name="484395188">^[a-z0-9-]+$</stringProp>
+          <stringProp name="89649215">^\d+$</stringProp>
         </collectionProp>
         <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
         <boolProp name="Assertion.assume_success">false</boolProp>
         <intProp name="Assertion.test_type">1</intProp>
         <stringProp name="Assertion.scope">variable</stringProp>
-        <stringProp name="Scope.variable">admin_token</stringProp>
+        <stringProp name="Scope.variable">order_id</stringProp>
       </ResponseAssertion>
       <hashTree/>
     </hashTree>
-  
-    <HeaderManager guiclass="HeaderPanel" testclass="HeaderManager" testname="HTTP Header Manager" enabled="true">
-      <collectionProp name="HeaderManager.headers">
-        <elementProp name="" elementType="Header">
-          <stringProp name="Header.name">Authorization</stringProp>
-          <stringProp name="Header.value">Bearer ${admin_token}</stringProp>
-        </elementProp>
-      </collectionProp>
-    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/api/header_manager.jmx</stringProp></HeaderManager>
-    <hashTree/>
-  
-    <ThroughputController guiclass="ThroughputControllerGui" testclass="ThroughputController" testname="API Create Customer" enabled="true">
+  </hashTree>
+
+  </hashTree>
+
+  </hashTree>
+
+    
+        <ThreadGroup guiclass="ThreadGroupGui" testclass="ThreadGroup" testname="One Thread Scenarios (Vulnerable to deadlocks)" enabled="true">
+            <stringProp name="ThreadGroup.on_sample_error">continue</stringProp>
+            <elementProp name="ThreadGroup.main_controller" elementType="LoopController" guiclass="LoopControlPanel" testclass="LoopController" testname="Loop Controller" enabled="true">
+                <boolProp name="LoopController.continue_forever">false</boolProp>
+                <stringProp name="LoopController.loops">${loops}</stringProp>
+            </elementProp>
+            <stringProp name="ThreadGroup.num_threads">${deadLocksPoolUsers}</stringProp>
+            <stringProp name="ThreadGroup.ramp_time">${ramp_period}</stringProp>
+            <longProp name="ThreadGroup.start_time">1505803944000</longProp>
+            <longProp name="ThreadGroup.end_time">1505803944000</longProp>
+            <boolProp name="ThreadGroup.scheduler">false</boolProp>
+            <stringProp name="ThreadGroup.duration"/>
+            <stringProp name="ThreadGroup.delay"/>
+        <stringProp name="TestPlan.comments">mpaf/tool/fragments/_system/thread_group.jmx</stringProp></ThreadGroup>
+        <hashTree>
+    <ThroughputController guiclass="ThroughputControllerGui" testclass="ThroughputController" testname="Product Grid Mass Actions" enabled="true">
       <intProp name="ThroughputController.style">1</intProp>
       <boolProp name="ThroughputController.perThread">false</boolProp>
       <intProp name="ThroughputController.maxThroughput">1</intProp>
-      <stringProp name="ThroughputController.percentThroughput">100</stringProp>
+      <stringProp name="ThroughputController.percentThroughput">${productGridMassActionPercentage}</stringProp>
     <stringProp name="TestPlan.comments">mpaf/tool/fragments/_system/scenario_controller_tmpl.jmx</stringProp></ThroughputController>
     <hashTree>
         <JSR223PreProcessor guiclass="TestBeanGUI" testclass="JSR223PreProcessor" testname="Set Test Label" enabled="true">
@@ -25949,30 +16415,99 @@ if (testLabel
         <hashTree/>
         <BeanShellSampler guiclass="BeanShellSamplerGui" testclass="BeanShellSampler" testname="SetUp - Set Label" enabled="true">
             <stringProp name="BeanShellSampler.query">
-                vars.put("testLabel", "API Create Customer");
+                vars.put("testLabel", "Product Grid Mass Actions");
             </stringProp>
             <boolProp name="BeanShellSampler.resetInterpreter">true</boolProp>
         </BeanShellSampler>
         <hashTree/>
     
-    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Create customer" enabled="true">
-      <boolProp name="HTTPSampler.postBodyRaw">true</boolProp>
-      <elementProp name="HTTPsampler.Arguments" elementType="Arguments">
-        <collectionProp name="Arguments.arguments">
-          <elementProp name="" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">false</boolProp>
-            <stringProp name="Argument.value">{&#xD;
-    "customer": {&#xD;
-&#xD;
-        "email": "customer_${__time()}-${__threadNum}-${__Random(1,1000000)}@example.com",&#xD;
-        "firstname": "test_${__time()}-${__threadNum}-${__Random(1,1000000)}",&#xD;
-        "lastname": "Doe"&#xD;
-    },&#xD;
-    "password": "test@123"&#xD;
-}</stringProp>
-            <stringProp name="Argument.metadata">=</stringProp>
-          </elementProp>
-        </collectionProp>
+        <JSR223PostProcessor guiclass="TestBeanGUI" testclass="JSR223PostProcessor" testname="Get admin form key PostProcessor" enabled="true">
+        <stringProp name="script">
+        function getFormKeyFromResponse()
+        {
+            var url = prev.getUrlAsString(),
+            responseCode =  prev.getResponseCode(),
+            formKey = null;
+            searchPattern = /var FORM_KEY = '(.+)'/;
+            if (responseCode == "200" &amp;&amp; url) {
+                response = prev.getResponseDataAsString();
+                formKey = response  &amp;&amp; response.match(searchPattern) ? response.match(searchPattern)[1] : null;
+            }
+            return formKey;
+        }
+
+        formKey = vars.get("form_key_storage");
+
+	   currentFormKey = getFormKeyFromResponse();
+
+	   if (currentFormKey != null &amp;&amp; currentFormKey != formKey) {
+		  vars.put("form_key_storage", currentFormKey);
+	   }
+        </stringProp>
+        <stringProp name="scriptLanguage">javascript</stringProp>
+        <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin/handle_admin_form_key.jmx</stringProp></JSR223PostProcessor>
+        <hashTree/>
+        <JSR223PreProcessor guiclass="TestBeanGUI" testclass="JSR223PreProcessor" testname="Set admin form key PreProcessor" enabled="true">
+            <stringProp name="script">
+                formKey =  vars.get("form_key_storage");
+                if (formKey
+                    &amp;&amp; sampler.getClass().getName() == 'org.apache.jmeter.protocol.http.sampler.HTTPSamplerProxy'
+                    &amp;&amp; sampler.getMethod() == "POST")
+                    {
+                        arguments = sampler.getArguments();
+                        for (i=0; i&lt;arguments.getArgumentCount(); i++)
+                        {
+                            argument = arguments.getArgument(i);
+                            if (argument.getName() == 'form_key' &amp;&amp; argument.getValue() != formKey) {
+                            log.info("admin form key updated: " + argument.getValue() + " =&gt; " + formKey);
+                            argument.setValue(formKey);
+                        }
+                    }
+                }
+            </stringProp>
+            <stringProp name="scriptLanguage">javascript</stringProp>
+        </JSR223PreProcessor>
+        <hashTree/>
+    
+    <CookieManager guiclass="CookiePanel" testclass="CookieManager" testname="HTTP Cookie Manager" enabled="true">
+      <collectionProp name="CookieManager.cookies"/>
+      <boolProp name="CookieManager.clearEachIteration">false</boolProp>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/http_cookie_manager_without_clear_each_iteration.jmx</stringProp></CookieManager>
+    <hashTree/>
+  
+    <GenericController guiclass="LogicControllerGui" testclass="GenericController" testname="Admin Login" enabled="true">
+  <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/simple_controller.jmx</stringProp>
+</GenericController>
+    <hashTree>
+    <CriticalSectionController guiclass="CriticalSectionControllerGui" testclass="CriticalSectionController" testname="Admin Login Lock" enabled="true">
+        <stringProp name="CriticalSectionController.lockName">get-admin-email</stringProp>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/lock_controller.jmx</stringProp></CriticalSectionController>
+    <hashTree>
+    
+    <BeanShellSampler guiclass="BeanShellSamplerGui" testclass="BeanShellSampler" testname="SetUp - Get Admin Email" enabled="true">
+      <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/get_admin_email.jmx</stringProp>
+      <stringProp name="BeanShellSampler.query">
+adminUserList = props.get("adminUserList");
+adminUser = adminUserList.poll();
+if (adminUser == null) {
+  SampleResult.setResponseMessage("adminUser list is empty");
+  SampleResult.setResponseData("adminUser list is empty","UTF-8");
+  IsSuccess=false;
+  SampleResult.setSuccessful(false);
+  SampleResult.setStopThread(true);
+}
+vars.put("admin_user", adminUser);
+      </stringProp>
+      <stringProp name="BeanShellSampler.filename"/>
+      <stringProp name="BeanShellSampler.parameters"/>
+      <boolProp name="BeanShellSampler.resetInterpreter">true</boolProp>
+    </BeanShellSampler>
+    <hashTree/>
+  </hashTree>
+  
+    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="SetUp - Login" enabled="true">
+      <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
+        <collectionProp name="Arguments.arguments"/>
       </elementProp>
       <stringProp name="HTTPSampler.domain"/>
       <stringProp name="HTTPSampler.port"/>
@@ -25980,40 +16515,80 @@ if (testLabel
       <stringProp name="HTTPSampler.response_timeout"/>
       <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
       <stringProp name="HTTPSampler.contentEncoding"/>
-      <stringProp name="HTTPSampler.path">${base_path}rest/default/V1/customers</stringProp>
-      <stringProp name="HTTPSampler.method">POST</stringProp>
+      <stringProp name="HTTPSampler.path">${base_path}${admin_path}</stringProp>
+      <stringProp name="HTTPSampler.method">GET</stringProp>
       <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
       <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
       <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
       <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
       <boolProp name="HTTPSampler.monitor">false</boolProp>
       <stringProp name="HTTPSampler.embedded_url_re"/>
-    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/api/create_customer.jmx</stringProp></HTTPSamplerProxy>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_login/admin_login.jmx</stringProp></HTTPSamplerProxy>
     <hashTree>
-      <com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor guiclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.gui.JSONPathExtractorGui" testclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor" testname="Extract customer id" enabled="true">
-        <stringProp name="VAR">customer_id</stringProp>
-        <stringProp name="JSONPATH">$.id</stringProp>
-        <stringProp name="DEFAULT"/>
-        <stringProp name="VARIABLE"/>
-        <stringProp name="SUBJECT">BODY</stringProp>
-      </com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor>
+      <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert login form shown" enabled="true">
+        <collectionProp name="Asserion.test_strings">
+          <stringProp name="-1397214398">Welcome</stringProp>
+          <stringProp name="-515240035">&lt;title&gt;Magento Admin&lt;/title&gt;</stringProp>
+        </collectionProp>
+        <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
+        <boolProp name="Assertion.assume_success">false</boolProp>
+        <intProp name="Assertion.test_type">2</intProp>
+      </ResponseAssertion>
       <hashTree/>
-      <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert customer id not null" enabled="true">
+      <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract form key" enabled="true">
+        <stringProp name="RegexExtractor.useHeaders">false</stringProp>
+        <stringProp name="RegexExtractor.refname">admin_form_key</stringProp>
+        <stringProp name="RegexExtractor.regex">&lt;input name="form_key" type="hidden" value="([^'"]+)" /&gt;</stringProp>
+        <stringProp name="RegexExtractor.template">$1$</stringProp>
+        <stringProp name="RegexExtractor.default"/>
+        <stringProp name="RegexExtractor.match_number">1</stringProp>
+      </RegexExtractor>
+      <hashTree/>
+      <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert form_key extracted" enabled="true">
         <collectionProp name="Asserion.test_strings">
-          <stringProp name="89649215">^\d+$</stringProp>
+          <stringProp name="2845929">^.+$</stringProp>
         </collectionProp>
         <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
         <boolProp name="Assertion.assume_success">false</boolProp>
         <intProp name="Assertion.test_type">1</intProp>
         <stringProp name="Assertion.scope">variable</stringProp>
-        <stringProp name="Scope.variable">customer_id</stringProp>
+        <stringProp name="Scope.variable">admin_form_key</stringProp>
       </ResponseAssertion>
       <hashTree/>
     </hashTree>
   
-    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Check customer" enabled="true">
+    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="SetUp - Login Submit Form" enabled="true">
       <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
-        <collectionProp name="Arguments.arguments"/>
+        <collectionProp name="Arguments.arguments">
+          <elementProp name="dummy" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value"/>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">dummy</stringProp>
+          </elementProp>
+          <elementProp name="form_key" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">${admin_form_key}</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">form_key</stringProp>
+          </elementProp>
+          <elementProp name="login[password]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">${admin_password}</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">login[password]</stringProp>
+          </elementProp>
+          <elementProp name="login[username]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">${admin_user}</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">login[username]</stringProp>
+          </elementProp>
+        </collectionProp>
       </elementProp>
       <stringProp name="HTTPSampler.domain"/>
       <stringProp name="HTTPSampler.port"/>
@@ -26021,7 +16596,117 @@ if (testLabel
       <stringProp name="HTTPSampler.response_timeout"/>
       <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
       <stringProp name="HTTPSampler.contentEncoding"/>
-      <stringProp name="HTTPSampler.path">${base_path}rest/default/V1/customers/${customer_id}</stringProp>
+      <stringProp name="HTTPSampler.path">${base_path}${admin_path}/admin/dashboard/</stringProp>
+      <stringProp name="HTTPSampler.method">POST</stringProp>
+      <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
+      <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
+      <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
+      <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
+      <stringProp name="HTTPSampler.implementation">Java</stringProp>
+      <boolProp name="HTTPSampler.monitor">false</boolProp>
+      <stringProp name="HTTPSampler.embedded_url_re"/>
+      <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_login/admin_login_submit_form.jmx</stringProp>
+    </HTTPSamplerProxy>
+    <hashTree>
+        <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract form key" enabled="true">
+            <stringProp name="RegexExtractor.useHeaders">false</stringProp>
+            <stringProp name="RegexExtractor.refname">admin_form_key</stringProp>
+            <stringProp name="RegexExtractor.regex">&lt;input name="form_key" type="hidden" value="([^'"]+)" /&gt;</stringProp>
+            <stringProp name="RegexExtractor.template">$1$</stringProp>
+            <stringProp name="RegexExtractor.default"/>
+            <stringProp name="RegexExtractor.match_number">1</stringProp>
+        <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_login/admin_retrieve_form_key.jmx</stringProp></RegexExtractor>
+        <hashTree/>
+    </hashTree>
+  </hashTree>
+  
+    <GenericController guiclass="LogicControllerGui" testclass="GenericController" testname="Simple Controller" enabled="true">
+  <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/simple_controller.jmx</stringProp>
+</GenericController>
+    <hashTree>
+    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Get Product Pages Count" enabled="true">
+      <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
+        <collectionProp name="Arguments.arguments">
+          <elementProp name="form_key" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">${admin_form_key}</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">form_key</stringProp>
+          </elementProp>
+          <elementProp name="namespace" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">product_listing</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">namespace</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
+          </elementProp>
+          <elementProp name="search" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value"/>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">search</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
+          </elementProp>
+          <elementProp name="filters[placeholder]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">true</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">filters[placeholder]</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
+          </elementProp>
+          <elementProp name="paging[pageSize]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">20</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">paging[pageSize]</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
+          </elementProp>
+          <elementProp name="paging[current]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">1</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">paging[current]</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
+          </elementProp>
+          <elementProp name="sorting[field]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">entity_id</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">sorting[field]</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
+          </elementProp>
+          <elementProp name="sorting[direction]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">asc</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">sorting[direction]</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
+          </elementProp>
+          <elementProp name="isAjax" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">true</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">isAjax</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
+          </elementProp>
+        </collectionProp>
+      </elementProp>
+      <stringProp name="HTTPSampler.domain"/>
+      <stringProp name="HTTPSampler.port"/>
+      <stringProp name="HTTPSampler.connect_timeout"/>
+      <stringProp name="HTTPSampler.response_timeout"/>
+      <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
+      <stringProp name="HTTPSampler.contentEncoding"/>
+      <stringProp name="HTTPSampler.path">${base_path}${admin_path}/mui/index/render/</stringProp>
       <stringProp name="HTTPSampler.method">GET</stringProp>
       <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
       <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
@@ -26029,118 +16714,151 @@ if (testLabel
       <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
       <boolProp name="HTTPSampler.monitor">false</boolProp>
       <stringProp name="HTTPSampler.embedded_url_re"/>
-    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/api/check_customer.jmx</stringProp></HTTPSamplerProxy>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_browse_products_grid/get_product_pages_count.jmx</stringProp></HTTPSamplerProxy>
     <hashTree>
-      <com.atlantbh.jmeter.plugins.jsonutils.jsonpathassertion.JSONPathAssertion guiclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathassertion.gui.JSONPathAssertionGui" testclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathassertion.JSONPathAssertion" testname="jp@gc - JSON Path Assertion" enabled="true">
-        <stringProp name="JSON_PATH">$.id</stringProp>
-        <stringProp name="EXPECTED_VALUE">${customer_id}</stringProp>
+      <com.atlantbh.jmeter.plugins.jsonutils.jsonpathassertion.JSONPathAssertion guiclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathassertion.gui.JSONPathAssertionGui" testclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathassertion.JSONPathAssertion" testname="Assert total records is not 0" enabled="true">
+        <stringProp name="JSON_PATH">$.totalRecords</stringProp>
+        <stringProp name="EXPECTED_VALUE">0</stringProp>
         <boolProp name="JSONVALIDATION">true</boolProp>
         <boolProp name="EXPECT_NULL">false</boolProp>
-        <boolProp name="INVERT">false</boolProp>
+        <boolProp name="INVERT">true</boolProp>
       </com.atlantbh.jmeter.plugins.jsonutils.jsonpathassertion.JSONPathAssertion>
       <hashTree/>
-    </hashTree>
-  </hashTree>
+      <com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor guiclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.gui.JSONPathExtractorGui" testclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor" testname="Extract total records" enabled="true">
+        <stringProp name="VAR">products_number</stringProp>
+        <stringProp name="JSONPATH">$.totalRecords</stringProp>
+        <stringProp name="DEFAULT"/>
+        <stringProp name="VARIABLE"/>
+        <stringProp name="SUBJECT">BODY</stringProp>
+      </com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor>
+      <hashTree/>
+      <BeanShellPostProcessor guiclass="TestBeanGUI" testclass="BeanShellPostProcessor" testname="Calculate pages count" enabled="true">
+        <boolProp name="resetInterpreter">false</boolProp>
+        <stringProp name="parameters"/>
+        <stringProp name="filename"/>
+        <stringProp name="script">var productsPageSize = Integer.parseInt(vars.get("products_page_size"));
+var productsTotal = Integer.parseInt(vars.get("products_number"));
+var pageCountProducts = Math.round(productsTotal/productsPageSize);
 
+vars.put("pages_count_product", String.valueOf(pageCountProducts));</stringProp>
+      </BeanShellPostProcessor>
+      <hashTree/>
+    </hashTree>
   
-    <ThroughputController guiclass="ThroughputControllerGui" testclass="ThroughputController" testname="API Product Attribute Management" enabled="true">
-      <intProp name="ThroughputController.style">1</intProp>
-      <boolProp name="ThroughputController.perThread">false</boolProp>
-      <intProp name="ThroughputController.maxThroughput">1</intProp>
-      <stringProp name="ThroughputController.percentThroughput">100</stringProp>
-    <stringProp name="TestPlan.comments">mpaf/tool/fragments/_system/scenario_controller_tmpl.jmx</stringProp></ThroughputController>
-    <hashTree>
-        <JSR223PreProcessor guiclass="TestBeanGUI" testclass="JSR223PreProcessor" testname="Set Test Label" enabled="true">
-            <stringProp name="script">
-var testLabel = "${testLabel}" ? " (${testLabel})" : "";
-if (testLabel
-    &amp;&amp; sampler.getClass().getName() == 'org.apache.jmeter.protocol.http.sampler.HTTPSamplerProxy'
-) {
-    if (sampler.getName().indexOf(testLabel) == -1) {
-       sampler.setName(sampler.getName() + testLabel);
-    }
-} else if (sampler.getName().indexOf("SetUp - ") == -1) {
-    sampler.setName("SetUp - " + sampler.getName());
+    <BeanShellSampler guiclass="BeanShellSamplerGui" testclass="BeanShellSampler" testname="SetUp - Set Arguments" enabled="true">
+      <stringProp name="BeanShellSampler.query">
+import java.util.Random;
+Random random = new Random();
+if (${seedForRandom} &gt; 0) {
+random.setSeed(${seedForRandom});
 }
-            </stringProp>
-            <stringProp name="scriptLanguage">javascript</stringProp>
-        <stringProp name="TestPlan.comments">mpaf/tool/fragments/_system/setup_label.jmx</stringProp></JSR223PreProcessor>
-        <hashTree/>
-        <BeanShellSampler guiclass="BeanShellSamplerGui" testclass="BeanShellSampler" testname="SetUp - Set Label" enabled="true">
-            <stringProp name="BeanShellSampler.query">
-                vars.put("testLabel", "API Product Attribute Management");
-            </stringProp>
-            <boolProp name="BeanShellSampler.resetInterpreter">true</boolProp>
-        </BeanShellSampler>
-        <hashTree/>
-    
-    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Create attribute set" enabled="true">
-      <boolProp name="HTTPSampler.postBodyRaw">true</boolProp>
-      <elementProp name="HTTPsampler.Arguments" elementType="Arguments">
+var productsPageSize = Integer.parseInt(vars.get("products_page_size"));
+var totalNumberOfPages = Integer.parseInt(vars.get("pages_count_product"));
+
+// Randomly select a page.
+var randomProductsPage = random.nextInt(totalNumberOfPages) + 1;
+
+// Get the first and last product id on that page.
+var lastProductIdOnPage = randomProductsPage * productsPageSize;
+var firstProductIdOnPage = lastProductIdOnPage - productsPageSize + 1;
+
+var randomProductId1 = Math.floor(random.nextInt(productsPageSize)) + firstProductIdOnPage;
+var randomProductId2 = Math.floor(random.nextInt(productsPageSize)) + firstProductIdOnPage;
+var randomProductId3 = Math.floor(random.nextInt(productsPageSize)) + firstProductIdOnPage;
+
+vars.put("page_number", String.valueOf(randomProductsPage));
+vars.put("productId1", String.valueOf(randomProductId1));
+vars.put("productId2", String.valueOf(randomProductId2));
+vars.put("productId3", String.valueOf(randomProductId3));
+
+var randomQuantity = random.nextInt(1000) + 1;
+var randomPrice = random.nextInt(500) + 10;
+var randomVisibility = random.nextInt(4) + 1;
+
+vars.put("quantity", String.valueOf(randomQuantity));
+vars.put("price", String.valueOf(randomPrice));
+vars.put("visibility", String.valueOf(randomVisibility));
+      </stringProp>
+      <stringProp name="BeanShellSampler.filename"/>
+      <stringProp name="BeanShellSampler.parameters"/>
+      <boolProp name="BeanShellSampler.resetInterpreter">false</boolProp>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_browse_products_grid/products_grid_mass_actions/setup.jmx</stringProp></BeanShellSampler>
+    <hashTree/>
+  
+    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Select Products and Update Attributes mass action" enabled="true">
+      <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
         <collectionProp name="Arguments.arguments">
-          <elementProp name="" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">false</boolProp>
-            <stringProp name="Argument.value">{&#xD;
-    "attributeSet": {&#xD;
-        "attribute_set_name": "new_attribute_set_${__time()}-${__threadNum}-${__Random(1,1000000)}",&#xD;
-        "sort_order": 500&#xD;
-    },&#xD;
-    "skeletonId": "4"&#xD;
-}</stringProp>
+          <elementProp name="form_key" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">${admin_form_key}</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">form_key</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
+          </elementProp>
+          <elementProp name="namespace" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">product_listing</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">namespace</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
+          </elementProp>
+          <elementProp name="search" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value"/>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">search</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
+          </elementProp>
+          <elementProp name="filters[placeholder]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">true</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">filters[placeholder]</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
+          </elementProp>
+          <elementProp name="paging[pageSize]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">${products_page_size}</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">paging[pageSize]</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
+          </elementProp>
+          <elementProp name="paging[current]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">${page_number}</stringProp>
             <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">paging[current]</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
           </elementProp>
-        </collectionProp>
-      </elementProp>
-      <stringProp name="HTTPSampler.domain"/>
-      <stringProp name="HTTPSampler.port"/>
-      <stringProp name="HTTPSampler.connect_timeout"/>
-      <stringProp name="HTTPSampler.response_timeout"/>
-      <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
-      <stringProp name="HTTPSampler.contentEncoding"/>
-      <stringProp name="HTTPSampler.path">${base_path}rest/default/V1/products/attribute-sets/</stringProp>
-      <stringProp name="HTTPSampler.method">POST</stringProp>
-      <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
-      <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
-      <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
-      <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
-      <boolProp name="HTTPSampler.monitor">false</boolProp>
-      <stringProp name="HTTPSampler.embedded_url_re"/>
-    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/api/create_attribute_set.jmx</stringProp></HTTPSamplerProxy>
-    <hashTree>
-      <com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor guiclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.gui.JSONPathExtractorGui" testclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor" testname="Extract attribute_set_id" enabled="true">
-        <stringProp name="VAR">attribute_set_id</stringProp>
-        <stringProp name="JSONPATH">$.attribute_set_id</stringProp>
-        <stringProp name="DEFAULT"/>
-        <stringProp name="VARIABLE"/>
-        <stringProp name="SUBJECT">BODY</stringProp>
-      </com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor>
-      <hashTree/>
-      <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert attribute_set_id not null" enabled="true">
-        <collectionProp name="Asserion.test_strings">
-          <stringProp name="89649215">^\d+$</stringProp>
-        </collectionProp>
-        <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
-        <boolProp name="Assertion.assume_success">false</boolProp>
-        <intProp name="Assertion.test_type">1</intProp>
-        <stringProp name="Assertion.scope">variable</stringProp>
-        <stringProp name="Scope.variable">attribute_set_id</stringProp>
-      </ResponseAssertion>
-      <hashTree/>
-    </hashTree>
-  
-    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Create attribute group" enabled="true">
-      <boolProp name="HTTPSampler.postBodyRaw">true</boolProp>
-      <elementProp name="HTTPsampler.Arguments" elementType="Arguments">
-        <collectionProp name="Arguments.arguments">
-          <elementProp name="" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">false</boolProp>
-            <stringProp name="Argument.value">{&#xD;
-    "group": {&#xD;
-        "attribute_group_name": "empty_attribute_group_${__time()}-${__threadNum}-${__Random(1,1000000)}",&#xD;
-        "attribute_set_id": ${attribute_set_id}&#xD;
-    }&#xD;
-}</stringProp>
+          <elementProp name="sorting[field]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">entity_id</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">sorting[field]</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
+          </elementProp>
+          <elementProp name="sorting[direction]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">asc</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">sorting[direction]</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
+          </elementProp>
+          <elementProp name="isAjax" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">true</stringProp>
             <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">isAjax</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
           </elementProp>
         </collectionProp>
       </elementProp>
@@ -26150,58 +16868,75 @@ if (testLabel
       <stringProp name="HTTPSampler.response_timeout"/>
       <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
       <stringProp name="HTTPSampler.contentEncoding"/>
-      <stringProp name="HTTPSampler.path">${base_path}rest/default/V1/products/attribute-sets/groups</stringProp>
-      <stringProp name="HTTPSampler.method">POST</stringProp>
+      <stringProp name="HTTPSampler.path">${base_path}${admin_path}/mui/index/render/</stringProp>
+      <stringProp name="HTTPSampler.method">GET</stringProp>
       <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
       <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
       <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
       <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
       <boolProp name="HTTPSampler.monitor">false</boolProp>
       <stringProp name="HTTPSampler.embedded_url_re"/>
-    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/api/create_attribute_group.jmx</stringProp></HTTPSamplerProxy>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_browse_products_grid/products_grid_mass_actions/display_grid.jmx</stringProp></HTTPSamplerProxy>
     <hashTree>
-      <com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor guiclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.gui.JSONPathExtractorGui" testclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor" testname="Extract attribute_group_id" enabled="true">
-        <stringProp name="VAR">attribute_group_id</stringProp>
-        <stringProp name="JSONPATH">$.attribute_group_id</stringProp>
-        <stringProp name="DEFAULT"/>
-        <stringProp name="VARIABLE"/>
-        <stringProp name="SUBJECT">BODY</stringProp>
-      </com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor>
-      <hashTree/>
-      <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert attribute_group_id not null" enabled="true">
+      <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Response Assertion" enabled="true">
         <collectionProp name="Asserion.test_strings">
-          <stringProp name="89649215">^\d+$</stringProp>
+          <stringProp name="1637639774">totalRecords</stringProp>
         </collectionProp>
         <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
         <boolProp name="Assertion.assume_success">false</boolProp>
-        <intProp name="Assertion.test_type">1</intProp>
-        <stringProp name="Assertion.scope">variable</stringProp>
-        <stringProp name="Scope.variable">attribute_set_id</stringProp>
+        <intProp name="Assertion.test_type">2</intProp>
       </ResponseAssertion>
       <hashTree/>
     </hashTree>
   
-    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Create attribute" enabled="true">
-      <boolProp name="HTTPSampler.postBodyRaw">true</boolProp>
-      <elementProp name="HTTPsampler.Arguments" elementType="Arguments">
+    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Display Update Attributes" enabled="true">
+      <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
         <collectionProp name="Arguments.arguments">
-          <elementProp name="" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">false</boolProp>
-            <stringProp name="Argument.value">{&#xD;
-    "attribute": {&#xD;
-        "attribute_code": "attr_code_${__time()}",&#xD;
-        "frontend_labels": [&#xD;
-            {&#xD;
-                "store_id": 0,&#xD;
-                "label": "front_lbl_${__time(YMDHMS)}-${__threadNum}-${__Random(1,1000000)}"&#xD;
-            }&#xD;
-        ],&#xD;
-        "default_value": "default value",&#xD;
-        "frontend_input": "textarea",&#xD;
-        "is_required": true&#xD;
-    }&#xD;
-}</stringProp>
+          <elementProp name="selected[0]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">${productId1}</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">selected[0]</stringProp>
+          </elementProp>
+          <elementProp name="selected[1]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">${productId2}</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">selected[1]</stringProp>
+          </elementProp>
+          <elementProp name="selected[2]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">${productId3}</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">selected[2]</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
+          </elementProp>
+          <elementProp name="filters[placeholder]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">true</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">filters[placeholder]</stringProp>
+            <stringProp name="Argument.desc">false</stringProp>
+          </elementProp>
+          <elementProp name="form_key" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">${admin_form_key}</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">form_key</stringProp>
+            <stringProp name="Argument.desc">false</stringProp>
+          </elementProp>
+          <elementProp name="namespace" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">product_listing</stringProp>
             <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">namespace</stringProp>
+            <stringProp name="Argument.desc">false</stringProp>
           </elementProp>
         </collectionProp>
       </elementProp>
@@ -26211,71 +16946,240 @@ if (testLabel
       <stringProp name="HTTPSampler.response_timeout"/>
       <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
       <stringProp name="HTTPSampler.contentEncoding"/>
-      <stringProp name="HTTPSampler.path">${base_path}rest/default/V1/products/attributes/</stringProp>
-      <stringProp name="HTTPSampler.method">POST</stringProp>
+      <stringProp name="HTTPSampler.path">${base_path}${admin_path}/catalog/product_action_attribute/edit</stringProp>
+      <stringProp name="HTTPSampler.method">GET</stringProp>
       <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
       <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
       <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
       <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
       <boolProp name="HTTPSampler.monitor">false</boolProp>
       <stringProp name="HTTPSampler.embedded_url_re"/>
-    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/api/create_attribute.jmx</stringProp></HTTPSamplerProxy>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_browse_products_grid/products_grid_mass_actions/display_update_attributes.jmx</stringProp></HTTPSamplerProxy>
     <hashTree>
-      <com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor guiclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.gui.JSONPathExtractorGui" testclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor" testname="Extract attribute_id" enabled="true">
-        <stringProp name="VAR">attribute_id</stringProp>
-        <stringProp name="JSONPATH">$.attribute_id</stringProp>
-        <stringProp name="DEFAULT"/>
-        <stringProp name="VARIABLE"/>
-        <stringProp name="SUBJECT">BODY</stringProp>
-      </com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor>
-      <hashTree/>
-      <com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor guiclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.gui.JSONPathExtractorGui" testclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor" testname="Extract attribute_code" enabled="true">
-        <stringProp name="VAR">attribute_code</stringProp>
-        <stringProp name="JSONPATH">$.attribute_code</stringProp>
-        <stringProp name="DEFAULT"/>
-        <stringProp name="VARIABLE"/>
-        <stringProp name="SUBJECT">BODY</stringProp>
-      </com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor>
-      <hashTree/>
-      <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert attribute_id not null" enabled="true">
-        <collectionProp name="Asserion.test_strings">
-          <stringProp name="89649215">^\d+$</stringProp>
-        </collectionProp>
-        <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
-        <boolProp name="Assertion.assume_success">false</boolProp>
-        <intProp name="Assertion.test_type">1</intProp>
-        <stringProp name="Assertion.scope">variable</stringProp>
-        <stringProp name="Scope.variable">attribute_id</stringProp>
-      </ResponseAssertion>
-      <hashTree/>
-      <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert attribute_code not null" enabled="true">
+      <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Response Assertion" enabled="true">
         <collectionProp name="Asserion.test_strings">
-          <stringProp name="2131456825">^[a-z0-9-_]+$</stringProp>
+          <stringProp name="1862384910">Update Attributes</stringProp>
         </collectionProp>
         <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
         <boolProp name="Assertion.assume_success">false</boolProp>
-        <intProp name="Assertion.test_type">1</intProp>
-        <stringProp name="Assertion.scope">variable</stringProp>
-        <stringProp name="Scope.variable">attribute_code</stringProp>
+        <intProp name="Assertion.test_type">2</intProp>
       </ResponseAssertion>
       <hashTree/>
     </hashTree>
   
-    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Add attribute to attribute set" enabled="true">
-      <boolProp name="HTTPSampler.postBodyRaw">true</boolProp>
-      <elementProp name="HTTPsampler.Arguments" elementType="Arguments">
-        <collectionProp name="Arguments.arguments">
-          <elementProp name="" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">false</boolProp>
-            <stringProp name="Argument.value">{&#xD;
-    "attributeSetId": "${attribute_set_id}",&#xD;
-    "attributeGroupId": "${attribute_group_id}",&#xD;
-    "attributeCode": "${attribute_code}",&#xD;
-    "sortOrder": 3&#xD;
-}</stringProp>
-            <stringProp name="Argument.metadata">=</stringProp>
-          </elementProp>
-        </collectionProp>
+  <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Validate Attributes" enabled="true">
+    <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
+      <collectionProp name="Arguments.arguments">
+        <elementProp name="isAjax" elementType="HTTPArgument">
+          <boolProp name="HTTPArgument.always_encode">true</boolProp>
+          <stringProp name="Argument.value">true</stringProp>
+          <stringProp name="Argument.metadata">=</stringProp>
+          <boolProp name="HTTPArgument.use_equals">true</boolProp>
+          <stringProp name="Argument.name">isAjax</stringProp>
+          <stringProp name="Argument.desc">true</stringProp>
+        </elementProp>
+        <elementProp name="form_key" elementType="HTTPArgument">
+          <boolProp name="HTTPArgument.always_encode">true</boolProp>
+          <stringProp name="Argument.value">${admin_form_key}</stringProp>
+          <stringProp name="Argument.metadata">=</stringProp>
+          <boolProp name="HTTPArgument.use_equals">true</boolProp>
+          <stringProp name="Argument.name">form_key</stringProp>
+          <stringProp name="Argument.desc">true</stringProp>
+        </elementProp>
+        <elementProp name="product[product_has_weight]" elementType="HTTPArgument">
+          <boolProp name="HTTPArgument.always_encode">true</boolProp>
+          <stringProp name="Argument.value">1</stringProp>
+          <stringProp name="Argument.metadata">=</stringProp>
+          <boolProp name="HTTPArgument.use_equals">true</boolProp>
+          <stringProp name="Argument.name">product[product_has_weight]</stringProp>
+          <stringProp name="Argument.desc">true</stringProp>
+        </elementProp>
+        <elementProp name="product[use_config_gift_message_available]" elementType="HTTPArgument">
+          <boolProp name="HTTPArgument.always_encode">true</boolProp>
+          <stringProp name="Argument.value">1</stringProp>
+          <stringProp name="Argument.metadata">=</stringProp>
+          <boolProp name="HTTPArgument.use_equals">true</boolProp>
+          <stringProp name="Argument.name">product[use_config_gift_message_available]</stringProp>
+          <stringProp name="Argument.desc">true</stringProp>
+        </elementProp>
+        <elementProp name="product[use_config_gift_wrapping_available]" elementType="HTTPArgument">
+          <boolProp name="HTTPArgument.always_encode">true</boolProp>
+          <stringProp name="Argument.value">1</stringProp>
+          <stringProp name="Argument.metadata">=</stringProp>
+          <boolProp name="HTTPArgument.use_equals">true</boolProp>
+          <stringProp name="Argument.name">product[use_config_gift_wrapping_available]</stringProp>
+          <stringProp name="Argument.desc">true</stringProp>
+        </elementProp>
+        <elementProp name="inventory[qty]" elementType="HTTPArgument">
+          <boolProp name="HTTPArgument.always_encode">true</boolProp>
+          <stringProp name="Argument.value">${quantity}</stringProp>
+          <stringProp name="Argument.metadata">=</stringProp>
+          <boolProp name="HTTPArgument.use_equals">true</boolProp>
+          <stringProp name="Argument.name">inventory[qty]</stringProp>
+          <stringProp name="Argument.desc">true</stringProp>
+        </elementProp>
+        <elementProp name="attributes[price]" elementType="HTTPArgument">
+          <boolProp name="HTTPArgument.always_encode">true</boolProp>
+          <stringProp name="Argument.value">${price}</stringProp>
+          <stringProp name="Argument.metadata">=</stringProp>
+          <boolProp name="HTTPArgument.use_equals">true</boolProp>
+          <stringProp name="Argument.name">attributes[price]</stringProp>
+        </elementProp>
+        <elementProp name="attributes[visibility]" elementType="HTTPArgument">
+          <boolProp name="HTTPArgument.always_encode">true</boolProp>
+          <stringProp name="Argument.value">${visibility}</stringProp>
+          <stringProp name="Argument.metadata">=</stringProp>
+          <boolProp name="HTTPArgument.use_equals">true</boolProp>
+          <stringProp name="Argument.name">attributes[visibility]</stringProp>
+        </elementProp>
+      </collectionProp>
+    </elementProp>
+    <stringProp name="HTTPSampler.domain"/>
+    <stringProp name="HTTPSampler.port"/>
+    <stringProp name="HTTPSampler.connect_timeout"/>
+    <stringProp name="HTTPSampler.response_timeout"/>
+    <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
+    <stringProp name="HTTPSampler.contentEncoding"/>
+    <stringProp name="HTTPSampler.path">${base_path}${admin_path}/catalog/product_action_attribute/validate</stringProp>
+    <stringProp name="HTTPSampler.method">POST</stringProp>
+    <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
+    <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
+    <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
+    <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
+    <boolProp name="HTTPSampler.monitor">false</boolProp>
+    <stringProp name="HTTPSampler.embedded_url_re"/>
+  <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_browse_products_grid/products_grid_mass_actions/change_attributes.jmx</stringProp></HTTPSamplerProxy>
+  <hashTree>
+    <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Response Assertion" enabled="true">
+      <collectionProp name="Asserion.test_strings">
+        <stringProp name="1853918323">{"error":false}</stringProp>
+      </collectionProp>
+      <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
+      <boolProp name="Assertion.assume_success">false</boolProp>
+      <intProp name="Assertion.test_type">2</intProp>
+    </ResponseAssertion>
+    <hashTree/>
+  </hashTree>
+  <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Save Attributes" enabled="true">
+    <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
+      <collectionProp name="Arguments.arguments">
+        <elementProp name="isAjax" elementType="HTTPArgument">
+          <boolProp name="HTTPArgument.always_encode">true</boolProp>
+          <stringProp name="Argument.value">true</stringProp>
+          <stringProp name="Argument.metadata">=</stringProp>
+          <boolProp name="HTTPArgument.use_equals">true</boolProp>
+          <stringProp name="Argument.name">isAjax</stringProp>
+          <stringProp name="Argument.desc">false</stringProp>
+        </elementProp>
+        <elementProp name="form_key" elementType="HTTPArgument">
+          <boolProp name="HTTPArgument.always_encode">true</boolProp>
+          <stringProp name="Argument.value">${admin_form_key}</stringProp>
+          <stringProp name="Argument.metadata">=</stringProp>
+          <boolProp name="HTTPArgument.use_equals">true</boolProp>
+          <stringProp name="Argument.name">form_key</stringProp>
+          <stringProp name="Argument.desc">false</stringProp>
+        </elementProp>
+        <elementProp name="product[product_has_weight]" elementType="HTTPArgument">
+          <boolProp name="HTTPArgument.always_encode">true</boolProp>
+          <stringProp name="Argument.value">1</stringProp>
+          <stringProp name="Argument.metadata">=</stringProp>
+          <boolProp name="HTTPArgument.use_equals">true</boolProp>
+          <stringProp name="Argument.name">product[product_has_weight]</stringProp>
+          <stringProp name="Argument.desc">true</stringProp>
+        </elementProp>
+        <elementProp name="product[use_config_gift_message_available]" elementType="HTTPArgument">
+          <boolProp name="HTTPArgument.always_encode">true</boolProp>
+          <stringProp name="Argument.value">1</stringProp>
+          <stringProp name="Argument.metadata">=</stringProp>
+          <boolProp name="HTTPArgument.use_equals">true</boolProp>
+          <stringProp name="Argument.name">product[use_config_gift_message_available]</stringProp>
+        </elementProp>
+        <elementProp name="product[use_config_gift_wrapping_available]" elementType="HTTPArgument">
+          <boolProp name="HTTPArgument.always_encode">true</boolProp>
+          <stringProp name="Argument.value">1</stringProp>
+          <stringProp name="Argument.metadata">=</stringProp>
+          <boolProp name="HTTPArgument.use_equals">true</boolProp>
+          <stringProp name="Argument.name">product[use_config_gift_wrapping_available]</stringProp>
+          <stringProp name="Argument.desc">true</stringProp>
+        </elementProp>
+        <elementProp name="inventory[qty]" elementType="HTTPArgument">
+          <boolProp name="HTTPArgument.always_encode">true</boolProp>
+          <stringProp name="Argument.value">${quantity}</stringProp>
+          <stringProp name="Argument.metadata">=</stringProp>
+          <boolProp name="HTTPArgument.use_equals">true</boolProp>
+          <stringProp name="Argument.name">inventory[qty]</stringProp>
+        </elementProp>
+        <elementProp name="toggle_qty" elementType="HTTPArgument">
+          <boolProp name="HTTPArgument.always_encode">true</boolProp>
+          <stringProp name="Argument.value">on</stringProp>
+          <stringProp name="Argument.metadata">=</stringProp>
+          <boolProp name="HTTPArgument.use_equals">true</boolProp>
+          <stringProp name="Argument.name">toggle_price</stringProp>
+          <stringProp name="Argument.desc">true</stringProp>
+        </elementProp>
+        <elementProp name="attributes[price]" elementType="HTTPArgument">
+          <boolProp name="HTTPArgument.always_encode">true</boolProp>
+          <stringProp name="Argument.value">${price}</stringProp>
+          <stringProp name="Argument.metadata">=</stringProp>
+          <boolProp name="HTTPArgument.use_equals">true</boolProp>
+          <stringProp name="Argument.name">attributes[price]</stringProp>
+        </elementProp>
+        <elementProp name="toggle_price" elementType="HTTPArgument">
+          <boolProp name="HTTPArgument.always_encode">true</boolProp>
+          <stringProp name="Argument.value">on</stringProp>
+          <stringProp name="Argument.metadata">=</stringProp>
+          <boolProp name="HTTPArgument.use_equals">true</boolProp>
+          <stringProp name="Argument.name">toggle_price</stringProp>
+          <stringProp name="Argument.desc">true</stringProp>
+        </elementProp>
+        <elementProp name="attributes[visibility]" elementType="HTTPArgument">
+          <boolProp name="HTTPArgument.always_encode">true</boolProp>
+          <stringProp name="Argument.value">${visibility}</stringProp>
+          <stringProp name="Argument.metadata">=</stringProp>
+          <boolProp name="HTTPArgument.use_equals">true</boolProp>
+          <stringProp name="Argument.name">attributes[visibility]</stringProp>
+        </elementProp>
+        <elementProp name="toggle_visibility" elementType="HTTPArgument">
+          <boolProp name="HTTPArgument.always_encode">true</boolProp>
+          <stringProp name="Argument.value">on</stringProp>
+          <stringProp name="Argument.metadata">=</stringProp>
+          <boolProp name="HTTPArgument.use_equals">true</boolProp>
+          <stringProp name="Argument.name">toggle_visibility</stringProp>
+          <stringProp name="Argument.desc">true</stringProp>
+        </elementProp>
+      </collectionProp>
+    </elementProp>
+    <stringProp name="HTTPSampler.domain"/>
+    <stringProp name="HTTPSampler.port"/>
+    <stringProp name="HTTPSampler.connect_timeout"/>
+    <stringProp name="HTTPSampler.response_timeout"/>
+    <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
+    <stringProp name="HTTPSampler.contentEncoding"/>
+    <stringProp name="HTTPSampler.path">${base_path}${admin_path}/catalog/product_action_attribute/save/store/0/active_tab/attributes</stringProp>
+    <stringProp name="HTTPSampler.method">POST</stringProp>
+    <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
+    <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
+    <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
+    <boolProp name="HTTPSampler.DO_MULTIPART_POST">true</boolProp>
+    <boolProp name="HTTPSampler.monitor">false</boolProp>
+    <stringProp name="HTTPSampler.embedded_url_re"/>
+  </HTTPSamplerProxy>
+  <hashTree>
+    <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Response Assertion" enabled="true">
+      <collectionProp name="Asserion.test_strings">
+        <stringProp name="1848809106">were updated.</stringProp>
+      </collectionProp>
+      <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
+      <boolProp name="Assertion.assume_success">false</boolProp>
+      <intProp name="Assertion.test_type">2</intProp>
+    </ResponseAssertion>
+    <hashTree/>
+  </hashTree>
+</hashTree>
+  
+    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Logout" enabled="true">
+      <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
+        <collectionProp name="Arguments.arguments"/>
       </elementProp>
       <stringProp name="HTTPSampler.domain"/>
       <stringProp name="HTTPSampler.port"/>
@@ -26283,33 +17187,36 @@ if (testLabel
       <stringProp name="HTTPSampler.response_timeout"/>
       <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
       <stringProp name="HTTPSampler.contentEncoding"/>
-      <stringProp name="HTTPSampler.path">${base_path}rest/default/V1/products/attribute-sets/attributes</stringProp>
-      <stringProp name="HTTPSampler.method">POST</stringProp>
+      <stringProp name="HTTPSampler.path">${base_path}${admin_path}/admin/auth/logout/</stringProp>
+      <stringProp name="HTTPSampler.method">GET</stringProp>
       <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
       <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
       <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
       <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
       <boolProp name="HTTPSampler.monitor">false</boolProp>
       <stringProp name="HTTPSampler.embedded_url_re"/>
-    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/api/add_attribute_to_attribute_set.jmx</stringProp></HTTPSamplerProxy>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/setup/admin_logout.jmx</stringProp></HTTPSamplerProxy>
     <hashTree>
-      <com.atlantbh.jmeter.plugins.jsonutils.jsonpathassertion.JSONPathAssertion guiclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathassertion.gui.JSONPathAssertionGui" testclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathassertion.JSONPathAssertion" testname="Assert response is not null" enabled="true">
-        <stringProp name="JSON_PATH">$</stringProp>
-        <stringProp name="EXPECTED_VALUE">(\d+)</stringProp>
-        <boolProp name="JSONVALIDATION">true</boolProp>
-        <boolProp name="EXPECT_NULL">false</boolProp>
-        <boolProp name="INVERT">false</boolProp>
-      </com.atlantbh.jmeter.plugins.jsonutils.jsonpathassertion.JSONPathAssertion>
-      <hashTree/>
-    </hashTree>
+    
+    <BeanShellPostProcessor guiclass="TestBeanGUI" testclass="BeanShellPostProcessor" testname="Return Admin to Pool" enabled="true">
+        <boolProp name="resetInterpreter">false</boolProp>
+        <stringProp name="parameters"/>
+        <stringProp name="filename"/>
+        <stringProp name="script">
+adminUserList = props.get("adminUserList");
+adminUserList.add(vars.get("admin_user"));
+        </stringProp>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/common/return_admin_email_to_pool.jmx</stringProp></BeanShellPostProcessor>
+    <hashTree/>
+  </hashTree>
   </hashTree>
 
   
-    <ThroughputController guiclass="ThroughputControllerGui" testclass="ThroughputController" testname="API Product Management" enabled="true">
+    <ThroughputController guiclass="ThroughputControllerGui" testclass="ThroughputController" testname="Import Products" enabled="true">
       <intProp name="ThroughputController.style">1</intProp>
       <boolProp name="ThroughputController.perThread">false</boolProp>
       <intProp name="ThroughputController.maxThroughput">1</intProp>
-      <stringProp name="ThroughputController.percentThroughput">100</stringProp>
+      <stringProp name="ThroughputController.percentThroughput">${importProductsPercentage}</stringProp>
     <stringProp name="TestPlan.comments">mpaf/tool/fragments/_system/scenario_controller_tmpl.jmx</stringProp></ThroughputController>
     <hashTree>
         <JSR223PreProcessor guiclass="TestBeanGUI" testclass="JSR223PreProcessor" testname="Set Test Label" enabled="true">
@@ -26326,32 +17233,103 @@ if (testLabel
 }
             </stringProp>
             <stringProp name="scriptLanguage">javascript</stringProp>
-        <stringProp name="TestPlan.comments">mpaf/tool/fragments/_system/setup_label.jmx</stringProp></JSR223PreProcessor>
-        <hashTree/>
-        <BeanShellSampler guiclass="BeanShellSamplerGui" testclass="BeanShellSampler" testname="SetUp - Set Label" enabled="true">
-            <stringProp name="BeanShellSampler.query">
-                vars.put("testLabel", "API Product Management");
-            </stringProp>
-            <boolProp name="BeanShellSampler.resetInterpreter">true</boolProp>
-        </BeanShellSampler>
+        <stringProp name="TestPlan.comments">mpaf/tool/fragments/_system/setup_label.jmx</stringProp></JSR223PreProcessor>
+        <hashTree/>
+        <BeanShellSampler guiclass="BeanShellSamplerGui" testclass="BeanShellSampler" testname="SetUp - Set Label" enabled="true">
+            <stringProp name="BeanShellSampler.query">
+                vars.put("testLabel", "Import Products");
+            </stringProp>
+            <boolProp name="BeanShellSampler.resetInterpreter">true</boolProp>
+        </BeanShellSampler>
+        <hashTree/>
+    
+        <JSR223PostProcessor guiclass="TestBeanGUI" testclass="JSR223PostProcessor" testname="Get admin form key PostProcessor" enabled="true">
+        <stringProp name="script">
+        function getFormKeyFromResponse()
+        {
+            var url = prev.getUrlAsString(),
+            responseCode =  prev.getResponseCode(),
+            formKey = null;
+            searchPattern = /var FORM_KEY = '(.+)'/;
+            if (responseCode == "200" &amp;&amp; url) {
+                response = prev.getResponseDataAsString();
+                formKey = response  &amp;&amp; response.match(searchPattern) ? response.match(searchPattern)[1] : null;
+            }
+            return formKey;
+        }
+
+        formKey = vars.get("form_key_storage");
+
+	   currentFormKey = getFormKeyFromResponse();
+
+	   if (currentFormKey != null &amp;&amp; currentFormKey != formKey) {
+		  vars.put("form_key_storage", currentFormKey);
+	   }
+        </stringProp>
+        <stringProp name="scriptLanguage">javascript</stringProp>
+        <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin/handle_admin_form_key.jmx</stringProp></JSR223PostProcessor>
+        <hashTree/>
+        <JSR223PreProcessor guiclass="TestBeanGUI" testclass="JSR223PreProcessor" testname="Set admin form key PreProcessor" enabled="true">
+            <stringProp name="script">
+                formKey =  vars.get("form_key_storage");
+                if (formKey
+                    &amp;&amp; sampler.getClass().getName() == 'org.apache.jmeter.protocol.http.sampler.HTTPSamplerProxy'
+                    &amp;&amp; sampler.getMethod() == "POST")
+                    {
+                        arguments = sampler.getArguments();
+                        for (i=0; i&lt;arguments.getArgumentCount(); i++)
+                        {
+                            argument = arguments.getArgument(i);
+                            if (argument.getName() == 'form_key' &amp;&amp; argument.getValue() != formKey) {
+                            log.info("admin form key updated: " + argument.getValue() + " =&gt; " + formKey);
+                            argument.setValue(formKey);
+                        }
+                    }
+                }
+            </stringProp>
+            <stringProp name="scriptLanguage">javascript</stringProp>
+        </JSR223PreProcessor>
         <hashTree/>
     
-    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Create product" enabled="true">
-      <boolProp name="HTTPSampler.postBodyRaw">true</boolProp>
-      <elementProp name="HTTPsampler.Arguments" elementType="Arguments">
-        <collectionProp name="Arguments.arguments">
-          <elementProp name="" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">false</boolProp>
-            <stringProp name="Argument.value">{&#xD;
-    "product": {&#xD;
-        "sku": "psku-test-${__time()}-${__threadNum}-${__Random(1,1000000)}",&#xD;
-        "name": "Product_${__time()}-${__threadNum}-${__Random(1,1000000)}",&#xD;
-        "attributeSetId": 4&#xD;
-    }&#xD;
-}</stringProp>
-            <stringProp name="Argument.metadata">=</stringProp>
-          </elementProp>
-        </collectionProp>
+    <CookieManager guiclass="CookiePanel" testclass="CookieManager" testname="HTTP Cookie Manager" enabled="true">
+      <collectionProp name="CookieManager.cookies"/>
+      <boolProp name="CookieManager.clearEachIteration">false</boolProp>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/http_cookie_manager_without_clear_each_iteration.jmx</stringProp></CookieManager>
+    <hashTree/>
+  
+    <GenericController guiclass="LogicControllerGui" testclass="GenericController" testname="Admin Login" enabled="true">
+  <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/simple_controller.jmx</stringProp>
+</GenericController>
+    <hashTree>
+    <CriticalSectionController guiclass="CriticalSectionControllerGui" testclass="CriticalSectionController" testname="Admin Login Lock" enabled="true">
+        <stringProp name="CriticalSectionController.lockName">get-admin-email</stringProp>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/lock_controller.jmx</stringProp></CriticalSectionController>
+    <hashTree>
+    
+    <BeanShellSampler guiclass="BeanShellSamplerGui" testclass="BeanShellSampler" testname="SetUp - Get Admin Email" enabled="true">
+      <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/get_admin_email.jmx</stringProp>
+      <stringProp name="BeanShellSampler.query">
+adminUserList = props.get("adminUserList");
+adminUser = adminUserList.poll();
+if (adminUser == null) {
+  SampleResult.setResponseMessage("adminUser list is empty");
+  SampleResult.setResponseData("adminUser list is empty","UTF-8");
+  IsSuccess=false;
+  SampleResult.setSuccessful(false);
+  SampleResult.setStopThread(true);
+}
+vars.put("admin_user", adminUser);
+      </stringProp>
+      <stringProp name="BeanShellSampler.filename"/>
+      <stringProp name="BeanShellSampler.parameters"/>
+      <boolProp name="BeanShellSampler.resetInterpreter">true</boolProp>
+    </BeanShellSampler>
+    <hashTree/>
+  </hashTree>
+  
+    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="SetUp - Login" enabled="true">
+      <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
+        <collectionProp name="Arguments.arguments"/>
       </elementProp>
       <stringProp name="HTTPSampler.domain"/>
       <stringProp name="HTTPSampler.port"/>
@@ -26359,89 +17337,78 @@ if (testLabel
       <stringProp name="HTTPSampler.response_timeout"/>
       <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
       <stringProp name="HTTPSampler.contentEncoding"/>
-      <stringProp name="HTTPSampler.path">${base_path}rest/default/V1/products</stringProp>
-      <stringProp name="HTTPSampler.method">POST</stringProp>
+      <stringProp name="HTTPSampler.path">${base_path}${admin_path}</stringProp>
+      <stringProp name="HTTPSampler.method">GET</stringProp>
       <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
       <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
       <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
       <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
       <boolProp name="HTTPSampler.monitor">false</boolProp>
       <stringProp name="HTTPSampler.embedded_url_re"/>
-    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/api/create_product_no_custom_attributes.jmx</stringProp></HTTPSamplerProxy>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_login/admin_login.jmx</stringProp></HTTPSamplerProxy>
     <hashTree>
-      <com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor guiclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.gui.JSONPathExtractorGui" testclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor" testname="Extract product id" enabled="true">
-        <stringProp name="VAR">simple_product_id</stringProp>
-        <stringProp name="JSONPATH">$.id</stringProp>
-        <stringProp name="DEFAULT"/>
-        <stringProp name="VARIABLE"/>
-        <stringProp name="SUBJECT">BODY</stringProp>
-      </com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor>
-      <hashTree/>
-      <com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor guiclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.gui.JSONPathExtractorGui" testclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor" testname="Extract product sku" enabled="true">
-        <stringProp name="VAR">simple_product_sku</stringProp>
-        <stringProp name="JSONPATH">$.sku</stringProp>
-        <stringProp name="DEFAULT"/>
-        <stringProp name="VARIABLE"/>
-        <stringProp name="SUBJECT">BODY</stringProp>
-      </com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor>
-      <hashTree/>
-      <com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor guiclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.gui.JSONPathExtractorGui" testclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor" testname="Extract stock item id" enabled="true">
-        <stringProp name="VAR">simple_stock_item_id</stringProp>
-        <stringProp name="JSONPATH">$.extension_attributes.stock_item.item_id</stringProp>
-        <stringProp name="DEFAULT"/>
-        <stringProp name="VARIABLE"/>
-        <stringProp name="SUBJECT">BODY</stringProp>
-      </com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor>
-      <hashTree/>
-      <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert product id not null" enabled="true">
+      <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert login form shown" enabled="true">
         <collectionProp name="Asserion.test_strings">
-          <stringProp name="89649215">^\d+$</stringProp>
+          <stringProp name="-1397214398">Welcome</stringProp>
+          <stringProp name="-515240035">&lt;title&gt;Magento Admin&lt;/title&gt;</stringProp>
         </collectionProp>
         <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
         <boolProp name="Assertion.assume_success">false</boolProp>
-        <intProp name="Assertion.test_type">1</intProp>
-        <stringProp name="Assertion.scope">variable</stringProp>
-        <stringProp name="Scope.variable">simple_product_id</stringProp>
+        <intProp name="Assertion.test_type">2</intProp>
       </ResponseAssertion>
       <hashTree/>
-      <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert product sku not null" enabled="true">
-        <collectionProp name="Asserion.test_strings">
-          <stringProp name="484395188">^[a-z0-9-]+$</stringProp>
-        </collectionProp>
-        <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
-        <boolProp name="Assertion.assume_success">false</boolProp>
-        <intProp name="Assertion.test_type">1</intProp>
-        <stringProp name="Assertion.scope">variable</stringProp>
-        <stringProp name="Scope.variable">simple_product_sku</stringProp>
-      </ResponseAssertion>
+      <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract form key" enabled="true">
+        <stringProp name="RegexExtractor.useHeaders">false</stringProp>
+        <stringProp name="RegexExtractor.refname">admin_form_key</stringProp>
+        <stringProp name="RegexExtractor.regex">&lt;input name="form_key" type="hidden" value="([^'"]+)" /&gt;</stringProp>
+        <stringProp name="RegexExtractor.template">$1$</stringProp>
+        <stringProp name="RegexExtractor.default"/>
+        <stringProp name="RegexExtractor.match_number">1</stringProp>
+      </RegexExtractor>
       <hashTree/>
-      <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert stock item id not null" enabled="true">
+      <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert form_key extracted" enabled="true">
         <collectionProp name="Asserion.test_strings">
-          <stringProp name="89649215">^\d+$</stringProp>
+          <stringProp name="2845929">^.+$</stringProp>
         </collectionProp>
         <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
         <boolProp name="Assertion.assume_success">false</boolProp>
         <intProp name="Assertion.test_type">1</intProp>
         <stringProp name="Assertion.scope">variable</stringProp>
-        <stringProp name="Scope.variable">simple_stock_item_id</stringProp>
+        <stringProp name="Scope.variable">admin_form_key</stringProp>
       </ResponseAssertion>
       <hashTree/>
     </hashTree>
   
-    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Update product stock info" enabled="true">
-      <boolProp name="HTTPSampler.postBodyRaw">true</boolProp>
-      <elementProp name="HTTPsampler.Arguments" elementType="Arguments">
+    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="SetUp - Login Submit Form" enabled="true">
+      <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
         <collectionProp name="Arguments.arguments">
-          <elementProp name="" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">false</boolProp>
-            <stringProp name="Argument.value">{&#xD;
-        "stock_item": {   &#xD;
-        	"manage_stock": true,    &#xD;
-        	"is_in_stock": true,&#xD;
-          "qty": ${simple_product_id}&#xD;
-        }&#xD;
-    }</stringProp>
+          <elementProp name="dummy" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value"/>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">dummy</stringProp>
+          </elementProp>
+          <elementProp name="form_key" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">${admin_form_key}</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">form_key</stringProp>
+          </elementProp>
+          <elementProp name="login[password]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">${admin_password}</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">login[password]</stringProp>
+          </elementProp>
+          <elementProp name="login[username]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">${admin_user}</stringProp>
             <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">login[username]</stringProp>
           </elementProp>
         </collectionProp>
       </elementProp>
@@ -26451,36 +17418,49 @@ if (testLabel
       <stringProp name="HTTPSampler.response_timeout"/>
       <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
       <stringProp name="HTTPSampler.contentEncoding"/>
-      <stringProp name="HTTPSampler.path">${base_path}rest/default/V1/products/${simple_product_sku}/stockItems/${simple_stock_item_id}</stringProp>
-      <stringProp name="HTTPSampler.method">PUT</stringProp>
+      <stringProp name="HTTPSampler.path">${base_path}${admin_path}/admin/dashboard/</stringProp>
+      <stringProp name="HTTPSampler.method">POST</stringProp>
       <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
       <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
       <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
       <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
+      <stringProp name="HTTPSampler.implementation">Java</stringProp>
       <boolProp name="HTTPSampler.monitor">false</boolProp>
       <stringProp name="HTTPSampler.embedded_url_re"/>
-    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/api/update_product_stock_info.jmx</stringProp></HTTPSamplerProxy>
+      <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_login/admin_login_submit_form.jmx</stringProp>
+    </HTTPSamplerProxy>
     <hashTree>
-      <com.atlantbh.jmeter.plugins.jsonutils.jsonpathassertion.JSONPathAssertion guiclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathassertion.gui.JSONPathAssertionGui" testclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathassertion.JSONPathAssertion" testname="jp@gc - JSON Path Assertion" enabled="true">
-        <stringProp name="JSON_PATH">$</stringProp>
-        <stringProp name="EXPECTED_VALUE">${simple_stock_item_id}</stringProp>
-        <boolProp name="JSONVALIDATION">true</boolProp>
-        <boolProp name="EXPECT_NULL">false</boolProp>
-        <boolProp name="INVERT">false</boolProp>
-      </com.atlantbh.jmeter.plugins.jsonutils.jsonpathassertion.JSONPathAssertion>
-      <hashTree/>
+        <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract form key" enabled="true">
+            <stringProp name="RegexExtractor.useHeaders">false</stringProp>
+            <stringProp name="RegexExtractor.refname">admin_form_key</stringProp>
+            <stringProp name="RegexExtractor.regex">&lt;input name="form_key" type="hidden" value="([^'"]+)" /&gt;</stringProp>
+            <stringProp name="RegexExtractor.template">$1$</stringProp>
+            <stringProp name="RegexExtractor.default"/>
+            <stringProp name="RegexExtractor.match_number">1</stringProp>
+        <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_login/admin_retrieve_form_key.jmx</stringProp></RegexExtractor>
+        <hashTree/>
     </hashTree>
+  </hashTree>
   
-    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Check product" enabled="true">
-      <boolProp name="HTTPSampler.postBodyRaw">true</boolProp>
-      <elementProp name="HTTPsampler.Arguments" elementType="Arguments">
-        <collectionProp name="Arguments.arguments">
-          <elementProp name="" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value"/>
-            <stringProp name="Argument.metadata">=</stringProp>
-          </elementProp>
-        </collectionProp>
+    <GenericController guiclass="LogicControllerGui" testclass="GenericController" testname="Simple Controller" enabled="true">
+  <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/simple_controller.jmx</stringProp>
+</GenericController>
+    <hashTree>
+    <BeanShellSampler guiclass="BeanShellSamplerGui" testclass="BeanShellSampler" testname="SetUp - Set Arguments" enabled="true">
+      <stringProp name="BeanShellSampler.query">vars.put("entity", "catalog_product");
+String behavior = "${adminImportProductBehavior}";
+vars.put("adminImportBehavior", behavior);
+String filepath = "${files_folder}${adminImportProductFilePath}";
+vars.put("adminImportFilePath", filepath);  </stringProp>
+      <stringProp name="BeanShellSampler.filename"/>
+      <stringProp name="BeanShellSampler.parameters"/>
+      <boolProp name="BeanShellSampler.resetInterpreter">true</boolProp>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/import_products/setup.jmx</stringProp></BeanShellSampler>
+    <hashTree/>
+  
+    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Import Page" enabled="true">
+      <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
+        <collectionProp name="Arguments.arguments"/>
       </elementProp>
       <stringProp name="HTTPSampler.domain"/>
       <stringProp name="HTTPSampler.port"/>
@@ -26488,7 +17468,7 @@ if (testLabel
       <stringProp name="HTTPSampler.response_timeout"/>
       <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
       <stringProp name="HTTPSampler.contentEncoding"/>
-      <stringProp name="HTTPSampler.path">${base_path}rest/default/V1/products/${simple_product_sku}</stringProp>
+      <stringProp name="HTTPSampler.path">${base_path}${admin_path}/admin/import/</stringProp>
       <stringProp name="HTTPSampler.method">GET</stringProp>
       <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
       <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
@@ -26496,92 +17476,71 @@ if (testLabel
       <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
       <boolProp name="HTTPSampler.monitor">false</boolProp>
       <stringProp name="HTTPSampler.embedded_url_re"/>
-    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/api/check_product.jmx</stringProp></HTTPSamplerProxy>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/common/import.jmx</stringProp></HTTPSamplerProxy>
     <hashTree>
-      <com.atlantbh.jmeter.plugins.jsonutils.jsonpathassertion.JSONPathAssertion guiclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathassertion.gui.JSONPathAssertionGui" testclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathassertion.JSONPathAssertion" testname="Assert product sku" enabled="true">
-        <stringProp name="JSON_PATH">$.sku</stringProp>
-        <stringProp name="EXPECTED_VALUE">${simple_product_sku}</stringProp>
-        <boolProp name="JSONVALIDATION">true</boolProp>
-        <boolProp name="EXPECT_NULL">false</boolProp>
-        <boolProp name="INVERT">false</boolProp>
-      </com.atlantbh.jmeter.plugins.jsonutils.jsonpathassertion.JSONPathAssertion>
-      <hashTree/>
-      <com.atlantbh.jmeter.plugins.jsonutils.jsonpathassertion.JSONPathAssertion guiclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathassertion.gui.JSONPathAssertionGui" testclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathassertion.JSONPathAssertion" testname="Assert product id" enabled="true">
-        <stringProp name="JSON_PATH">$.id</stringProp>
-        <stringProp name="EXPECTED_VALUE">${simple_product_id}</stringProp>
-        <boolProp name="JSONVALIDATION">true</boolProp>
-        <boolProp name="EXPECT_NULL">false</boolProp>
-        <boolProp name="INVERT">false</boolProp>
-      </com.atlantbh.jmeter.plugins.jsonutils.jsonpathassertion.JSONPathAssertion>
-      <hashTree/>
-      <com.atlantbh.jmeter.plugins.jsonutils.jsonpathassertion.JSONPathAssertion guiclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathassertion.gui.JSONPathAssertionGui" testclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathassertion.JSONPathAssertion" testname="Assert stock item id" enabled="true">
-        <stringProp name="JSON_PATH">$.extension_attributes.stock_item.item_id</stringProp>
-        <stringProp name="EXPECTED_VALUE">${simple_stock_item_id}</stringProp>
-        <boolProp name="JSONVALIDATION">true</boolProp>
-        <boolProp name="EXPECT_NULL">false</boolProp>
-        <boolProp name="INVERT">false</boolProp>
-      </com.atlantbh.jmeter.plugins.jsonutils.jsonpathassertion.JSONPathAssertion>
-      <hashTree/>
-      <com.atlantbh.jmeter.plugins.jsonutils.jsonpathassertion.JSONPathAssertion guiclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathassertion.gui.JSONPathAssertionGui" testclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathassertion.JSONPathAssertion" testname="Assert updated quantity" enabled="true">
-        <stringProp name="JSON_PATH">$.extension_attributes.stock_item.qty</stringProp>
-        <stringProp name="EXPECTED_VALUE">${simple_product_id}</stringProp>
-        <boolProp name="JSONVALIDATION">true</boolProp>
-        <boolProp name="EXPECT_NULL">false</boolProp>
-        <boolProp name="INVERT">false</boolProp>
-      </com.atlantbh.jmeter.plugins.jsonutils.jsonpathassertion.JSONPathAssertion>
+      <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert success" enabled="true">
+        <collectionProp name="Asserion.test_strings">
+          <stringProp name="1723813687">Import Settings</stringProp>
+        </collectionProp>
+        <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
+        <boolProp name="Assertion.assume_success">false</boolProp>
+        <intProp name="Assertion.test_type">2</intProp>
+      </ResponseAssertion>
       <hashTree/>
     </hashTree>
   
-    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Create product with extensible data objects" enabled="true">
-      <boolProp name="HTTPSampler.postBodyRaw">true</boolProp>
-      <elementProp name="HTTPsampler.Arguments" elementType="Arguments">
+    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Import Validate" enabled="true">
+      <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
         <collectionProp name="Arguments.arguments">
-          <elementProp name="" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">false</boolProp>
-            <stringProp name="Argument.value">{&#xD;
-    "product": {&#xD;
-        "sku": "apsku-test-${__time()}-${__threadNum}-${__Random(1,1000000)}",&#xD;
-        "name": "Extensible_Product_${__time()}-${__threadNum}-${__Random(1,1000000)}",&#xD;
-        "visibility": "4",&#xD;
-        "type_id": "simple",&#xD;
-        "price": "3.62",&#xD;
-        "status": "1",&#xD;
-        "attribute_set_id": "4",&#xD;
-        "custom_attributes": [&#xD;
-            {&#xD;
-                "attribute_code": "cost",&#xD;
-                "value": ""&#xD;
-            },&#xD;
-            {&#xD;
-                "attribute_code": "description",&#xD;
-                "value": "Description"&#xD;
-            }&#xD;
-        ],&#xD;
-        "extension_attributes":{&#xD;
-		"stock_item":{&#xD;
-		"manage_stock": true,    &#xD;
-		"is_in_stock": true,&#xD;
-		"qty":"100"&#xD;
-		}&#xD;
-    	   }        ,&#xD;
-    	   "media_gallery_entries":&#xD;
-    	   	[{&#xD;
-    	   		"id": null,&#xD;
-    	   		"label":"test_label_${__time()}-${__threadNum}-${__Random(1,1000000)}",&#xD;
-    	   		"position":1,&#xD;
-    	   		"disabled":false,&#xD;
-    	   		"media_type":"image",&#xD;
-    	   		"types":["image"],&#xD;
-    	   		"content":{&#xD;
-    	   			"base64_encoded_data": "/9j/4AAQSkZJRgABAQAAAQABAAD/2wBDAAgGBgcGBQgHBwcJCQgKDBQNDAsLDBkSEw8UHRofHh0aHBwgJC4nICIsIxwcKDcpLDAxNDQ0Hyc5PTgyPC4zNDL/2wBDAQkJCQwLDBgNDRgyIRwhMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjL/wAARCABgAGADASIAAhEBAxEB/8QAHwAAAQUBAQEBAQEAAAAAAAAAAAECAwQFBgcICQoL/8QAtRAAAgEDAwIEAwUFBAQAAAF9AQIDAAQRBRIhMUEGE1FhByJxFDKBkaEII0KxwRVS0fAkM2JyggkKFhcYGRolJicoKSo0NTY3ODk6Q0RFRkdISUpTVFVWV1hZWmNkZWZnaGlqc3R1dnd4eXqDhIWGh4iJipKTlJWWl5iZmqKjpKWmp6ipqrKztLW2t7i5usLDxMXGx8jJytLT1NXW19jZ2uHi4+Tl5ufo6erx8vP09fb3+Pn6/8QAHwEAAwEBAQEBAQEBAQAAAAAAAAECAwQFBgcICQoL/8QAtREAAgECBAQDBAcFBAQAAQJ3AAECAxEEBSExBhJBUQdhcRMiMoEIFEKRobHBCSMzUvAVYnLRChYkNOEl8RcYGRomJygpKjU2Nzg5OkNERUZHSElKU1RVVldYWVpjZGVmZ2hpanN0dXZ3eHl6goOEhYaHiImKkpOUlZaXmJmaoqOkpaanqKmqsrO0tba3uLm6wsPExcbHyMnK0tPU1dbX2Nna4uPk5ebn6Onq8vP09fb3+Pn6/9oADAMBAAIRAxEAPwD3+iioLy8t9Ps5bu7lWKCIZd26KKaTbshpX0RPRXN/8J/4V/6DVv8Ak3+FH/Cf+Ff+g1b/AJN/hXR9SxP/AD7l9zNPYVf5X9x0lFc3/wAJ/wCFf+g1b/k3+FH/AAn/AIV/6DVv+Tf4UfUsT/z7l9zD2FX+V/cdJRXN/wDCf+Ff+g1b/k3+FH/Cf+Ff+g1b/k3+FH1LE/8APuX3MPYVf5X9x0lFc3/wn/hX/oNW/wCTf4Uf8J/4V/6DVv8Ak3+FH1LE/wDPuX3MPYVf5X9x0lFVdP1G01WyS8sZ1nt3JCyL0ODg/qKtVzyi4u0lZmbTTswrm/H3/Iiav/1x/wDZhXSVzfj7/kRNX/64/wDswrowf+80/wDEvzNKH8WPqj5voorB1zS7OLT7m7SHE5YNu3HqWGeM471+kYutOhSdSEU7Jt3dtF20f6H1FacqcHJK9vO36M3qKzTa6foqPdxwlWxswrFi2T0AJ9aRdVmjkT7XYSW8TsFEm8MAT0yB0qfrcafu1tJeV2l2u7K3zsL2yjpPR+V3+NjTorPn1GVbt7a1s2uJIwDJ84ULnpyaik1SWTTrp47Z0uIQRJGzAFOPvZ70Sx1GLau9L9H03SdrNrsgdeCuu3k+hq0VR0ma4msImuIih2LtYvuLjA+b2zV6uijUVWmprqaQkpxUl1PoP4Xf8iBYf78v/oxq7GuO+F3/ACIFh/vy/wDoxq7GvzTMf98q/wCJ/mfLYn+NP1YVzfj7/kRNX/64/wDswrpK5vx9/wAiJq//AFx/9mFRg/8Aeaf+JfmTQ/ix9UfN9ZniD/kB3H/Af/QhWnTZI45kKSIroeqsMg1+l4mk61GdNfaTX3o+pqw54Sj3Rma/GXsI3BcLFMruU+8F5yR+dUZ4tOeNFOq3tx5jACNZg5J+mK6PrUMdrbxPvjgiR/7yoAa48TgPa1HNW1STvfp2s1+JjVw/PJy017mbe/YTqTB7iWzuQgPmhtocfjwajiupbjTtTieUXCxRsqTKMb8qePwrYlghnAE0UcgHQOoP86ckaRoERFVR/CowKbwU3UclJJO+19brqr203vvoHsJczd7J3/H8PmVNJnhm063WOVHZIkDhTkqcd/yNXajighg3eTFHHu67FAz+VSV2UIShTjGe67G9NOMUpbn0H8Lv+RAsP9+X/wBGNXY1x3wu/wCRAsP9+X/0Y1djX5tmP++Vf8T/ADPl8T/Gn6sK5vx9/wAiJq//AFx/9mFdJXN+Pv8AkRNX/wCuP/swqMH/ALzT/wAS/Mmh/Fj6o+b6KKK/Uj60KKKKACiiigAooooA+g/hd/yIFh/vy/8Aoxq7GuO+F3/IgWH+/L/6Mauxr8wzH/fKv+J/mfKYn+NP1YVzfj7/AJETV/8Arj/7MK6Sub8ff8iJq/8A1x/9mFRg/wDeaf8AiX5k0P4sfVHzfRRRX6kfWhRRRQAUUUUAFFFFAH0H8Lv+RAsP9+X/ANGNXY1x3wu/5ECw/wB+X/0Y1djX5hmP++Vf8T/M+UxP8afqwqC8s7fULOW0u4llglGHRujCp6K5E2ndGKdtUc3/AMIB4V/6Atv+bf40f8IB4V/6Atv+bf410lFdH13E/wDPyX3s09vV/mf3nN/8IB4V/wCgLb/m3+NH/CAeFf8AoC2/5t/jXSUUfXcT/wA/Jfew9vV/mf3nN/8ACAeFf+gLb/m3+NH/AAgHhX/oC2/5t/jXSUUfXcT/AM/Jfew9vV/mf3nN/wDCAeFf+gLb/m3+NH/CAeFf+gLb/m3+NdJRR9dxP/PyX3sPb1f5n95V0/TrTSrJLOxgWC3QkrGvQZOT+pq1RRXPKTk7yd2Zttu7P//Z",&#xD;
-        "type": "image/jpeg",&#xD;
-        "name": "test_image_${__time(YMDHMS)}-${__threadNum}-${__Random(1,1000000)}.jpeg"&#xD;
-    	   			}&#xD;
-    	   	}&#xD;
-    	   	]&#xD;
-    }&#xD;
-}</stringProp>
+          <elementProp name="form_key" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">${admin_form_key}</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">form_key</stringProp>
+            <stringProp name="Argument.desc">false</stringProp>
+          </elementProp>
+          <elementProp name="entity" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">${entity}</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">entity</stringProp>
+          </elementProp>
+          <elementProp name="behavior" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">${adminImportBehavior}</stringProp>
             <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">behavior</stringProp>
+          </elementProp>
+          <elementProp name="validation_strategy" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">validation-stop-on-errors</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">validation_strategy</stringProp>
+          </elementProp>
+          <elementProp name="allowed_error_count" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">10</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">allowed_error_count</stringProp>
+          </elementProp>
+          <elementProp name="_import_field_separator" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">,</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">_import_field_separator</stringProp>
+          </elementProp>
+          <elementProp name="_import_multiple_value_separator" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">,</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">_import_multiple_value_separator</stringProp>
           </elementProp>
         </collectionProp>
       </elementProp>
@@ -26591,93 +17550,145 @@ if (testLabel
       <stringProp name="HTTPSampler.response_timeout"/>
       <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
       <stringProp name="HTTPSampler.contentEncoding"/>
-      <stringProp name="HTTPSampler.path">${base_path}rest/default/V1/products</stringProp>
+      <stringProp name="HTTPSampler.path">${base_path}${admin_path}/admin/import/validate</stringProp>
       <stringProp name="HTTPSampler.method">POST</stringProp>
       <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
       <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
       <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
       <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
+      <stringProp name="HTTPSampler.implementation">HttpClient4</stringProp>
+      <elementProp name="HTTPsampler.Files" elementType="HTTPFileArgs">
+        <collectionProp name="HTTPFileArgs.files">
+          <elementProp name="${adminImportFilePath}" elementType="HTTPFileArg">
+            <stringProp name="File.path">${adminImportFilePath}</stringProp>
+            <stringProp name="File.paramname">import_file</stringProp>
+            <stringProp name="File.mimetype">application/vnd.ms-excel</stringProp>
+          </elementProp>
+        </collectionProp>
+      </elementProp>
       <boolProp name="HTTPSampler.monitor">false</boolProp>
       <stringProp name="HTTPSampler.embedded_url_re"/>
-    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/api/create_product_with_extensible_data_objects.jmx</stringProp></HTTPSamplerProxy>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/common/import_validate.jmx</stringProp></HTTPSamplerProxy>
     <hashTree>
-      <com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor guiclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.gui.JSONPathExtractorGui" testclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor" testname="Extract product id" enabled="true">
-        <stringProp name="VAR">simple_product_id</stringProp>
-        <stringProp name="JSONPATH">$.id</stringProp>
-        <stringProp name="DEFAULT"/>
-        <stringProp name="VARIABLE"/>
-        <stringProp name="SUBJECT">BODY</stringProp>
-      </com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor>
-      <hashTree/>
-      <com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor guiclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.gui.JSONPathExtractorGui" testclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor" testname="Extract product sku" enabled="true">
-        <stringProp name="VAR">simple_product_sku</stringProp>
-        <stringProp name="JSONPATH">$.sku</stringProp>
-        <stringProp name="DEFAULT"/>
-        <stringProp name="VARIABLE"/>
-        <stringProp name="SUBJECT">BODY</stringProp>
-      </com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor>
-      <hashTree/>
-      <com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor guiclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.gui.JSONPathExtractorGui" testclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor" testname="Extract stock item id" enabled="true">
-        <stringProp name="VAR">simple_stock_item_id</stringProp>
-        <stringProp name="JSONPATH">$.extension_attributes.stock_item.item_id</stringProp>
-        <stringProp name="DEFAULT"/>
-        <stringProp name="VARIABLE"/>
-        <stringProp name="SUBJECT">BODY</stringProp>
-      </com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor>
-      <hashTree/>
-      <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert product id not null" enabled="true">
-        <collectionProp name="Asserion.test_strings">
-          <stringProp name="89649215">^\d+$</stringProp>
-        </collectionProp>
-        <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
-        <boolProp name="Assertion.assume_success">false</boolProp>
-        <intProp name="Assertion.test_type">1</intProp>
-        <stringProp name="Assertion.scope">variable</stringProp>
-        <stringProp name="Scope.variable">simple_product_id</stringProp>
-      </ResponseAssertion>
-      <hashTree/>
-      <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert product sku not null" enabled="true">
-        <collectionProp name="Asserion.test_strings">
-          <stringProp name="484395188">^[a-z0-9-]+$</stringProp>
-        </collectionProp>
-        <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
-        <boolProp name="Assertion.assume_success">false</boolProp>
-        <intProp name="Assertion.test_type">1</intProp>
-        <stringProp name="Assertion.scope">variable</stringProp>
-        <stringProp name="Scope.variable">simple_product_sku</stringProp>
-      </ResponseAssertion>
-      <hashTree/>
-      <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert stock item id not null" enabled="true">
+      <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Response Assertion" enabled="true">
         <collectionProp name="Asserion.test_strings">
-          <stringProp name="89649215">^\d+$</stringProp>
+          <stringProp name="37280142">File is valid! To start import process</stringProp>
         </collectionProp>
         <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
         <boolProp name="Assertion.assume_success">false</boolProp>
-        <intProp name="Assertion.test_type">1</intProp>
-        <stringProp name="Assertion.scope">variable</stringProp>
-        <stringProp name="Scope.variable">simple_stock_item_id</stringProp>
+        <intProp name="Assertion.test_type">16</intProp>
       </ResponseAssertion>
       <hashTree/>
     </hashTree>
   
-    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Check product with extensible data objects" enabled="true">
-      <boolProp name="HTTPSampler.postBodyRaw">true</boolProp>
-      <elementProp name="HTTPsampler.Arguments" elementType="Arguments">
+    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Import Start" enabled="true">
+      <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
         <collectionProp name="Arguments.arguments">
-          <elementProp name="" elementType="HTTPArgument">
+          <elementProp name="form_key" elementType="HTTPArgument">
             <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value"/>
+            <stringProp name="Argument.value">${admin_form_key}</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">form_key</stringProp>
+            <stringProp name="Argument.desc">false</stringProp>
+          </elementProp>
+          <elementProp name="entity" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">${entity}</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">entity</stringProp>
+          </elementProp>
+          <elementProp name="behavior" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">${adminImportBehavior}</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">behavior</stringProp>
+          </elementProp>
+          <elementProp name="validation_strategy" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">validation-stop-on-errors</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">validation_strategy</stringProp>
+            <stringProp name="Argument.desc">false</stringProp>
+          </elementProp>
+          <elementProp name="allowed_error_count" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">10</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">allowed_error_count</stringProp>
+            <stringProp name="Argument.desc">false</stringProp>
+          </elementProp>
+          <elementProp name="_import_field_separator" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">,</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">_import_field_separator</stringProp>
+            <stringProp name="Argument.desc">false</stringProp>
+          </elementProp>
+          <elementProp name="_import_multiple_value_separator" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">,</stringProp>
             <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">_import_multiple_value_separator</stringProp>
+            <stringProp name="Argument.desc">false</stringProp>
+          </elementProp>
+        </collectionProp>
+      </elementProp>
+      <stringProp name="HTTPSampler.domain"/>
+      <stringProp name="HTTPSampler.port"/>
+      <stringProp name="HTTPSampler.connect_timeout"/>
+      <stringProp name="HTTPSampler.response_timeout"/>
+      <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
+      <stringProp name="HTTPSampler.contentEncoding"/>
+      <stringProp name="HTTPSampler.path">${base_path}${admin_path}/admin/import/start</stringProp>
+      <stringProp name="HTTPSampler.method">POST</stringProp>
+      <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
+      <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
+      <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
+      <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
+      <stringProp name="HTTPSampler.implementation">HttpClient4</stringProp>
+      <elementProp name="HTTPsampler.Files" elementType="HTTPFileArgs">
+        <collectionProp name="HTTPFileArgs.files">
+          <elementProp name="${adminImportFilePath}" elementType="HTTPFileArg">
+            <stringProp name="File.path">${adminImportFilePath}</stringProp>
+            <stringProp name="File.paramname">import_file</stringProp>
+            <stringProp name="File.mimetype">application/vnd.ms-excel</stringProp>
           </elementProp>
         </collectionProp>
       </elementProp>
+      <boolProp name="HTTPSampler.monitor">false</boolProp>
+      <stringProp name="HTTPSampler.embedded_url_re"/>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/common/import_save.jmx</stringProp></HTTPSamplerProxy>
+    <hashTree>
+      <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Response Assertion" enabled="true">
+        <collectionProp name="Asserion.test_strings">
+          <stringProp name="-1731221824">Import successfully done</stringProp>
+        </collectionProp>
+        <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
+        <boolProp name="Assertion.assume_success">false</boolProp>
+        <intProp name="Assertion.test_type">16</intProp>
+      </ResponseAssertion>
+      <hashTree/>
+    </hashTree>
+  </hashTree>
+  
+    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Logout" enabled="true">
+      <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
+        <collectionProp name="Arguments.arguments"/>
+      </elementProp>
       <stringProp name="HTTPSampler.domain"/>
       <stringProp name="HTTPSampler.port"/>
       <stringProp name="HTTPSampler.connect_timeout"/>
       <stringProp name="HTTPSampler.response_timeout"/>
       <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
       <stringProp name="HTTPSampler.contentEncoding"/>
-      <stringProp name="HTTPSampler.path">${base_path}rest/default/V1/products/${simple_product_sku}</stringProp>
+      <stringProp name="HTTPSampler.path">${base_path}${admin_path}/admin/auth/logout/</stringProp>
       <stringProp name="HTTPSampler.method">GET</stringProp>
       <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
       <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
@@ -26685,49 +17696,28 @@ if (testLabel
       <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
       <boolProp name="HTTPSampler.monitor">false</boolProp>
       <stringProp name="HTTPSampler.embedded_url_re"/>
-    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/api/check_product_with_extensible_data_objects.jmx</stringProp></HTTPSamplerProxy>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/setup/admin_logout.jmx</stringProp></HTTPSamplerProxy>
     <hashTree>
-      <com.atlantbh.jmeter.plugins.jsonutils.jsonpathassertion.JSONPathAssertion guiclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathassertion.gui.JSONPathAssertionGui" testclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathassertion.JSONPathAssertion" testname="Assert product sku" enabled="true">
-        <stringProp name="JSON_PATH">$.sku</stringProp>
-        <stringProp name="EXPECTED_VALUE">${simple_product_sku}</stringProp>
-        <boolProp name="JSONVALIDATION">true</boolProp>
-        <boolProp name="EXPECT_NULL">false</boolProp>
-        <boolProp name="INVERT">false</boolProp>
-      </com.atlantbh.jmeter.plugins.jsonutils.jsonpathassertion.JSONPathAssertion>
-      <hashTree/>
-      <com.atlantbh.jmeter.plugins.jsonutils.jsonpathassertion.JSONPathAssertion guiclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathassertion.gui.JSONPathAssertionGui" testclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathassertion.JSONPathAssertion" testname="Assert product id" enabled="true">
-        <stringProp name="JSON_PATH">$.id</stringProp>
-        <stringProp name="EXPECTED_VALUE">${simple_product_id}</stringProp>
-        <boolProp name="JSONVALIDATION">true</boolProp>
-        <boolProp name="EXPECT_NULL">false</boolProp>
-        <boolProp name="INVERT">false</boolProp>
-      </com.atlantbh.jmeter.plugins.jsonutils.jsonpathassertion.JSONPathAssertion>
-      <hashTree/>
-      <com.atlantbh.jmeter.plugins.jsonutils.jsonpathassertion.JSONPathAssertion guiclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathassertion.gui.JSONPathAssertionGui" testclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathassertion.JSONPathAssertion" testname="Assert stock item id" enabled="true">
-        <stringProp name="JSON_PATH">$.extension_attributes.stock_item.item_id</stringProp>
-        <stringProp name="EXPECTED_VALUE">${simple_stock_item_id}</stringProp>
-        <boolProp name="JSONVALIDATION">true</boolProp>
-        <boolProp name="EXPECT_NULL">false</boolProp>
-        <boolProp name="INVERT">false</boolProp>
-      </com.atlantbh.jmeter.plugins.jsonutils.jsonpathassertion.JSONPathAssertion>
-      <hashTree/>
-      <com.atlantbh.jmeter.plugins.jsonutils.jsonpathassertion.JSONPathAssertion guiclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathassertion.gui.JSONPathAssertionGui" testclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathassertion.JSONPathAssertion" testname="Assert updated quantity" enabled="true">
-        <stringProp name="JSON_PATH">$.extension_attributes.stock_item.qty</stringProp>
-        <stringProp name="EXPECTED_VALUE">100</stringProp>
-        <boolProp name="JSONVALIDATION">true</boolProp>
-        <boolProp name="EXPECT_NULL">false</boolProp>
-        <boolProp name="INVERT">false</boolProp>
-      </com.atlantbh.jmeter.plugins.jsonutils.jsonpathassertion.JSONPathAssertion>
-      <hashTree/>
-    </hashTree>
+    
+    <BeanShellPostProcessor guiclass="TestBeanGUI" testclass="BeanShellPostProcessor" testname="Return Admin to Pool" enabled="true">
+        <boolProp name="resetInterpreter">false</boolProp>
+        <stringProp name="parameters"/>
+        <stringProp name="filename"/>
+        <stringProp name="script">
+adminUserList = props.get("adminUserList");
+adminUserList.add(vars.get("admin_user"));
+        </stringProp>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/common/return_admin_email_to_pool.jmx</stringProp></BeanShellPostProcessor>
+    <hashTree/>
+  </hashTree>
   </hashTree>
 
   
-    <ThroughputController guiclass="ThroughputControllerGui" testclass="ThroughputController" testname="API Process Orders" enabled="true">
+    <ThroughputController guiclass="ThroughputControllerGui" testclass="ThroughputController" testname="Import Customers" enabled="true">
       <intProp name="ThroughputController.style">1</intProp>
       <boolProp name="ThroughputController.perThread">false</boolProp>
       <intProp name="ThroughputController.maxThroughput">1</intProp>
-      <stringProp name="ThroughputController.percentThroughput">100</stringProp>
+      <stringProp name="ThroughputController.percentThroughput">${importCustomersPercentage}</stringProp>
     <stringProp name="TestPlan.comments">mpaf/tool/fragments/_system/scenario_controller_tmpl.jmx</stringProp></ThroughputController>
     <hashTree>
         <JSR223PreProcessor guiclass="TestBeanGUI" testclass="JSR223PreProcessor" testname="Set Test Label" enabled="true">
@@ -26748,64 +17738,178 @@ if (testLabel
         <hashTree/>
         <BeanShellSampler guiclass="BeanShellSamplerGui" testclass="BeanShellSampler" testname="SetUp - Set Label" enabled="true">
             <stringProp name="BeanShellSampler.query">
-                vars.put("testLabel", "API Process Orders");
+                vars.put("testLabel", "Import Customers");
             </stringProp>
             <boolProp name="BeanShellSampler.resetInterpreter">true</boolProp>
         </BeanShellSampler>
         <hashTree/>
     
-    <BeanShellSampler guiclass="BeanShellSamplerGui" testclass="BeanShellSampler" testname="SetUp - Set Arguments" enabled="true">
-      <stringProp name="BeanShellSampler.query">// Each thread gets an equal number of orders, based on how many orders are available.
-
-      int apiProcessOrders = Integer.parseInt("${apiProcessOrders}");
-      if (apiProcessOrders &gt; 0) {
-      ordersPerThread = apiProcessOrders;
-      } else {
-      ordersPerThread = 1;
-      }
+        <JSR223PostProcessor guiclass="TestBeanGUI" testclass="JSR223PostProcessor" testname="Get admin form key PostProcessor" enabled="true">
+        <stringProp name="script">
+        function getFormKeyFromResponse()
+        {
+            var url = prev.getUrlAsString(),
+            responseCode =  prev.getResponseCode(),
+            formKey = null;
+            searchPattern = /var FORM_KEY = '(.+)'/;
+            if (responseCode == "200" &amp;&amp; url) {
+                response = prev.getResponseDataAsString();
+                formKey = response  &amp;&amp; response.match(searchPattern) ? response.match(searchPattern)[1] : null;
+            }
+            return formKey;
+        }
 
+        formKey = vars.get("form_key_storage");
 
-      threadNum = ${__threadNum};
-      vars.put("ordersPerThread", String.valueOf(ordersPerThread));
-      vars.put("threadNum", String.valueOf(threadNum));
+	   currentFormKey = getFormKeyFromResponse();
 
+	   if (currentFormKey != null &amp;&amp; currentFormKey != formKey) {
+		  vars.put("form_key_storage", currentFormKey);
+	   }
+        </stringProp>
+        <stringProp name="scriptLanguage">javascript</stringProp>
+        <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin/handle_admin_form_key.jmx</stringProp></JSR223PostProcessor>
+        <hashTree/>
+        <JSR223PreProcessor guiclass="TestBeanGUI" testclass="JSR223PreProcessor" testname="Set admin form key PreProcessor" enabled="true">
+            <stringProp name="script">
+                formKey =  vars.get("form_key_storage");
+                if (formKey
+                    &amp;&amp; sampler.getClass().getName() == 'org.apache.jmeter.protocol.http.sampler.HTTPSamplerProxy'
+                    &amp;&amp; sampler.getMethod() == "POST")
+                    {
+                        arguments = sampler.getArguments();
+                        for (i=0; i&lt;arguments.getArgumentCount(); i++)
+                        {
+                            argument = arguments.getArgument(i);
+                            if (argument.getName() == 'form_key' &amp;&amp; argument.getValue() != formKey) {
+                            log.info("admin form key updated: " + argument.getValue() + " =&gt; " + formKey);
+                            argument.setValue(formKey);
+                        }
+                    }
+                }
+            </stringProp>
+            <stringProp name="scriptLanguage">javascript</stringProp>
+        </JSR223PreProcessor>
+        <hashTree/>
+    
+    <CookieManager guiclass="CookiePanel" testclass="CookieManager" testname="HTTP Cookie Manager" enabled="true">
+      <collectionProp name="CookieManager.cookies"/>
+      <boolProp name="CookieManager.clearEachIteration">false</boolProp>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/http_cookie_manager_without_clear_each_iteration.jmx</stringProp></CookieManager>
+    <hashTree/>
+  
+    <GenericController guiclass="LogicControllerGui" testclass="GenericController" testname="Admin Login" enabled="true">
+  <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/simple_controller.jmx</stringProp>
+</GenericController>
+    <hashTree>
+    <CriticalSectionController guiclass="CriticalSectionControllerGui" testclass="CriticalSectionController" testname="Admin Login Lock" enabled="true">
+        <stringProp name="CriticalSectionController.lockName">get-admin-email</stringProp>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/lock_controller.jmx</stringProp></CriticalSectionController>
+    <hashTree>
+    
+    <BeanShellSampler guiclass="BeanShellSamplerGui" testclass="BeanShellSampler" testname="SetUp - Get Admin Email" enabled="true">
+      <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/get_admin_email.jmx</stringProp>
+      <stringProp name="BeanShellSampler.query">
+adminUserList = props.get("adminUserList");
+adminUser = adminUserList.poll();
+if (adminUser == null) {
+  SampleResult.setResponseMessage("adminUser list is empty");
+  SampleResult.setResponseData("adminUser list is empty","UTF-8");
+  IsSuccess=false;
+  SampleResult.setSuccessful(false);
+  SampleResult.setStopThread(true);
+}
+vars.put("admin_user", adminUser);
       </stringProp>
       <stringProp name="BeanShellSampler.filename"/>
       <stringProp name="BeanShellSampler.parameters"/>
-      <boolProp name="BeanShellSampler.resetInterpreter">false</boolProp>
-    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/api/process_orders/setup.jmx</stringProp></BeanShellSampler>
+      <boolProp name="BeanShellSampler.resetInterpreter">true</boolProp>
+    </BeanShellSampler>
     <hashTree/>
+  </hashTree>
   
-    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Get Orders" enabled="true">
+    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="SetUp - Login" enabled="true">
+      <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
+        <collectionProp name="Arguments.arguments"/>
+      </elementProp>
+      <stringProp name="HTTPSampler.domain"/>
+      <stringProp name="HTTPSampler.port"/>
+      <stringProp name="HTTPSampler.connect_timeout"/>
+      <stringProp name="HTTPSampler.response_timeout"/>
+      <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
+      <stringProp name="HTTPSampler.contentEncoding"/>
+      <stringProp name="HTTPSampler.path">${base_path}${admin_path}</stringProp>
+      <stringProp name="HTTPSampler.method">GET</stringProp>
+      <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
+      <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
+      <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
+      <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
+      <boolProp name="HTTPSampler.monitor">false</boolProp>
+      <stringProp name="HTTPSampler.embedded_url_re"/>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_login/admin_login.jmx</stringProp></HTTPSamplerProxy>
+    <hashTree>
+      <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert login form shown" enabled="true">
+        <collectionProp name="Asserion.test_strings">
+          <stringProp name="-1397214398">Welcome</stringProp>
+          <stringProp name="-515240035">&lt;title&gt;Magento Admin&lt;/title&gt;</stringProp>
+        </collectionProp>
+        <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
+        <boolProp name="Assertion.assume_success">false</boolProp>
+        <intProp name="Assertion.test_type">2</intProp>
+      </ResponseAssertion>
+      <hashTree/>
+      <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract form key" enabled="true">
+        <stringProp name="RegexExtractor.useHeaders">false</stringProp>
+        <stringProp name="RegexExtractor.refname">admin_form_key</stringProp>
+        <stringProp name="RegexExtractor.regex">&lt;input name="form_key" type="hidden" value="([^'"]+)" /&gt;</stringProp>
+        <stringProp name="RegexExtractor.template">$1$</stringProp>
+        <stringProp name="RegexExtractor.default"/>
+        <stringProp name="RegexExtractor.match_number">1</stringProp>
+      </RegexExtractor>
+      <hashTree/>
+      <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert form_key extracted" enabled="true">
+        <collectionProp name="Asserion.test_strings">
+          <stringProp name="2845929">^.+$</stringProp>
+        </collectionProp>
+        <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
+        <boolProp name="Assertion.assume_success">false</boolProp>
+        <intProp name="Assertion.test_type">1</intProp>
+        <stringProp name="Assertion.scope">variable</stringProp>
+        <stringProp name="Scope.variable">admin_form_key</stringProp>
+      </ResponseAssertion>
+      <hashTree/>
+    </hashTree>
+  
+    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="SetUp - Login Submit Form" enabled="true">
       <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
         <collectionProp name="Arguments.arguments">
-          <elementProp name="searchCriteria[filterGroups][0][filters][0][field]" elementType="HTTPArgument">
+          <elementProp name="dummy" elementType="HTTPArgument">
             <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">status</stringProp>
+            <stringProp name="Argument.value"/>
             <stringProp name="Argument.metadata">=</stringProp>
             <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">searchCriteria[filterGroups][0][filters][0][field]</stringProp>
+            <stringProp name="Argument.name">dummy</stringProp>
           </elementProp>
-          <elementProp name="searchCriteria[filterGroups][0][filters][0][value]" elementType="HTTPArgument">
+          <elementProp name="form_key" elementType="HTTPArgument">
             <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">Pending</stringProp>
+            <stringProp name="Argument.value">${admin_form_key}</stringProp>
             <stringProp name="Argument.metadata">=</stringProp>
             <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">searchCriteria[filterGroups][0][filters][0][value]</stringProp>
+            <stringProp name="Argument.name">form_key</stringProp>
           </elementProp>
-          <elementProp name="searchCriteria[pageSize]" elementType="HTTPArgument">
+          <elementProp name="login[password]" elementType="HTTPArgument">
             <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">${ordersPerThread}</stringProp>
+            <stringProp name="Argument.value">${admin_password}</stringProp>
             <stringProp name="Argument.metadata">=</stringProp>
             <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">searchCriteria[pageSize]</stringProp>
+            <stringProp name="Argument.name">login[password]</stringProp>
           </elementProp>
-          <elementProp name="searchCriteria[current_page]" elementType="HTTPArgument">
+          <elementProp name="login[username]" elementType="HTTPArgument">
             <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">${threadNum}</stringProp>
+            <stringProp name="Argument.value">${admin_user}</stringProp>
             <stringProp name="Argument.metadata">=</stringProp>
             <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">searchCriteria[current_page]</stringProp>
+            <stringProp name="Argument.name">login[username]</stringProp>
           </elementProp>
         </collectionProp>
       </elementProp>
@@ -26815,33 +17919,47 @@ if (testLabel
       <stringProp name="HTTPSampler.response_timeout"/>
       <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
       <stringProp name="HTTPSampler.contentEncoding"/>
-      <stringProp name="HTTPSampler.path">${base_path}rest/default/V1/orders</stringProp>
-      <stringProp name="HTTPSampler.method">GET</stringProp>
+      <stringProp name="HTTPSampler.path">${base_path}${admin_path}/admin/dashboard/</stringProp>
+      <stringProp name="HTTPSampler.method">POST</stringProp>
       <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
       <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
       <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
       <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
+      <stringProp name="HTTPSampler.implementation">Java</stringProp>
       <boolProp name="HTTPSampler.monitor">false</boolProp>
       <stringProp name="HTTPSampler.embedded_url_re"/>
-    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/api/process_orders/get_orders.jmx</stringProp></HTTPSamplerProxy>
+      <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_login/admin_login_submit_form.jmx</stringProp>
+    </HTTPSamplerProxy>
     <hashTree>
-      <com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor guiclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.gui.JSONPathExtractorGui" testclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor" testname="Extract entity ids" enabled="true">
-        <stringProp name="VAR">entity_ids</stringProp>
-        <stringProp name="JSONPATH">$.items[*].entity_id</stringProp>
-        <stringProp name="DEFAULT"/>
-        <stringProp name="VARIABLE"/>
-        <stringProp name="SUBJECT">BODY</stringProp>
-      </com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor>
-      <hashTree/>
+        <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract form key" enabled="true">
+            <stringProp name="RegexExtractor.useHeaders">false</stringProp>
+            <stringProp name="RegexExtractor.refname">admin_form_key</stringProp>
+            <stringProp name="RegexExtractor.regex">&lt;input name="form_key" type="hidden" value="([^'"]+)" /&gt;</stringProp>
+            <stringProp name="RegexExtractor.template">$1$</stringProp>
+            <stringProp name="RegexExtractor.default"/>
+            <stringProp name="RegexExtractor.match_number">1</stringProp>
+        <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_login/admin_retrieve_form_key.jmx</stringProp></RegexExtractor>
+        <hashTree/>
     </hashTree>
+  </hashTree>
   
-    <ForeachController guiclass="ForeachControlPanel" testclass="ForeachController" testname="ForEach Order" enabled="true">
-      <stringProp name="ForeachController.inputVal">entity_ids</stringProp>
-      <stringProp name="ForeachController.returnVal">order_id</stringProp>
-      <boolProp name="ForeachController.useSeparator">true</boolProp>
-    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/api/process_orders/for_each_order.jmx</stringProp></ForeachController>
+    <BeanShellSampler guiclass="BeanShellSamplerGui" testclass="BeanShellSampler" testname="SetUp - Set Arguments" enabled="true">
+      <stringProp name="BeanShellSampler.query">vars.put("entity", "customer");
+String behavior = "${adminImportCustomerBehavior}";
+vars.put("adminImportBehavior", behavior);
+String filepath = "${files_folder}${adminImportCustomerFilePath}";
+vars.put("adminImportFilePath", filepath);  </stringProp>
+      <stringProp name="BeanShellSampler.filename"/>
+      <stringProp name="BeanShellSampler.parameters"/>
+      <boolProp name="BeanShellSampler.resetInterpreter">true</boolProp>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/import_customers/setup.jmx</stringProp></BeanShellSampler>
+    <hashTree/>
+  
+    <GenericController guiclass="LogicControllerGui" testclass="GenericController" testname="Simple Controller" enabled="true">
+  <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/simple_controller.jmx</stringProp>
+</GenericController>
     <hashTree>
-    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Create Invoice" enabled="true">
+    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Import Page" enabled="true">
       <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
         <collectionProp name="Arguments.arguments"/>
       </elementProp>
@@ -26851,30 +17969,177 @@ if (testLabel
       <stringProp name="HTTPSampler.response_timeout"/>
       <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
       <stringProp name="HTTPSampler.contentEncoding"/>
-      <stringProp name="HTTPSampler.path">${base_path}rest/default/V1/order/${order_id}/invoice</stringProp>
+      <stringProp name="HTTPSampler.path">${base_path}${admin_path}/admin/import/</stringProp>
+      <stringProp name="HTTPSampler.method">GET</stringProp>
+      <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
+      <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
+      <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
+      <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
+      <boolProp name="HTTPSampler.monitor">false</boolProp>
+      <stringProp name="HTTPSampler.embedded_url_re"/>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/common/import.jmx</stringProp></HTTPSamplerProxy>
+    <hashTree>
+      <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert success" enabled="true">
+        <collectionProp name="Asserion.test_strings">
+          <stringProp name="1723813687">Import Settings</stringProp>
+        </collectionProp>
+        <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
+        <boolProp name="Assertion.assume_success">false</boolProp>
+        <intProp name="Assertion.test_type">2</intProp>
+      </ResponseAssertion>
+      <hashTree/>
+    </hashTree>
+  
+    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Import Validate" enabled="true">
+      <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
+        <collectionProp name="Arguments.arguments">
+          <elementProp name="form_key" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">${admin_form_key}</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">form_key</stringProp>
+            <stringProp name="Argument.desc">false</stringProp>
+          </elementProp>
+          <elementProp name="entity" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">${entity}</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">entity</stringProp>
+          </elementProp>
+          <elementProp name="behavior" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">${adminImportBehavior}</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">behavior</stringProp>
+          </elementProp>
+          <elementProp name="validation_strategy" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">validation-stop-on-errors</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">validation_strategy</stringProp>
+          </elementProp>
+          <elementProp name="allowed_error_count" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">10</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">allowed_error_count</stringProp>
+          </elementProp>
+          <elementProp name="_import_field_separator" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">,</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">_import_field_separator</stringProp>
+          </elementProp>
+          <elementProp name="_import_multiple_value_separator" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">,</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">_import_multiple_value_separator</stringProp>
+          </elementProp>
+        </collectionProp>
+      </elementProp>
+      <stringProp name="HTTPSampler.domain"/>
+      <stringProp name="HTTPSampler.port"/>
+      <stringProp name="HTTPSampler.connect_timeout"/>
+      <stringProp name="HTTPSampler.response_timeout"/>
+      <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
+      <stringProp name="HTTPSampler.contentEncoding"/>
+      <stringProp name="HTTPSampler.path">${base_path}${admin_path}/admin/import/validate</stringProp>
       <stringProp name="HTTPSampler.method">POST</stringProp>
       <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
       <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
       <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
       <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
+      <stringProp name="HTTPSampler.implementation">HttpClient4</stringProp>
+      <elementProp name="HTTPsampler.Files" elementType="HTTPFileArgs">
+        <collectionProp name="HTTPFileArgs.files">
+          <elementProp name="${adminImportFilePath}" elementType="HTTPFileArg">
+            <stringProp name="File.path">${adminImportFilePath}</stringProp>
+            <stringProp name="File.paramname">import_file</stringProp>
+            <stringProp name="File.mimetype">application/vnd.ms-excel</stringProp>
+          </elementProp>
+        </collectionProp>
+      </elementProp>
       <boolProp name="HTTPSampler.monitor">false</boolProp>
       <stringProp name="HTTPSampler.embedded_url_re"/>
-    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/api/process_orders/create_invoice.jmx</stringProp></HTTPSamplerProxy>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/common/import_validate.jmx</stringProp></HTTPSamplerProxy>
     <hashTree>
       <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Response Assertion" enabled="true">
         <collectionProp name="Asserion.test_strings">
-          <stringProp name="34237953">"\d+"</stringProp>
+          <stringProp name="37280142">File is valid! To start import process</stringProp>
         </collectionProp>
         <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
         <boolProp name="Assertion.assume_success">false</boolProp>
-        <intProp name="Assertion.test_type">2</intProp>
+        <intProp name="Assertion.test_type">16</intProp>
       </ResponseAssertion>
       <hashTree/>
     </hashTree>
   
-    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Create Shipment" enabled="true">
+    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Import Start" enabled="true">
       <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
-        <collectionProp name="Arguments.arguments"/>
+        <collectionProp name="Arguments.arguments">
+          <elementProp name="form_key" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">${admin_form_key}</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">form_key</stringProp>
+            <stringProp name="Argument.desc">false</stringProp>
+          </elementProp>
+          <elementProp name="entity" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">${entity}</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">entity</stringProp>
+          </elementProp>
+          <elementProp name="behavior" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">${adminImportBehavior}</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">behavior</stringProp>
+          </elementProp>
+          <elementProp name="validation_strategy" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">validation-stop-on-errors</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">validation_strategy</stringProp>
+            <stringProp name="Argument.desc">false</stringProp>
+          </elementProp>
+          <elementProp name="allowed_error_count" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">10</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">allowed_error_count</stringProp>
+            <stringProp name="Argument.desc">false</stringProp>
+          </elementProp>
+          <elementProp name="_import_field_separator" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">,</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">_import_field_separator</stringProp>
+            <stringProp name="Argument.desc">false</stringProp>
+          </elementProp>
+          <elementProp name="_import_multiple_value_separator" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">,</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">_import_multiple_value_separator</stringProp>
+            <stringProp name="Argument.desc">false</stringProp>
+          </elementProp>
+        </collectionProp>
       </elementProp>
       <stringProp name="HTTPSampler.domain"/>
       <stringProp name="HTTPSampler.port"/>
@@ -26882,35 +18147,78 @@ if (testLabel
       <stringProp name="HTTPSampler.response_timeout"/>
       <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
       <stringProp name="HTTPSampler.contentEncoding"/>
-      <stringProp name="HTTPSampler.path">${base_path}rest/default/V1/order/${order_id}/ship</stringProp>
+      <stringProp name="HTTPSampler.path">${base_path}${admin_path}/admin/import/start</stringProp>
       <stringProp name="HTTPSampler.method">POST</stringProp>
       <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
       <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
       <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
       <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
+      <stringProp name="HTTPSampler.implementation">HttpClient4</stringProp>
+      <elementProp name="HTTPsampler.Files" elementType="HTTPFileArgs">
+        <collectionProp name="HTTPFileArgs.files">
+          <elementProp name="${adminImportFilePath}" elementType="HTTPFileArg">
+            <stringProp name="File.path">${adminImportFilePath}</stringProp>
+            <stringProp name="File.paramname">import_file</stringProp>
+            <stringProp name="File.mimetype">application/vnd.ms-excel</stringProp>
+          </elementProp>
+        </collectionProp>
+      </elementProp>
       <boolProp name="HTTPSampler.monitor">false</boolProp>
       <stringProp name="HTTPSampler.embedded_url_re"/>
-    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/api/process_orders/create_shipment.jmx</stringProp></HTTPSamplerProxy>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/common/import_save.jmx</stringProp></HTTPSamplerProxy>
     <hashTree>
       <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Response Assertion" enabled="true">
         <collectionProp name="Asserion.test_strings">
-          <stringProp name="34237953">"\d+"</stringProp>
+          <stringProp name="-1731221824">Import successfully done</stringProp>
         </collectionProp>
         <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
         <boolProp name="Assertion.assume_success">false</boolProp>
-        <intProp name="Assertion.test_type">2</intProp>
+        <intProp name="Assertion.test_type">16</intProp>
       </ResponseAssertion>
       <hashTree/>
     </hashTree>
   </hashTree>
+  
+    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Logout" enabled="true">
+      <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
+        <collectionProp name="Arguments.arguments"/>
+      </elementProp>
+      <stringProp name="HTTPSampler.domain"/>
+      <stringProp name="HTTPSampler.port"/>
+      <stringProp name="HTTPSampler.connect_timeout"/>
+      <stringProp name="HTTPSampler.response_timeout"/>
+      <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
+      <stringProp name="HTTPSampler.contentEncoding"/>
+      <stringProp name="HTTPSampler.path">${base_path}${admin_path}/admin/auth/logout/</stringProp>
+      <stringProp name="HTTPSampler.method">GET</stringProp>
+      <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
+      <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
+      <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
+      <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
+      <boolProp name="HTTPSampler.monitor">false</boolProp>
+      <stringProp name="HTTPSampler.embedded_url_re"/>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/setup/admin_logout.jmx</stringProp></HTTPSamplerProxy>
+    <hashTree>
+    
+    <BeanShellPostProcessor guiclass="TestBeanGUI" testclass="BeanShellPostProcessor" testname="Return Admin to Pool" enabled="true">
+        <boolProp name="resetInterpreter">false</boolProp>
+        <stringProp name="parameters"/>
+        <stringProp name="filename"/>
+        <stringProp name="script">
+adminUserList = props.get("adminUserList");
+adminUserList.add(vars.get("admin_user"));
+        </stringProp>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/common/return_admin_email_to_pool.jmx</stringProp></BeanShellPostProcessor>
+    <hashTree/>
+  </hashTree>
   </hashTree>
 
   
-    <ThroughputController guiclass="ThroughputControllerGui" testclass="ThroughputController" testname="API Catalog Browsing" enabled="true">
+    <ThroughputController guiclass="ThroughputControllerGui" testclass="ThroughputController" testname="Export Products" enabled="true">
       <intProp name="ThroughputController.style">1</intProp>
       <boolProp name="ThroughputController.perThread">false</boolProp>
       <intProp name="ThroughputController.maxThroughput">1</intProp>
-      <stringProp name="ThroughputController.percentThroughput">100</stringProp>
+      <stringProp name="ThroughputController.percentThroughput">${exportProductsPercentage}</stringProp>
     <stringProp name="TestPlan.comments">mpaf/tool/fragments/_system/scenario_controller_tmpl.jmx</stringProp></ThroughputController>
     <hashTree>
         <JSR223PreProcessor guiclass="TestBeanGUI" testclass="JSR223PreProcessor" testname="Set Test Label" enabled="true">
@@ -26931,14 +18239,98 @@ if (testLabel
         <hashTree/>
         <BeanShellSampler guiclass="BeanShellSamplerGui" testclass="BeanShellSampler" testname="SetUp - Set Label" enabled="true">
             <stringProp name="BeanShellSampler.query">
-                vars.put("testLabel", "API Catalog Browsing");
+                vars.put("testLabel", "Export Products");
             </stringProp>
             <boolProp name="BeanShellSampler.resetInterpreter">true</boolProp>
         </BeanShellSampler>
         <hashTree/>
     
-    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Get categories" enabled="true">
-      <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" testname="User Defined Variables" enabled="true">
+        <JSR223PostProcessor guiclass="TestBeanGUI" testclass="JSR223PostProcessor" testname="Get admin form key PostProcessor" enabled="true">
+        <stringProp name="script">
+        function getFormKeyFromResponse()
+        {
+            var url = prev.getUrlAsString(),
+            responseCode =  prev.getResponseCode(),
+            formKey = null;
+            searchPattern = /var FORM_KEY = '(.+)'/;
+            if (responseCode == "200" &amp;&amp; url) {
+                response = prev.getResponseDataAsString();
+                formKey = response  &amp;&amp; response.match(searchPattern) ? response.match(searchPattern)[1] : null;
+            }
+            return formKey;
+        }
+
+        formKey = vars.get("form_key_storage");
+
+	   currentFormKey = getFormKeyFromResponse();
+
+	   if (currentFormKey != null &amp;&amp; currentFormKey != formKey) {
+		  vars.put("form_key_storage", currentFormKey);
+	   }
+        </stringProp>
+        <stringProp name="scriptLanguage">javascript</stringProp>
+        <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin/handle_admin_form_key.jmx</stringProp></JSR223PostProcessor>
+        <hashTree/>
+        <JSR223PreProcessor guiclass="TestBeanGUI" testclass="JSR223PreProcessor" testname="Set admin form key PreProcessor" enabled="true">
+            <stringProp name="script">
+                formKey =  vars.get("form_key_storage");
+                if (formKey
+                    &amp;&amp; sampler.getClass().getName() == 'org.apache.jmeter.protocol.http.sampler.HTTPSamplerProxy'
+                    &amp;&amp; sampler.getMethod() == "POST")
+                    {
+                        arguments = sampler.getArguments();
+                        for (i=0; i&lt;arguments.getArgumentCount(); i++)
+                        {
+                            argument = arguments.getArgument(i);
+                            if (argument.getName() == 'form_key' &amp;&amp; argument.getValue() != formKey) {
+                            log.info("admin form key updated: " + argument.getValue() + " =&gt; " + formKey);
+                            argument.setValue(formKey);
+                        }
+                    }
+                }
+            </stringProp>
+            <stringProp name="scriptLanguage">javascript</stringProp>
+        </JSR223PreProcessor>
+        <hashTree/>
+    
+    <CookieManager guiclass="CookiePanel" testclass="CookieManager" testname="HTTP Cookie Manager" enabled="true">
+      <collectionProp name="CookieManager.cookies"/>
+      <boolProp name="CookieManager.clearEachIteration">false</boolProp>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/http_cookie_manager_without_clear_each_iteration.jmx</stringProp></CookieManager>
+    <hashTree/>
+  
+    <GenericController guiclass="LogicControllerGui" testclass="GenericController" testname="Admin Login" enabled="true">
+  <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/simple_controller.jmx</stringProp>
+</GenericController>
+    <hashTree>
+    <CriticalSectionController guiclass="CriticalSectionControllerGui" testclass="CriticalSectionController" testname="Admin Login Lock" enabled="true">
+        <stringProp name="CriticalSectionController.lockName">get-admin-email</stringProp>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/lock_controller.jmx</stringProp></CriticalSectionController>
+    <hashTree>
+    
+    <BeanShellSampler guiclass="BeanShellSamplerGui" testclass="BeanShellSampler" testname="SetUp - Get Admin Email" enabled="true">
+      <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/get_admin_email.jmx</stringProp>
+      <stringProp name="BeanShellSampler.query">
+adminUserList = props.get("adminUserList");
+adminUser = adminUserList.poll();
+if (adminUser == null) {
+  SampleResult.setResponseMessage("adminUser list is empty");
+  SampleResult.setResponseData("adminUser list is empty","UTF-8");
+  IsSuccess=false;
+  SampleResult.setSuccessful(false);
+  SampleResult.setStopThread(true);
+}
+vars.put("admin_user", adminUser);
+      </stringProp>
+      <stringProp name="BeanShellSampler.filename"/>
+      <stringProp name="BeanShellSampler.parameters"/>
+      <boolProp name="BeanShellSampler.resetInterpreter">true</boolProp>
+    </BeanShellSampler>
+    <hashTree/>
+  </hashTree>
+  
+    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="SetUp - Login" enabled="true">
+      <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
         <collectionProp name="Arguments.arguments"/>
       </elementProp>
       <stringProp name="HTTPSampler.domain"/>
@@ -26947,7 +18339,7 @@ if (testLabel
       <stringProp name="HTTPSampler.response_timeout"/>
       <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
       <stringProp name="HTTPSampler.contentEncoding"/>
-      <stringProp name="HTTPSampler.path">${base_path}rest/default/V1/categories</stringProp>
+      <stringProp name="HTTPSampler.path">${base_path}${admin_path}</stringProp>
       <stringProp name="HTTPSampler.method">GET</stringProp>
       <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
       <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
@@ -26955,42 +18347,109 @@ if (testLabel
       <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
       <boolProp name="HTTPSampler.monitor">false</boolProp>
       <stringProp name="HTTPSampler.embedded_url_re"/>
-    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/api/get_categories.jmx</stringProp></HTTPSamplerProxy>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_login/admin_login.jmx</stringProp></HTTPSamplerProxy>
     <hashTree>
-      <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert results are present" enabled="true">
+      <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert login form shown" enabled="true">
         <collectionProp name="Asserion.test_strings">
-          <stringProp name="-1294635157">errors</stringProp>
+          <stringProp name="-1397214398">Welcome</stringProp>
+          <stringProp name="-515240035">&lt;title&gt;Magento Admin&lt;/title&gt;</stringProp>
         </collectionProp>
         <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
         <boolProp name="Assertion.assume_success">false</boolProp>
-        <intProp name="Assertion.test_type">6</intProp>
-        <stringProp name="Assertion.scope">variable</stringProp>
-        <stringProp name="Scope.variable"/>
+        <intProp name="Assertion.test_type">2</intProp>
       </ResponseAssertion>
       <hashTree/>
-      <com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor guiclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.gui.JSONPathExtractorGui" testclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor" testname="Extract search category id" enabled="true">
-        <stringProp name="VAR">search_category_id</stringProp>
-        <stringProp name="JSONPATH">$.id</stringProp>
-        <stringProp name="DEFAULT"/>
-        <stringProp name="VARIABLE"/>
-        <stringProp name="SUBJECT">BODY</stringProp>
-      </com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor>
+      <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract form key" enabled="true">
+        <stringProp name="RegexExtractor.useHeaders">false</stringProp>
+        <stringProp name="RegexExtractor.refname">admin_form_key</stringProp>
+        <stringProp name="RegexExtractor.regex">&lt;input name="form_key" type="hidden" value="([^'"]+)" /&gt;</stringProp>
+        <stringProp name="RegexExtractor.template">$1$</stringProp>
+        <stringProp name="RegexExtractor.default"/>
+        <stringProp name="RegexExtractor.match_number">1</stringProp>
+      </RegexExtractor>
       <hashTree/>
-      <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert search category id is not null" enabled="true">
+      <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert form_key extracted" enabled="true">
         <collectionProp name="Asserion.test_strings">
-          <stringProp name="89649215">^\d+$</stringProp>
+          <stringProp name="2845929">^.+$</stringProp>
         </collectionProp>
         <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
         <boolProp name="Assertion.assume_success">false</boolProp>
         <intProp name="Assertion.test_type">1</intProp>
         <stringProp name="Assertion.scope">variable</stringProp>
-        <stringProp name="Scope.variable">search_category_id</stringProp>
+        <stringProp name="Scope.variable">admin_form_key</stringProp>
       </ResponseAssertion>
       <hashTree/>
     </hashTree>
   
-    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Get category" enabled="true">
-      <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" testname="User Defined Variables" enabled="true">
+    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="SetUp - Login Submit Form" enabled="true">
+      <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
+        <collectionProp name="Arguments.arguments">
+          <elementProp name="dummy" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value"/>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">dummy</stringProp>
+          </elementProp>
+          <elementProp name="form_key" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">${admin_form_key}</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">form_key</stringProp>
+          </elementProp>
+          <elementProp name="login[password]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">${admin_password}</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">login[password]</stringProp>
+          </elementProp>
+          <elementProp name="login[username]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">${admin_user}</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">login[username]</stringProp>
+          </elementProp>
+        </collectionProp>
+      </elementProp>
+      <stringProp name="HTTPSampler.domain"/>
+      <stringProp name="HTTPSampler.port"/>
+      <stringProp name="HTTPSampler.connect_timeout"/>
+      <stringProp name="HTTPSampler.response_timeout"/>
+      <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
+      <stringProp name="HTTPSampler.contentEncoding"/>
+      <stringProp name="HTTPSampler.path">${base_path}${admin_path}/admin/dashboard/</stringProp>
+      <stringProp name="HTTPSampler.method">POST</stringProp>
+      <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
+      <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
+      <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
+      <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
+      <stringProp name="HTTPSampler.implementation">Java</stringProp>
+      <boolProp name="HTTPSampler.monitor">false</boolProp>
+      <stringProp name="HTTPSampler.embedded_url_re"/>
+      <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_login/admin_login_submit_form.jmx</stringProp>
+    </HTTPSamplerProxy>
+    <hashTree>
+        <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract form key" enabled="true">
+            <stringProp name="RegexExtractor.useHeaders">false</stringProp>
+            <stringProp name="RegexExtractor.refname">admin_form_key</stringProp>
+            <stringProp name="RegexExtractor.regex">&lt;input name="form_key" type="hidden" value="([^'"]+)" /&gt;</stringProp>
+            <stringProp name="RegexExtractor.template">$1$</stringProp>
+            <stringProp name="RegexExtractor.default"/>
+            <stringProp name="RegexExtractor.match_number">1</stringProp>
+        <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_login/admin_retrieve_form_key.jmx</stringProp></RegexExtractor>
+        <hashTree/>
+    </hashTree>
+  </hashTree>
+  
+    <GenericController guiclass="LogicControllerGui" testclass="GenericController" testname="Simple Controller" enabled="true">
+  <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/simple_controller.jmx</stringProp>
+</GenericController>
+    <hashTree>
+    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Export Page" enabled="true">
+      <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
         <collectionProp name="Arguments.arguments"/>
       </elementProp>
       <stringProp name="HTTPSampler.domain"/>
@@ -26999,7 +18458,7 @@ if (testLabel
       <stringProp name="HTTPSampler.response_timeout"/>
       <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
       <stringProp name="HTTPSampler.contentEncoding"/>
-      <stringProp name="HTTPSampler.path">${base_path}rest/default/V1/categories/${search_category_id}</stringProp>
+      <stringProp name="HTTPSampler.path">${base_path}${admin_path}/admin/export/</stringProp>
       <stringProp name="HTTPSampler.method">GET</stringProp>
       <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
       <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
@@ -27007,541 +18466,574 @@ if (testLabel
       <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
       <boolProp name="HTTPSampler.monitor">false</boolProp>
       <stringProp name="HTTPSampler.embedded_url_re"/>
-    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/api/get_category.jmx</stringProp></HTTPSamplerProxy>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/common/export.jmx</stringProp></HTTPSamplerProxy>
     <hashTree>
-      <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert results are present" enabled="true">
+      <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert success" enabled="true">
         <collectionProp name="Asserion.test_strings">
-          <stringProp name="-1294635157">errors</stringProp>
+          <stringProp name="1723813687">Export Settings</stringProp>
         </collectionProp>
         <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
         <boolProp name="Assertion.assume_success">false</boolProp>
-        <intProp name="Assertion.test_type">6</intProp>
-        <stringProp name="Assertion.scope">variable</stringProp>
-        <stringProp name="Scope.variable"/>
+        <intProp name="Assertion.test_type">2</intProp>
       </ResponseAssertion>
       <hashTree/>
     </hashTree>
   
-    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Get products" enabled="true">
-      <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" testname="User Defined Variables" enabled="true">
+    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Export Products" enabled="true">
+      <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
         <collectionProp name="Arguments.arguments">
-          <elementProp name="searchCriteria[page_size]" elementType="HTTPArgument">
+          <elementProp name="form_key" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.name">form_key</stringProp>
+            <stringProp name="Argument.value">${admin_form_key}</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+          </elementProp>
+          <elementProp name="attribute_code" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.name">attribute_code</stringProp>
+            <stringProp name="Argument.value"/>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+          </elementProp>
+          <elementProp name="export_filter[allow_message][]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.name">export_filter[allow_message][]</stringProp>
+            <stringProp name="Argument.value">,</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+          </elementProp>
+          <elementProp name="export_filter[allow_open_amount]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.name">export_filter[allow_open_amount]</stringProp>
+            <stringProp name="Argument.value"/>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+          </elementProp>
+          <elementProp name="export_filter[category_ids]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.name">export_filter[category_ids]</stringProp>
+            <stringProp name="Argument.value">24,25,26,27,28,29,30</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+          </elementProp>
+          <elementProp name="export_filter[configurable_variations]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.name">export_filter[configurable_variations]</stringProp>
+            <stringProp name="Argument.value"/>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+          </elementProp>
+          <elementProp name="export_filter[cost][]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.name">export_filter[cost][]</stringProp>
+            <stringProp name="Argument.value">,</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+          </elementProp>
+          <elementProp name="export_filter[country_of_manufacture]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.name">export_filter[country_of_manufacture]</stringProp>
+            <stringProp name="Argument.value"/>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+          </elementProp>
+          <elementProp name="export_filter[created_at]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.name">export_filter[created_at]</stringProp>
+            <stringProp name="Argument.value"/>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+          </elementProp>
+          <elementProp name="export_filter[custom_design]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.name">export_filter[custom_design]</stringProp>
+            <stringProp name="Argument.value"/>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+          </elementProp>
+          <elementProp name="export_filter[custom_design_from][]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.name">export_filter[custom_design_from][]</stringProp>
+            <stringProp name="Argument.value">,</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+          </elementProp>
+          <elementProp name="export_filter[custom_design_to][]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.name">export_filter[custom_design_to][]</stringProp>
+            <stringProp name="Argument.value">,</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+          </elementProp>
+          <elementProp name="export_filter[custom_layout_update]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.name">export_filter[custom_layout_update]</stringProp>
+            <stringProp name="Argument.value"/>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+          </elementProp>
+          <elementProp name="export_filter[description]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.name">export_filter[description]</stringProp>
+            <stringProp name="Argument.value"/>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+          </elementProp>
+          <elementProp name="export_filter[email_template]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.name">export_filter[email_template]</stringProp>
+            <stringProp name="Argument.value"/>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+          </elementProp>
+          <elementProp name="export_filter[gallery]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.name">export_filter[gallery]</stringProp>
+            <stringProp name="Argument.value"/>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+          </elementProp>
+          <elementProp name="export_filter[gift_message_available]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.name">export_filter[gift_message_available]</stringProp>
+            <stringProp name="Argument.value"/>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+          </elementProp>
+          <elementProp name="export_filter[gift_wrapping_available]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.name">export_filter[gift_wrapping_available]</stringProp>
+            <stringProp name="Argument.value"/>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+          </elementProp>
+          <elementProp name="export_filter[gift_wrapping_price][]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.name">export_filter[gift_wrapping_price][]</stringProp>
+            <stringProp name="Argument.value">,</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+          </elementProp>
+          <elementProp name="export_filter[group_price][]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.name">export_filter[group_price][]</stringProp>
+            <stringProp name="Argument.value">,</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+          </elementProp>
+          <elementProp name="export_filter[has_options]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.name">export_filter[has_options]</stringProp>
+            <stringProp name="Argument.value"/>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+          </elementProp>
+          <elementProp name="export_filter[image]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.name">export_filter[image]</stringProp>
+            <stringProp name="Argument.value"/>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+          </elementProp>
+          <elementProp name="export_filter[image_label]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.name">export_filter[image_label]</stringProp>
+            <stringProp name="Argument.value"/>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+          </elementProp>
+          <elementProp name="export_filter[is_redeemable][]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.name">export_filter[is_redeemable][]</stringProp>
+            <stringProp name="Argument.value">,</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+          </elementProp>
+          <elementProp name="export_filter[is_returnable]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.name">export_filter[is_returnable]</stringProp>
+            <stringProp name="Argument.value"/>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+          </elementProp>
+          <elementProp name="export_filter[lifetime][]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.name">export_filter[lifetime][]</stringProp>
+            <stringProp name="Argument.value">,</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+          </elementProp>
+          <elementProp name="export_filter[links_exist][]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.name">export_filter[links_exist][]</stringProp>
+            <stringProp name="Argument.value">,</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+          </elementProp>
+          <elementProp name="export_filter[links_purchased_separately][]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.name">export_filter[links_purchased_separately][]</stringProp>
+            <stringProp name="Argument.value">,</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+          </elementProp>
+          <elementProp name="export_filter[links_title]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.name">export_filter[links_title]</stringProp>
+            <stringProp name="Argument.value"/>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+          </elementProp>
+          <elementProp name="export_filter[media_gallery]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.name">export_filter[media_gallery]</stringProp>
+            <stringProp name="Argument.value"/>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+          </elementProp>
+          <elementProp name="export_filter[meta_description]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.name">export_filter[meta_description]</stringProp>
+            <stringProp name="Argument.value"/>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+          </elementProp>
+          <elementProp name="export_filter[meta_keyword]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.name">export_filter[meta_keyword]</stringProp>
+            <stringProp name="Argument.value"/>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+          </elementProp>
+          <elementProp name="export_filter[meta_title]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.name">export_filter[meta_title]</stringProp>
+            <stringProp name="Argument.value"/>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+          </elementProp>
+          <elementProp name="export_filter[minimal_price][]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.name">export_filter[minimal_price][]</stringProp>
+            <stringProp name="Argument.value">,</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+          </elementProp>
+          <elementProp name="export_filter[msrp][]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.name">export_filter[msrp][]</stringProp>
+            <stringProp name="Argument.value">,</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+          </elementProp>
+          <elementProp name="export_filter[msrp_display_actual_price_type]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.name">export_filter[msrp_display_actual_price_type]</stringProp>
+            <stringProp name="Argument.value"/>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+          </elementProp>
+          <elementProp name="export_filter[name]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.name">export_filter[name]</stringProp>
+            <stringProp name="Argument.value"/>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+          </elementProp>
+          <elementProp name="export_filter[news_from_date][]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.name">export_filter[news_from_date][]</stringProp>
+            <stringProp name="Argument.value">,</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+          </elementProp>
+          <elementProp name="export_filter[news_to_date][]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.name">export_filter[news_to_date][]</stringProp>
+            <stringProp name="Argument.value">,</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+          </elementProp>
+          <elementProp name="export_filter[old_id][]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.name">export_filter[old_id][]</stringProp>
+            <stringProp name="Argument.value">,</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+          </elementProp>
+          <elementProp name="export_filter[open_amount_max][]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.name">export_filter[open_amount_max][]</stringProp>
+            <stringProp name="Argument.value">,</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+          </elementProp>
+          <elementProp name="export_filter[open_amount_min][]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.name">export_filter[open_amount_min][]</stringProp>
+            <stringProp name="Argument.value">,</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+          </elementProp>
+          <elementProp name="export_filter[options_container]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.name">export_filter[options_container]</stringProp>
+            <stringProp name="Argument.value"/>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+          </elementProp>
+          <elementProp name="export_filter[page_layout]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.name">export_filter[page_layout]</stringProp>
+            <stringProp name="Argument.value"/>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+          </elementProp>
+          <elementProp name="export_filter[price][]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.name">export_filter[price][]</stringProp>
+            <stringProp name="Argument.value">,</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+          </elementProp>
+          <elementProp name="export_filter[price_type][]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.name">export_filter[price_type][]</stringProp>
+            <stringProp name="Argument.value">,</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+          </elementProp>
+          <elementProp name="export_filter[price_view]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.name">export_filter[price_view]</stringProp>
+            <stringProp name="Argument.value"/>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+          </elementProp>
+          <elementProp name="export_filter[quantity_and_stock_status]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.name">export_filter[quantity_and_stock_status]</stringProp>
+            <stringProp name="Argument.value"/>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+          </elementProp>
+          <elementProp name="export_filter[related_tgtr_position_behavior][]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.name">export_filter[related_tgtr_position_behavior][]</stringProp>
+            <stringProp name="Argument.value">,</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+          </elementProp>
+          <elementProp name="export_filter[related_tgtr_position_limit][]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.name">export_filter[related_tgtr_position_limit][]</stringProp>
+            <stringProp name="Argument.value">,</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+          </elementProp>
+          <elementProp name="export_filter[required_options]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.name">export_filter[required_options]</stringProp>
+            <stringProp name="Argument.value"/>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+          </elementProp>
+          <elementProp name="export_filter[samples_title]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.name">export_filter[samples_title]</stringProp>
+            <stringProp name="Argument.value"/>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+          </elementProp>
+          <elementProp name="export_filter[shipment_type][]" elementType="HTTPArgument">
             <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">20</stringProp>
+            <stringProp name="Argument.name">export_filter[shipment_type][]</stringProp>
+            <stringProp name="Argument.value">,</stringProp>
             <stringProp name="Argument.metadata">=</stringProp>
             <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">searchCriteria[page_size]</stringProp>
-            <stringProp name="Argument.desc">true</stringProp>
           </elementProp>
-          <elementProp name="searchCriteria[current_page]" elementType="HTTPArgument">
+          <elementProp name="export_filter[short_description]" elementType="HTTPArgument">
             <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">1</stringProp>
+            <stringProp name="Argument.name">export_filter[short_description]</stringProp>
+            <stringProp name="Argument.value"/>
             <stringProp name="Argument.metadata">=</stringProp>
             <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">searchCriteria[current_page]</stringProp>
-            <stringProp name="Argument.desc">true</stringProp>
           </elementProp>
-        </collectionProp>
-      </elementProp>
-      <stringProp name="HTTPSampler.domain"/>
-      <stringProp name="HTTPSampler.port"/>
-      <stringProp name="HTTPSampler.connect_timeout"/>
-      <stringProp name="HTTPSampler.response_timeout"/>
-      <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
-      <stringProp name="HTTPSampler.contentEncoding"/>
-      <stringProp name="HTTPSampler.path">${base_path}rest/default/V1/products</stringProp>
-      <stringProp name="HTTPSampler.method">GET</stringProp>
-      <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
-      <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
-      <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
-      <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
-      <boolProp name="HTTPSampler.monitor">false</boolProp>
-      <stringProp name="HTTPSampler.embedded_url_re"/>
-    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/api/get_products.jmx</stringProp></HTTPSamplerProxy>
-    <hashTree>
-      <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert results are present" enabled="true">
-        <collectionProp name="Asserion.test_strings">
-          <stringProp name="-1294635157">errors</stringProp>
-        </collectionProp>
-        <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
-        <boolProp name="Assertion.assume_success">false</boolProp>
-        <intProp name="Assertion.test_type">6</intProp>
-        <stringProp name="Assertion.scope">variable</stringProp>
-        <stringProp name="Scope.variable"/>
-      </ResponseAssertion>
-      <hashTree/>
-    </hashTree>
-  </hashTree>
-
-  
-    <ThroughputController guiclass="ThroughputControllerGui" testclass="ThroughputController" testname="API Search" enabled="true">
-      <intProp name="ThroughputController.style">1</intProp>
-      <boolProp name="ThroughputController.perThread">false</boolProp>
-      <intProp name="ThroughputController.maxThroughput">1</intProp>
-      <stringProp name="ThroughputController.percentThroughput">100</stringProp>
-    <stringProp name="TestPlan.comments">mpaf/tool/fragments/_system/scenario_controller_tmpl.jmx</stringProp></ThroughputController>
-    <hashTree>
-        <JSR223PreProcessor guiclass="TestBeanGUI" testclass="JSR223PreProcessor" testname="Set Test Label" enabled="true">
-            <stringProp name="script">
-var testLabel = "${testLabel}" ? " (${testLabel})" : "";
-if (testLabel
-    &amp;&amp; sampler.getClass().getName() == 'org.apache.jmeter.protocol.http.sampler.HTTPSamplerProxy'
-) {
-    if (sampler.getName().indexOf(testLabel) == -1) {
-       sampler.setName(sampler.getName() + testLabel);
-    }
-} else if (sampler.getName().indexOf("SetUp - ") == -1) {
-    sampler.setName("SetUp - " + sampler.getName());
-}
-            </stringProp>
-            <stringProp name="scriptLanguage">javascript</stringProp>
-        <stringProp name="TestPlan.comments">mpaf/tool/fragments/_system/setup_label.jmx</stringProp></JSR223PreProcessor>
-        <hashTree/>
-        <BeanShellSampler guiclass="BeanShellSamplerGui" testclass="BeanShellSampler" testname="SetUp - Set Label" enabled="true">
-            <stringProp name="BeanShellSampler.query">
-                vars.put("testLabel", "API Search");
-            </stringProp>
-            <boolProp name="BeanShellSampler.resetInterpreter">true</boolProp>
-        </BeanShellSampler>
-        <hashTree/>
-    
-    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Search for simple product on frontend" enabled="true">
-      <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
-        <collectionProp name="Arguments.arguments">
-          <elementProp name="searchCriteria[request_name]" elementType="HTTPArgument">
+          <elementProp name="export_filter[sku]" elementType="HTTPArgument">
             <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">quick_search_container</stringProp>
+            <stringProp name="Argument.name">export_filter[sku]</stringProp>
+            <stringProp name="Argument.value"/>
             <stringProp name="Argument.metadata">=</stringProp>
             <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">searchCriteria[request_name]</stringProp>
           </elementProp>
-          <elementProp name="searchCriteria[filter_groups][0][filters][0][field]" elementType="HTTPArgument">
+          <elementProp name="export_filter[sku_type][]" elementType="HTTPArgument">
             <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">search_term</stringProp>
+            <stringProp name="Argument.name">export_filter[sku_type][]</stringProp>
+            <stringProp name="Argument.value">,</stringProp>
             <stringProp name="Argument.metadata">=</stringProp>
             <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">searchCriteria[filter_groups][0][filters][0][field]</stringProp>
           </elementProp>
-          <elementProp name="searchCriteria[filter_groups][0][filters][0][value]" elementType="HTTPArgument">
+          <elementProp name="export_filter[small_image]" elementType="HTTPArgument">
             <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">Simple</stringProp>
+            <stringProp name="Argument.name">export_filter[small_image]</stringProp>
+            <stringProp name="Argument.value"/>
             <stringProp name="Argument.metadata">=</stringProp>
             <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">searchCriteria[filter_groups][0][filters][0][value]</stringProp>
           </elementProp>
-          <elementProp name="searchCriteria[page_size]" elementType="HTTPArgument">
+          <elementProp name="export_filter[small_image_label]" elementType="HTTPArgument">
             <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">20</stringProp>
+            <stringProp name="Argument.name">export_filter[small_image_label]</stringProp>
+            <stringProp name="Argument.value"/>
             <stringProp name="Argument.metadata">=</stringProp>
             <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">searchCriteria[page_size]</stringProp>
           </elementProp>
-          <elementProp name="searchCriteria[current_page]" elementType="HTTPArgument">
+          <elementProp name="export_filter[special_from_date][]" elementType="HTTPArgument">
             <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">1</stringProp>
+            <stringProp name="Argument.name">export_filter[special_from_date][]</stringProp>
+            <stringProp name="Argument.value">,</stringProp>
             <stringProp name="Argument.metadata">=</stringProp>
             <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">searchCriteria[current_page]</stringProp>
           </elementProp>
-        </collectionProp>
-      </elementProp>
-      <stringProp name="HTTPSampler.domain"/>
-      <stringProp name="HTTPSampler.port"/>
-      <stringProp name="HTTPSampler.connect_timeout"/>
-      <stringProp name="HTTPSampler.response_timeout"/>
-      <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
-      <stringProp name="HTTPSampler.contentEncoding"/>
-      <stringProp name="HTTPSampler.path">${base_path}rest/default/V1/search</stringProp>
-      <stringProp name="HTTPSampler.method">GET</stringProp>
-      <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
-      <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
-      <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
-      <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
-      <boolProp name="HTTPSampler.monitor">false</boolProp>
-      <stringProp name="HTTPSampler.embedded_url_re"/>
-    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/api/search_for_product_frontend.jmx</stringProp></HTTPSamplerProxy>
-    <hashTree>
-      <com.atlantbh.jmeter.plugins.jsonutils.jsonpathassertion.JSONPathAssertion guiclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathassertion.gui.JSONPathAssertionGui" testclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathassertion.JSONPathAssertion" testname="Assert results are present" enabled="true">
-        <stringProp name="JSON_PATH">$.total_count</stringProp>
-        <stringProp name="EXPECTED_VALUE">0</stringProp>
-        <boolProp name="JSONVALIDATION">true</boolProp>
-        <boolProp name="EXPECT_NULL">false</boolProp>
-        <boolProp name="INVERT">true</boolProp>
-      </com.atlantbh.jmeter.plugins.jsonutils.jsonpathassertion.JSONPathAssertion>
-      <hashTree/>
-      <com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor guiclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.gui.JSONPathExtractorGui" testclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor" testname="Extract search product id" enabled="true">
-        <stringProp name="VAR">search_product_id</stringProp>
-        <stringProp name="JSONPATH">$.items[0].id</stringProp>
-        <stringProp name="DEFAULT"/>
-        <stringProp name="VARIABLE"/>
-        <stringProp name="SUBJECT">BODY</stringProp>
-      </com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor>
-      <hashTree/>
-      <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert search product id is not null" enabled="true">
-        <collectionProp name="Asserion.test_strings">
-          <stringProp name="89649215">^\d+$</stringProp>
-        </collectionProp>
-        <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
-        <boolProp name="Assertion.assume_success">false</boolProp>
-        <intProp name="Assertion.test_type">1</intProp>
-        <stringProp name="Assertion.scope">variable</stringProp>
-        <stringProp name="Scope.variable">search_product_id</stringProp>
-      </ResponseAssertion>
-      <hashTree/>
-    </hashTree>
-  </hashTree>
-
-  
-    <ThroughputController guiclass="ThroughputControllerGui" testclass="ThroughputController" testname="API Checkout" enabled="true">
-      <intProp name="ThroughputController.style">1</intProp>
-      <boolProp name="ThroughputController.perThread">false</boolProp>
-      <intProp name="ThroughputController.maxThroughput">1</intProp>
-      <stringProp name="ThroughputController.percentThroughput">100</stringProp>
-    <stringProp name="TestPlan.comments">mpaf/tool/fragments/_system/scenario_controller_tmpl.jmx</stringProp></ThroughputController>
-    <hashTree>
-        <JSR223PreProcessor guiclass="TestBeanGUI" testclass="JSR223PreProcessor" testname="Set Test Label" enabled="true">
-            <stringProp name="script">
-var testLabel = "${testLabel}" ? " (${testLabel})" : "";
-if (testLabel
-    &amp;&amp; sampler.getClass().getName() == 'org.apache.jmeter.protocol.http.sampler.HTTPSamplerProxy'
-) {
-    if (sampler.getName().indexOf(testLabel) == -1) {
-       sampler.setName(sampler.getName() + testLabel);
-    }
-} else if (sampler.getName().indexOf("SetUp - ") == -1) {
-    sampler.setName("SetUp - " + sampler.getName());
-}
-            </stringProp>
-            <stringProp name="scriptLanguage">javascript</stringProp>
-        <stringProp name="TestPlan.comments">mpaf/tool/fragments/_system/setup_label.jmx</stringProp></JSR223PreProcessor>
-        <hashTree/>
-        <BeanShellSampler guiclass="BeanShellSamplerGui" testclass="BeanShellSampler" testname="SetUp - Set Label" enabled="true">
-            <stringProp name="BeanShellSampler.query">
-                vars.put("testLabel", "API Checkout");
-            </stringProp>
-            <boolProp name="BeanShellSampler.resetInterpreter">true</boolProp>
-        </BeanShellSampler>
-        <hashTree/>
-    
-    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Create quote" enabled="true">
-      <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
-        <collectionProp name="Arguments.arguments"/>
-      </elementProp>
-      <stringProp name="HTTPSampler.domain"/>
-      <stringProp name="HTTPSampler.port"/>
-      <stringProp name="HTTPSampler.connect_timeout"/>
-      <stringProp name="HTTPSampler.response_timeout"/>
-      <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
-      <stringProp name="HTTPSampler.contentEncoding"/>
-      <stringProp name="HTTPSampler.path">${base_path}rest/default/V1/carts</stringProp>
-      <stringProp name="HTTPSampler.method">POST</stringProp>
-      <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
-      <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
-      <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
-      <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
-      <boolProp name="HTTPSampler.monitor">false</boolProp>
-      <stringProp name="HTTPSampler.embedded_url_re"/>
-    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/api/create_quote.jmx</stringProp></HTTPSamplerProxy>
-    <hashTree>
-      <com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor guiclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.gui.JSONPathExtractorGui" testclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor" testname="Extract cart id" enabled="true">
-        <stringProp name="VAR">quote_id</stringProp>
-        <stringProp name="JSONPATH">$</stringProp>
-        <stringProp name="DEFAULT"/>
-        <stringProp name="VARIABLE"/>
-        <stringProp name="SUBJECT">BODY</stringProp>
-      </com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor>
-      <hashTree/>
-      <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Response Assertion" enabled="true">
-        <collectionProp name="Asserion.test_strings">
-          <stringProp name="89649215">^\d+$</stringProp>
-        </collectionProp>
-        <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
-        <boolProp name="Assertion.assume_success">false</boolProp>
-        <intProp name="Assertion.test_type">1</intProp>
-        <stringProp name="Assertion.scope">variable</stringProp>
-        <stringProp name="Scope.variable">quote_id</stringProp>
-      </ResponseAssertion>
-      <hashTree/>
-    </hashTree>
-  
-    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Add product to quote" enabled="true">
-      <boolProp name="HTTPSampler.postBodyRaw">true</boolProp>
-      <elementProp name="HTTPsampler.Arguments" elementType="Arguments">
-        <collectionProp name="Arguments.arguments">
-          <elementProp name="" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">false</boolProp>
-            <stringProp name="Argument.value">{&#xD;
-	"cartItem": {&#xD;
-		"sku": "product_dynamic_${search_product_id}",&#xD;
-		"qty":"1",&#xD;
-		"quote_id":"${quote_id}"&#xD;
-	}&#xD;
-}&#xD;
-</stringProp>
+          <elementProp name="export_filter[special_price][]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.name">export_filter[special_price][]</stringProp>
+            <stringProp name="Argument.value">,</stringProp>
             <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
           </elementProp>
-        </collectionProp>
-      </elementProp>
-      <stringProp name="HTTPSampler.domain"/>
-      <stringProp name="HTTPSampler.port"/>
-      <stringProp name="HTTPSampler.connect_timeout"/>
-      <stringProp name="HTTPSampler.response_timeout"/>
-      <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
-      <stringProp name="HTTPSampler.contentEncoding"/>
-      <stringProp name="HTTPSampler.path">${base_path}rest/default/V1/carts/${quote_id}/items</stringProp>
-      <stringProp name="HTTPSampler.method">POST</stringProp>
-      <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
-      <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
-      <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
-      <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
-      <boolProp name="HTTPSampler.monitor">false</boolProp>
-      <stringProp name="HTTPSampler.embedded_url_re"/>
-      <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/api/add_product_to_quote_hardwired_sku.jmx</stringProp>
-    </HTTPSamplerProxy>
-    <hashTree>
-      <com.atlantbh.jmeter.plugins.jsonutils.jsonpathassertion.JSONPathAssertion guiclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathassertion.gui.JSONPathAssertionGui" testclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathassertion.JSONPathAssertion" testname="jp@gc - JSON Path Assertion" enabled="true">
-        <stringProp name="JSON_PATH">$.sku</stringProp>
-        <stringProp name="EXPECTED_VALUE">product_dynamic_${search_product_id}</stringProp>
-        <boolProp name="JSONVALIDATION">true</boolProp>
-        <boolProp name="EXPECT_NULL">false</boolProp>
-        <boolProp name="INVERT">false</boolProp>
-      </com.atlantbh.jmeter.plugins.jsonutils.jsonpathassertion.JSONPathAssertion>
-      <hashTree/>
-    </hashTree>
-  
-    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Check products in quote" enabled="true">
-      <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
-        <collectionProp name="Arguments.arguments"/>
-      </elementProp>
-      <stringProp name="HTTPSampler.domain"/>
-      <stringProp name="HTTPSampler.port"/>
-      <stringProp name="HTTPSampler.connect_timeout"/>
-      <stringProp name="HTTPSampler.response_timeout"/>
-      <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
-      <stringProp name="HTTPSampler.contentEncoding"/>
-      <stringProp name="HTTPSampler.path">${base_path}rest/default/V1/carts/${quote_id}/items</stringProp>
-      <stringProp name="HTTPSampler.method">GET</stringProp>
-      <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
-      <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
-      <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
-      <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
-      <boolProp name="HTTPSampler.monitor">false</boolProp>
-      <stringProp name="HTTPSampler.embedded_url_re"/>
-    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/api/check_product_in_quote_hardwired_sku.jmx</stringProp></HTTPSamplerProxy>
-    <hashTree>
-      <com.atlantbh.jmeter.plugins.jsonutils.jsonpathassertion.JSONPathAssertion guiclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathassertion.gui.JSONPathAssertionGui" testclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathassertion.JSONPathAssertion" testname="jp@gc - JSON Path Assertion" enabled="true">
-        <stringProp name="JSON_PATH">$[0].sku</stringProp>
-        <stringProp name="EXPECTED_VALUE">product_dynamic_${search_product_id}</stringProp>
-        <boolProp name="JSONVALIDATION">true</boolProp>
-        <boolProp name="EXPECT_NULL">false</boolProp>
-        <boolProp name="INVERT">false</boolProp>
-      </com.atlantbh.jmeter.plugins.jsonutils.jsonpathassertion.JSONPathAssertion>
-      <hashTree/>
-    </hashTree>
-  
-    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Create Guest Cart" enabled="true">
-      <boolProp name="HTTPSampler.postBodyRaw">true</boolProp>
-      <elementProp name="HTTPsampler.Arguments" elementType="Arguments">
-        <collectionProp name="Arguments.arguments">
-          <elementProp name="" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">false</boolProp>
-            <stringProp name="Argument.value">{&#xD;
-    "storeId": 1&#xD;
-}</stringProp>
+          <elementProp name="export_filter[special_to_date][]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.name">export_filter[special_to_date][]</stringProp>
+            <stringProp name="Argument.value">,</stringProp>
             <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
           </elementProp>
-        </collectionProp>
-      </elementProp>
-      <stringProp name="HTTPSampler.domain"/>
-      <stringProp name="HTTPSampler.port"/>
-      <stringProp name="HTTPSampler.connect_timeout"/>
-      <stringProp name="HTTPSampler.response_timeout"/>
-      <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
-      <stringProp name="HTTPSampler.contentEncoding"/>
-      <stringProp name="HTTPSampler.path">${base_path}rest/default/V1/guest-carts/</stringProp>
-      <stringProp name="HTTPSampler.method">POST</stringProp>
-      <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
-      <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
-      <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
-      <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
-      <boolProp name="HTTPSampler.monitor">false</boolProp>
-      <stringProp name="HTTPSampler.embedded_url_re"/>
-    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/api/create_guest_cart.jmx</stringProp></HTTPSamplerProxy>
-    <hashTree>
-      <com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor guiclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.gui.JSONPathExtractorGui" testclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor" testname="jp@gc - JSON Path Extractor" enabled="true">
-        <stringProp name="VAR">cart_id</stringProp>
-        <stringProp name="JSONPATH">$</stringProp>
-        <stringProp name="DEFAULT"/>
-        <stringProp name="VARIABLE"/>
-        <stringProp name="SUBJECT">BODY</stringProp>
-      </com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor>
-      <hashTree/>
-      <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert Guest Cart Id extracted" enabled="true">
-        <collectionProp name="Asserion.test_strings">
-          <stringProp name="2845929">^.+$</stringProp>
-        </collectionProp>
-        <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
-        <boolProp name="Assertion.assume_success">false</boolProp>
-        <intProp name="Assertion.test_type">1</intProp>
-        <stringProp name="Assertion.scope">variable</stringProp>
-        <stringProp name="Scope.variable">cart_id</stringProp>
-      </ResponseAssertion>
-      <hashTree/>
-    </hashTree>
-  
-    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Add product to Guest Cart" enabled="true">
-      <boolProp name="HTTPSampler.postBodyRaw">true</boolProp>
-      <elementProp name="HTTPsampler.Arguments" elementType="Arguments">
-        <collectionProp name="Arguments.arguments">
-          <elementProp name="" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">false</boolProp>
-            <stringProp name="Argument.value">{&#xD;
-	"cartItem": {&#xD;
-		"sku": "product_dynamic_${search_product_id}",&#xD;
-		"qty":"1",&#xD;
-		"quote_id":"${cart_id}"&#xD;
-	}&#xD;
-}&#xD;
-</stringProp>
+          <elementProp name="export_filter[status]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.name">export_filter[status]</stringProp>
+            <stringProp name="Argument.value"/>
             <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
           </elementProp>
-        </collectionProp>
-      </elementProp>
-      <stringProp name="HTTPSampler.domain"/>
-      <stringProp name="HTTPSampler.port"/>
-      <stringProp name="HTTPSampler.connect_timeout"/>
-      <stringProp name="HTTPSampler.response_timeout"/>
-      <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
-      <stringProp name="HTTPSampler.contentEncoding"/>
-      <stringProp name="HTTPSampler.path">${base_path}rest/default/V1/guest-carts/${cart_id}/items</stringProp>
-      <stringProp name="HTTPSampler.method">POST</stringProp>
-      <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
-      <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
-      <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
-      <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
-      <boolProp name="HTTPSampler.monitor">false</boolProp>
-      <stringProp name="HTTPSampler.embedded_url_re"/>
-    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/api/add_product_to_guest_cart_hardwired_sku.jmx</stringProp></HTTPSamplerProxy>
-    <hashTree>
-      <com.atlantbh.jmeter.plugins.jsonutils.jsonpathassertion.JSONPathAssertion guiclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathassertion.gui.JSONPathAssertionGui" testclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathassertion.JSONPathAssertion" testname="jp@gc - JSON Path Assertion" enabled="true">
-        <stringProp name="JSON_PATH">$.quote_id</stringProp>
-        <stringProp name="EXPECTED_VALUE">^[a-z0-9-]+$</stringProp>
-        <boolProp name="JSONVALIDATION">true</boolProp>
-        <boolProp name="EXPECT_NULL">false</boolProp>
-        <boolProp name="INVERT">false</boolProp>
-      </com.atlantbh.jmeter.plugins.jsonutils.jsonpathassertion.JSONPathAssertion>
-      <hashTree/>
-    </hashTree>
-  
-    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Add Gift Message to Guest Cart" enabled="true">
-      <boolProp name="HTTPSampler.postBodyRaw">true</boolProp>
-      <elementProp name="HTTPsampler.Arguments" elementType="Arguments">
-        <collectionProp name="Arguments.arguments">
-          <elementProp name="" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">false</boolProp>
-            <stringProp name="Argument.value">{&#xD;
-	"sender": "John Doe",&#xD;
-	"recipient": "Jane Roe",&#xD;
-	"giftMessage": "Gift Message Text"&#xD;
-}&#xD;
-</stringProp>
+          <elementProp name="export_filter[tax_class_id]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.name">export_filter[tax_class_id]</stringProp>
+            <stringProp name="Argument.value"/>
             <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
           </elementProp>
-        </collectionProp>
-      </elementProp>
-      <stringProp name="HTTPSampler.domain"/>
-      <stringProp name="HTTPSampler.port"/>
-      <stringProp name="HTTPSampler.connect_timeout"/>
-      <stringProp name="HTTPSampler.response_timeout"/>
-      <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
-      <stringProp name="HTTPSampler.contentEncoding"/>
-      <stringProp name="HTTPSampler.path">${base_path}rest/default/V1/guest-carts/${cart_id}/gift-message</stringProp>
-      <stringProp name="HTTPSampler.method">POST</stringProp>
-      <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
-      <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
-      <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
-      <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
-      <boolProp name="HTTPSampler.monitor">false</boolProp>
-      <stringProp name="HTTPSampler.embedded_url_re"/>
-    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/api/add_gift_message_to_guest_cart.jmx</stringProp></HTTPSamplerProxy>
-    <hashTree>
-      <com.atlantbh.jmeter.plugins.jsonutils.jsonpathassertion.JSONPathAssertion guiclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathassertion.gui.JSONPathAssertionGui" testclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathassertion.JSONPathAssertion" testname="jp@gc - JSON Path Assertion" enabled="true">
-        <stringProp name="JSON_PATH">$</stringProp>
-        <stringProp name="EXPECTED_VALUE">true</stringProp>
-        <boolProp name="JSONVALIDATION">true</boolProp>
-        <boolProp name="EXPECT_NULL">false</boolProp>
-        <boolProp name="INVERT">false</boolProp>
-      </com.atlantbh.jmeter.plugins.jsonutils.jsonpathassertion.JSONPathAssertion>
-      <hashTree/>
-    </hashTree>
-  
-    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Checkout Estimate Shipping Methods" enabled="true">
-      <boolProp name="HTTPSampler.postBodyRaw">true</boolProp>
-      <elementProp name="HTTPsampler.Arguments" elementType="Arguments">
-        <collectionProp name="Arguments.arguments">
-          <elementProp name="" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">false</boolProp>
-            <stringProp name="Argument.value">{"address":{"country_id":"US","postcode":"95630"}}</stringProp>
+          <elementProp name="export_filter[thumbnail]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.name">export_filter[thumbnail]</stringProp>
+            <stringProp name="Argument.value"/>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+          </elementProp>
+          <elementProp name="export_filter[thumbnail_label]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.name">export_filter[thumbnail_label]</stringProp>
+            <stringProp name="Argument.value"/>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+          </elementProp>
+          <elementProp name="export_filter[tier_price][]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.name">export_filter[tier_price][]</stringProp>
+            <stringProp name="Argument.value">,</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+          </elementProp>
+          <elementProp name="export_filter[updated_at]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.name">export_filter[updated_at]</stringProp>
+            <stringProp name="Argument.value"/>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+          </elementProp>
+          <elementProp name="export_filter[upsell_tgtr_position_behavior][]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.name">export_filter[upsell_tgtr_position_behavior][]</stringProp>
+            <stringProp name="Argument.value">,</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+          </elementProp>
+          <elementProp name="export_filter[upsell_tgtr_position_limit][]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.name">export_filter[upsell_tgtr_position_limit][]</stringProp>
+            <stringProp name="Argument.value">,</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+          </elementProp>
+          <elementProp name="export_filter[url_key]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.name">export_filter[url_key]</stringProp>
+            <stringProp name="Argument.value"/>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+          </elementProp>
+          <elementProp name="export_filter[url_path]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.name">export_filter[url_path]</stringProp>
+            <stringProp name="Argument.value"/>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+          </elementProp>
+          <elementProp name="export_filter[use_config_allow_message][]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.name">export_filter[use_config_allow_message][]</stringProp>
+            <stringProp name="Argument.value">,</stringProp>
             <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
           </elementProp>
-        </collectionProp>
-      </elementProp>
-      <stringProp name="HTTPSampler.domain"/>
-      <stringProp name="HTTPSampler.port"/>
-      <stringProp name="HTTPSampler.connect_timeout"/>
-      <stringProp name="HTTPSampler.response_timeout"/>
-      <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
-      <stringProp name="HTTPSampler.contentEncoding"/>
-      <stringProp name="HTTPSampler.path">${base_path}rest/default/V1/guest-carts/${cart_id}/estimate-shipping-methods</stringProp>
-      <stringProp name="HTTPSampler.method">POST</stringProp>
-      <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
-      <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
-      <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
-      <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
-      <boolProp name="HTTPSampler.monitor">false</boolProp>
-      <stringProp name="HTTPSampler.embedded_url_re"/>
-    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/guest_checkout/checkout_estimate_shipping_methods_with_postal_code.jmx</stringProp></HTTPSamplerProxy>
-    <hashTree>
-      <HeaderManager guiclass="HeaderPanel" testclass="HeaderManager" testname="HTTP Header Manager" enabled="true">
-        <collectionProp name="HeaderManager.headers">
-          <elementProp name="" elementType="Header">
-            <stringProp name="Header.name">Referer</stringProp>
-            <stringProp name="Header.value">${base_path}checkout/onepage/</stringProp>
+          <elementProp name="export_filter[use_config_email_template][]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.name">export_filter[use_config_email_template][]</stringProp>
+            <stringProp name="Argument.value">,</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
           </elementProp>
-          <elementProp name="Content-Type" elementType="Header">
-            <stringProp name="Header.name">Content-Type</stringProp>
-            <stringProp name="Header.value">application/json; charset=UTF-8</stringProp>
+          <elementProp name="export_filter[use_config_is_redeemable][]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.name">export_filter[use_config_is_redeemable][]</stringProp>
+            <stringProp name="Argument.value">,</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
           </elementProp>
-          <elementProp name="X-Requested-With" elementType="Header">
-            <stringProp name="Header.name">X-Requested-With</stringProp>
-            <stringProp name="Header.value">XMLHttpRequest</stringProp>
+          <elementProp name="export_filter[use_config_lifetime][]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.name">export_filter[use_config_lifetime][]</stringProp>
+            <stringProp name="Argument.value">,</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
           </elementProp>
-          <elementProp name="Accept" elementType="Header">
-            <stringProp name="Header.name">Accept</stringProp>
-            <stringProp name="Header.value">application/json</stringProp>
+          <elementProp name="export_filter[visibility]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.name">export_filter[visibility]</stringProp>
+            <stringProp name="Argument.value"/>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
           </elementProp>
-        </collectionProp>
-      </HeaderManager>
-      <hashTree/>
-      <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert success" enabled="true">
-        <collectionProp name="Asserion.test_strings">
-          <stringProp name="-1224567411">"available":true</stringProp>
-        </collectionProp>
-        <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
-        <boolProp name="Assertion.assume_success">false</boolProp>
-        <intProp name="Assertion.test_type">2</intProp>
-      </ResponseAssertion>
-      <hashTree/>
-    </hashTree>
-  
-    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Checkout Billing/Shipping Information" enabled="true">
-      <boolProp name="HTTPSampler.postBodyRaw">true</boolProp>
-      <elementProp name="HTTPsampler.Arguments" elementType="Arguments">
-        <collectionProp name="Arguments.arguments">
-          <elementProp name="" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">false</boolProp>
-            <stringProp name="Argument.value">{"addressInformation":{"shipping_address":{"countryId":"US","regionId":"12","regionCode":"CA","region":"California","street":["10441 Jefferson Blvd ste 200"],"company":"","telephone":"3109450345","fax":"","postcode":"90232","city":"Culver City","firstname":"Name","lastname":"Lastname"},"shipping_method_code":"flatrate","shipping_carrier_code":"flatrate"}}</stringProp>
+          <elementProp name="export_filter[weight][]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.name">export_filter[weight][]</stringProp>
+            <stringProp name="Argument.value">,</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+          </elementProp>
+          <elementProp name="export_filter[weight_type][]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.name">export_filter[weight_type][]</stringProp>
+            <stringProp name="Argument.value">,</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+          </elementProp>
+          <elementProp name="frontend_label" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.name">frontend_label</stringProp>
+            <stringProp name="Argument.value"/>
             <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
           </elementProp>
         </collectionProp>
       </elementProp>
@@ -27551,7 +19043,7 @@ if (testLabel
       <stringProp name="HTTPSampler.response_timeout"/>
       <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
       <stringProp name="HTTPSampler.contentEncoding"/>
-      <stringProp name="HTTPSampler.path">${base_path}rest/default/V1/guest-carts/${cart_id}/shipping-information</stringProp>
+      <stringProp name="HTTPSampler.path">${base_path}${admin_path}/admin/export/export/entity/catalog_product/file_format/csv</stringProp>
       <stringProp name="HTTPSampler.method">POST</stringProp>
       <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
       <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
@@ -27559,50 +19051,23 @@ if (testLabel
       <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
       <boolProp name="HTTPSampler.monitor">false</boolProp>
       <stringProp name="HTTPSampler.embedded_url_re"/>
-    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/guest_checkout/checkout_billing_shipping_information.jmx</stringProp></HTTPSamplerProxy>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/export_products/export_products.jmx</stringProp></HTTPSamplerProxy>
     <hashTree>
-      <HeaderManager guiclass="HeaderPanel" testclass="HeaderManager" testname="HTTP Header Manager" enabled="true">
-        <collectionProp name="HeaderManager.headers">
-          <elementProp name="" elementType="Header">
-            <stringProp name="Header.name">Referer</stringProp>
-            <stringProp name="Header.value">${base_path}checkout/onepage/</stringProp>
-          </elementProp>
-          <elementProp name="Content-Type" elementType="Header">
-            <stringProp name="Header.name">Content-Type</stringProp>
-            <stringProp name="Header.value">application/json; charset=UTF-8</stringProp>
-          </elementProp>
-          <elementProp name="X-Requested-With" elementType="Header">
-            <stringProp name="Header.name">X-Requested-With</stringProp>
-            <stringProp name="Header.value">XMLHttpRequest</stringProp>
-          </elementProp>
-          <elementProp name="Accept" elementType="Header">
-            <stringProp name="Header.name">Accept</stringProp>
-            <stringProp name="Header.value">application/json</stringProp>
-          </elementProp>
-        </collectionProp>
-      </HeaderManager>
-      <hashTree/>
-      <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert success" enabled="true">
+      <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Response Assertion" enabled="true">
         <collectionProp name="Asserion.test_strings">
-          <stringProp name="-1494218646">{"payment_methods":</stringProp>
+          <stringProp name="-261088822">Simple Product 1</stringProp>
         </collectionProp>
         <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
         <boolProp name="Assertion.assume_success">false</boolProp>
-        <intProp name="Assertion.test_type">2</intProp>
+        <intProp name="Assertion.test_type">16</intProp>
       </ResponseAssertion>
       <hashTree/>
     </hashTree>
+  </hashTree>
   
-    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Checkout Payment Info/Place Order" enabled="true">
-      <boolProp name="HTTPSampler.postBodyRaw">true</boolProp>
-      <elementProp name="HTTPsampler.Arguments" elementType="Arguments">
-        <collectionProp name="Arguments.arguments">
-          <elementProp name="" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">false</boolProp>
-            <stringProp name="Argument.value">{"cartId":"${cart_id}","email":"test@example.com","paymentMethod":{"method":"checkmo","po_number":null,"additional_data":null},"billingAddress":{"countryId":"US","regionId":"12","regionCode":"CA","region":"California","street":["10441 Jefferson Blvd ste 200"],"company":"","telephone":"3109450345","fax":"","postcode":"90232","city":"Culver City","firstname":"Name","lastname":"Lastname","save_in_address_book":0}}</stringProp>
-            <stringProp name="Argument.metadata">=</stringProp>
-          </elementProp>
-        </collectionProp>
+    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Logout" enabled="true">
+      <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
+        <collectionProp name="Arguments.arguments"/>
       </elementProp>
       <stringProp name="HTTPSampler.domain"/>
       <stringProp name="HTTPSampler.port"/>
@@ -27610,76 +19075,36 @@ if (testLabel
       <stringProp name="HTTPSampler.response_timeout"/>
       <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
       <stringProp name="HTTPSampler.contentEncoding"/>
-      <stringProp name="HTTPSampler.path">${base_path}rest/default/V1/guest-carts/${cart_id}/payment-information</stringProp>
-      <stringProp name="HTTPSampler.method">POST</stringProp>
+      <stringProp name="HTTPSampler.path">${base_path}${admin_path}/admin/auth/logout/</stringProp>
+      <stringProp name="HTTPSampler.method">GET</stringProp>
       <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
       <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
       <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
       <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
       <boolProp name="HTTPSampler.monitor">false</boolProp>
       <stringProp name="HTTPSampler.embedded_url_re"/>
-    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/api/checkout_payment_info_place_order.jmx</stringProp></HTTPSamplerProxy>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/setup/admin_logout.jmx</stringProp></HTTPSamplerProxy>
     <hashTree>
-      <HeaderManager guiclass="HeaderPanel" testclass="HeaderManager" testname="HTTP Header Manager" enabled="true">
-        <collectionProp name="HeaderManager.headers">
-          <elementProp name="" elementType="Header">
-            <stringProp name="Header.name">Referer</stringProp>
-            <stringProp name="Header.value">${base_path}checkout/onepage/</stringProp>
-          </elementProp>
-          <elementProp name="Content-Type" elementType="Header">
-            <stringProp name="Header.name">Content-Type</stringProp>
-            <stringProp name="Header.value">application/json; charset=UTF-8</stringProp>
-          </elementProp>
-          <elementProp name="X-Requested-With" elementType="Header">
-            <stringProp name="Header.name">X-Requested-With</stringProp>
-            <stringProp name="Header.value">XMLHttpRequest</stringProp>
-          </elementProp>
-          <elementProp name="Accept" elementType="Header">
-            <stringProp name="Header.name">Accept</stringProp>
-            <stringProp name="Header.value">application/json</stringProp>
-          </elementProp>
-        </collectionProp>
-      </HeaderManager>
-      <hashTree/>
-      <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert success" enabled="true">
-        <collectionProp name="Asserion.test_strings">
-          <stringProp name="-297987887">"[0-9]+"</stringProp>
-        </collectionProp>
-        <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
-        <boolProp name="Assertion.assume_success">false</boolProp>
-        <intProp name="Assertion.test_type">2</intProp>
-      </ResponseAssertion>
-      <hashTree/>
-      <com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor guiclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.gui.JSONPathExtractorGui" testclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor" testname="Extract cart id" enabled="true">
-        <stringProp name="VAR">order_id</stringProp>
-        <stringProp name="JSONPATH">$</stringProp>
-        <stringProp name="DEFAULT"/>
-        <stringProp name="VARIABLE"/>
-        <stringProp name="SUBJECT">BODY</stringProp>
-      </com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor>
-      <hashTree/>
-      <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Response Assertion" enabled="true">
-        <collectionProp name="Asserion.test_strings">
-          <stringProp name="89649215">^\d+$</stringProp>
-        </collectionProp>
-        <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
-        <boolProp name="Assertion.assume_success">false</boolProp>
-        <intProp name="Assertion.test_type">1</intProp>
-        <stringProp name="Assertion.scope">variable</stringProp>
-        <stringProp name="Scope.variable">order_id</stringProp>
-      </ResponseAssertion>
-      <hashTree/>
-    </hashTree>
+    
+    <BeanShellPostProcessor guiclass="TestBeanGUI" testclass="BeanShellPostProcessor" testname="Return Admin to Pool" enabled="true">
+        <boolProp name="resetInterpreter">false</boolProp>
+        <stringProp name="parameters"/>
+        <stringProp name="filename"/>
+        <stringProp name="script">
+adminUserList = props.get("adminUserList");
+adminUserList.add(vars.get("admin_user"));
+        </stringProp>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/common/return_admin_email_to_pool.jmx</stringProp></BeanShellPostProcessor>
+    <hashTree/>
   </hashTree>
-
   </hashTree>
 
   
-    <ThroughputController guiclass="ThroughputControllerGui" testclass="ThroughputController" testname="Product Grid Mass Actions" enabled="true">
+    <ThroughputController guiclass="ThroughputControllerGui" testclass="ThroughputController" testname="Export Customers" enabled="true">
       <intProp name="ThroughputController.style">1</intProp>
       <boolProp name="ThroughputController.perThread">false</boolProp>
       <intProp name="ThroughputController.maxThroughput">1</intProp>
-      <stringProp name="ThroughputController.percentThroughput">${productGridMassActionPercentage}</stringProp>
+      <stringProp name="ThroughputController.percentThroughput">${exportCustomersPercentage}</stringProp>
     <stringProp name="TestPlan.comments">mpaf/tool/fragments/_system/scenario_controller_tmpl.jmx</stringProp></ThroughputController>
     <hashTree>
         <JSR223PreProcessor guiclass="TestBeanGUI" testclass="JSR223PreProcessor" testname="Set Test Label" enabled="true">
@@ -27700,7 +19125,7 @@ if (testLabel
         <hashTree/>
         <BeanShellSampler guiclass="BeanShellSamplerGui" testclass="BeanShellSampler" testname="SetUp - Set Label" enabled="true">
             <stringProp name="BeanShellSampler.query">
-                vars.put("testLabel", "Product Grid Mass Actions");
+                vars.put("testLabel", "Export Customers");
             </stringProp>
             <boolProp name="BeanShellSampler.resetInterpreter">true</boolProp>
         </BeanShellSampler>
@@ -27760,10 +19185,36 @@ if (testLabel
     <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/http_cookie_manager_without_clear_each_iteration.jmx</stringProp></CookieManager>
     <hashTree/>
   
-    <OnceOnlyController guiclass="OnceOnlyControllerGui" testclass="OnceOnlyController" testname="Once Only Controller" enabled="true">
-  <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/once_only_controller.jmx</stringProp>
-</OnceOnlyController>
+    <GenericController guiclass="LogicControllerGui" testclass="GenericController" testname="Admin Login" enabled="true">
+  <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/simple_controller.jmx</stringProp>
+</GenericController>
+    <hashTree>
+    <CriticalSectionController guiclass="CriticalSectionControllerGui" testclass="CriticalSectionController" testname="Admin Login Lock" enabled="true">
+        <stringProp name="CriticalSectionController.lockName">get-admin-email</stringProp>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/lock_controller.jmx</stringProp></CriticalSectionController>
     <hashTree>
+    
+    <BeanShellSampler guiclass="BeanShellSamplerGui" testclass="BeanShellSampler" testname="SetUp - Get Admin Email" enabled="true">
+      <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/get_admin_email.jmx</stringProp>
+      <stringProp name="BeanShellSampler.query">
+adminUserList = props.get("adminUserList");
+adminUser = adminUserList.poll();
+if (adminUser == null) {
+  SampleResult.setResponseMessage("adminUser list is empty");
+  SampleResult.setResponseData("adminUser list is empty","UTF-8");
+  IsSuccess=false;
+  SampleResult.setSuccessful(false);
+  SampleResult.setStopThread(true);
+}
+vars.put("admin_user", adminUser);
+      </stringProp>
+      <stringProp name="BeanShellSampler.filename"/>
+      <stringProp name="BeanShellSampler.parameters"/>
+      <boolProp name="BeanShellSampler.resetInterpreter">true</boolProp>
+    </BeanShellSampler>
+    <hashTree/>
+  </hashTree>
+  
     <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="SetUp - Login" enabled="true">
       <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
         <collectionProp name="Arguments.arguments"/>
@@ -27877,8 +19328,44 @@ if (testLabel
         <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_login/admin_retrieve_form_key.jmx</stringProp></RegexExtractor>
         <hashTree/>
     </hashTree>
+  </hashTree>
   
-    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Get Product Pages Count" enabled="true">
+    <GenericController guiclass="LogicControllerGui" testclass="GenericController" testname="Simple Controller" enabled="true">
+  <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/simple_controller.jmx</stringProp>
+</GenericController>
+    <hashTree>
+    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Export Page" enabled="true">
+      <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
+        <collectionProp name="Arguments.arguments"/>
+      </elementProp>
+      <stringProp name="HTTPSampler.domain"/>
+      <stringProp name="HTTPSampler.port"/>
+      <stringProp name="HTTPSampler.connect_timeout"/>
+      <stringProp name="HTTPSampler.response_timeout"/>
+      <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
+      <stringProp name="HTTPSampler.contentEncoding"/>
+      <stringProp name="HTTPSampler.path">${base_path}${admin_path}/admin/export/</stringProp>
+      <stringProp name="HTTPSampler.method">GET</stringProp>
+      <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
+      <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
+      <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
+      <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
+      <boolProp name="HTTPSampler.monitor">false</boolProp>
+      <stringProp name="HTTPSampler.embedded_url_re"/>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/common/export.jmx</stringProp></HTTPSamplerProxy>
+    <hashTree>
+      <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert success" enabled="true">
+        <collectionProp name="Asserion.test_strings">
+          <stringProp name="1723813687">Export Settings</stringProp>
+        </collectionProp>
+        <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
+        <boolProp name="Assertion.assume_success">false</boolProp>
+        <intProp name="Assertion.test_type">2</intProp>
+      </ResponseAssertion>
+      <hashTree/>
+    </hashTree>
+  
+    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Export Customers" enabled="true">
       <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
         <collectionProp name="Arguments.arguments">
           <elementProp name="form_key" elementType="HTTPArgument">
@@ -27887,238 +19374,206 @@ if (testLabel
             <stringProp name="Argument.metadata">=</stringProp>
             <boolProp name="HTTPArgument.use_equals">true</boolProp>
             <stringProp name="Argument.name">form_key</stringProp>
+            <stringProp name="Argument.desc">false</stringProp>
           </elementProp>
-          <elementProp name="namespace" elementType="HTTPArgument">
+          <elementProp name="attribute_code" elementType="HTTPArgument">
             <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">product_listing</stringProp>
+            <stringProp name="Argument.value"/>
             <stringProp name="Argument.metadata">=</stringProp>
             <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">namespace</stringProp>
+            <stringProp name="Argument.name">attribute_code</stringProp>
             <stringProp name="Argument.desc">true</stringProp>
           </elementProp>
-          <elementProp name="search" elementType="HTTPArgument">
+          <elementProp name="export_filter[confirmation]" elementType="HTTPArgument">
             <boolProp name="HTTPArgument.always_encode">true</boolProp>
             <stringProp name="Argument.value"/>
             <stringProp name="Argument.metadata">=</stringProp>
             <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">search</stringProp>
+            <stringProp name="Argument.name">export_filter[confirmation]</stringProp>
             <stringProp name="Argument.desc">true</stringProp>
           </elementProp>
-          <elementProp name="filters[placeholder]" elementType="HTTPArgument">
+          <elementProp name="export_filter[created_at]" elementType="HTTPArgument">
             <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">true</stringProp>
+            <stringProp name="Argument.value"/>
             <stringProp name="Argument.metadata">=</stringProp>
             <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">filters[placeholder]</stringProp>
+            <stringProp name="Argument.name">export_filter[created_at]</stringProp>
             <stringProp name="Argument.desc">true</stringProp>
           </elementProp>
-          <elementProp name="paging[pageSize]" elementType="HTTPArgument">
+          <elementProp name="export_filter[created_in]" elementType="HTTPArgument">
             <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">20</stringProp>
+            <stringProp name="Argument.value"/>
             <stringProp name="Argument.metadata">=</stringProp>
             <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">paging[pageSize]</stringProp>
+            <stringProp name="Argument.name">export_filter[created_in]</stringProp>
             <stringProp name="Argument.desc">true</stringProp>
           </elementProp>
-          <elementProp name="paging[current]" elementType="HTTPArgument">
+          <elementProp name="export_filter[default_billing][]" elementType="HTTPArgument">
             <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">1</stringProp>
+            <stringProp name="Argument.value">,</stringProp>
             <stringProp name="Argument.metadata">=</stringProp>
             <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">paging[current]</stringProp>
+            <stringProp name="Argument.name">export_filter[default_billing][]</stringProp>
             <stringProp name="Argument.desc">true</stringProp>
           </elementProp>
-          <elementProp name="sorting[field]" elementType="HTTPArgument">
+          <elementProp name="export_filter[default_shipping][]" elementType="HTTPArgument">
             <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">entity_id</stringProp>
+            <stringProp name="Argument.value">,</stringProp>
             <stringProp name="Argument.metadata">=</stringProp>
             <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">sorting[field]</stringProp>
+            <stringProp name="Argument.name">export_filter[default_shipping][]</stringProp>
             <stringProp name="Argument.desc">true</stringProp>
           </elementProp>
-          <elementProp name="sorting[direction]" elementType="HTTPArgument">
+          <elementProp name="export_filter[disable_auto_group_change]" elementType="HTTPArgument">
             <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">asc</stringProp>
+            <stringProp name="Argument.value"/>
             <stringProp name="Argument.metadata">=</stringProp>
             <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">sorting[direction]</stringProp>
+            <stringProp name="Argument.name">export_filter[disable_auto_group_change]</stringProp>
             <stringProp name="Argument.desc">true</stringProp>
           </elementProp>
-          <elementProp name="isAjax" elementType="HTTPArgument">
+          <elementProp name="export_filter[dob][]" elementType="HTTPArgument">
             <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">true</stringProp>
+            <stringProp name="Argument.value">,</stringProp>
             <stringProp name="Argument.metadata">=</stringProp>
             <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">isAjax</stringProp>
+            <stringProp name="Argument.name">export_filter[dob][]</stringProp>
             <stringProp name="Argument.desc">true</stringProp>
           </elementProp>
-        </collectionProp>
-      </elementProp>
-      <stringProp name="HTTPSampler.domain"/>
-      <stringProp name="HTTPSampler.port"/>
-      <stringProp name="HTTPSampler.connect_timeout"/>
-      <stringProp name="HTTPSampler.response_timeout"/>
-      <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
-      <stringProp name="HTTPSampler.contentEncoding"/>
-      <stringProp name="HTTPSampler.path">${base_path}${admin_path}/mui/index/render/</stringProp>
-      <stringProp name="HTTPSampler.method">GET</stringProp>
-      <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
-      <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
-      <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
-      <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
-      <boolProp name="HTTPSampler.monitor">false</boolProp>
-      <stringProp name="HTTPSampler.embedded_url_re"/>
-    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_browse_products_grid/get_product_pages_count.jmx</stringProp></HTTPSamplerProxy>
-    <hashTree>
-      <com.atlantbh.jmeter.plugins.jsonutils.jsonpathassertion.JSONPathAssertion guiclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathassertion.gui.JSONPathAssertionGui" testclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathassertion.JSONPathAssertion" testname="Assert total records is not 0" enabled="true">
-        <stringProp name="JSON_PATH">$.totalRecords</stringProp>
-        <stringProp name="EXPECTED_VALUE">0</stringProp>
-        <boolProp name="JSONVALIDATION">true</boolProp>
-        <boolProp name="EXPECT_NULL">false</boolProp>
-        <boolProp name="INVERT">true</boolProp>
-      </com.atlantbh.jmeter.plugins.jsonutils.jsonpathassertion.JSONPathAssertion>
-      <hashTree/>
-      <com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor guiclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.gui.JSONPathExtractorGui" testclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor" testname="Extract total records" enabled="true">
-        <stringProp name="VAR">products_number</stringProp>
-        <stringProp name="JSONPATH">$.totalRecords</stringProp>
-        <stringProp name="DEFAULT"/>
-        <stringProp name="VARIABLE"/>
-        <stringProp name="SUBJECT">BODY</stringProp>
-      </com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor>
-      <hashTree/>
-      <BeanShellPostProcessor guiclass="TestBeanGUI" testclass="BeanShellPostProcessor" testname="Calculate pages count" enabled="true">
-        <boolProp name="resetInterpreter">false</boolProp>
-        <stringProp name="parameters"/>
-        <stringProp name="filename"/>
-        <stringProp name="script">var productsPageSize = Integer.parseInt(vars.get("products_page_size"));
-var productsTotal = Integer.parseInt(vars.get("products_number"));
-var pageCountProducts = Math.round(productsTotal/productsPageSize);
-
-vars.put("pages_count_product", String.valueOf(pageCountProducts));</stringProp>
-      </BeanShellPostProcessor>
-      <hashTree/>
-    </hashTree>
-  </hashTree>
-  
-    <GenericController guiclass="LogicControllerGui" testclass="GenericController" testname="Simple Controller" enabled="true">
-  <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/simple_controller.jmx</stringProp>
-</GenericController>
-    <hashTree>
-    <BeanShellSampler guiclass="BeanShellSamplerGui" testclass="BeanShellSampler" testname="SetUp - Set Arguments" enabled="true">
-      <stringProp name="BeanShellSampler.query">
-import java.util.Random;
-Random random = new Random();
-if (${seedForRandom} &gt; 0) {
-    random.setSeed(${seedForRandom});
-}
-var productsPageSize = Integer.parseInt(vars.get("products_page_size"));
-var totalNumberOfPages = Integer.parseInt(vars.get("pages_count_product"));
-
-// Randomly select a page.
-var randomProductsPage = Math.floor((Math.random() * totalNumberOfPages) + 1);
-
-// Get the first and last product id on that page.
-var lastProductIdOnPage = randomProductsPage * productsPageSize;
-var firstProductIdOnPage = lastProductIdOnPage - productsPageSize + 1;
-
-var randomProductId1 = Math.floor(random.nextInt(productsPageSize)) + firstProductIdOnPage;
-var randomProductId2 = Math.floor(random.nextInt(productsPageSize)) + firstProductIdOnPage;
-var randomProductId3 = Math.floor(random.nextInt(productsPageSize)) + firstProductIdOnPage;
-
-vars.put("page_number", String.valueOf(randomProductsPage));
-vars.put("productId1", String.valueOf(randomProductId1));
-vars.put("productId2", String.valueOf(randomProductId2));
-vars.put("productId3", String.valueOf(randomProductId3));
-
-var randomQuantity = Math.floor(Math.random() * 1000) + 1;
-var randomPrice = Math.floor(Math.random() * 500) + 10;
-var randomVisibility = Math.floor(random.nextInt(4)) + 1;
-
-vars.put("quantity", String.valueOf(randomQuantity));
-vars.put("price", String.valueOf(randomPrice));
-vars.put("visibility", String.valueOf(randomVisibility));
-
-
-      </stringProp>
-      <stringProp name="BeanShellSampler.filename"/>
-      <stringProp name="BeanShellSampler.parameters"/>
-      <boolProp name="BeanShellSampler.resetInterpreter">false</boolProp>
-    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_browse_products_grid/products_grid_mass_actions/setup.jmx</stringProp></BeanShellSampler>
-    <hashTree/>
-  
-    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Select Products and Update Attributes mass action" enabled="true">
-      <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
-        <collectionProp name="Arguments.arguments">
-          <elementProp name="form_key" elementType="HTTPArgument">
+          <elementProp name="export_filter[email]" elementType="HTTPArgument">
             <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">${admin_form_key}</stringProp>
+            <stringProp name="Argument.value"/>
             <stringProp name="Argument.metadata">=</stringProp>
             <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">form_key</stringProp>
+            <stringProp name="Argument.name">export_filter[email]</stringProp>
             <stringProp name="Argument.desc">true</stringProp>
           </elementProp>
-          <elementProp name="namespace" elementType="HTTPArgument">
+          <elementProp name="export_filter[firstname]" elementType="HTTPArgument">
             <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">product_listing</stringProp>
+            <stringProp name="Argument.value"/>
             <stringProp name="Argument.metadata">=</stringProp>
             <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">namespace</stringProp>
+            <stringProp name="Argument.name">export_filter[firstname]</stringProp>
             <stringProp name="Argument.desc">true</stringProp>
           </elementProp>
-          <elementProp name="search" elementType="HTTPArgument">
+          <elementProp name="export_filter[gender]" elementType="HTTPArgument">
             <boolProp name="HTTPArgument.always_encode">true</boolProp>
             <stringProp name="Argument.value"/>
             <stringProp name="Argument.metadata">=</stringProp>
             <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">search</stringProp>
+            <stringProp name="Argument.name">export_filter[gender]</stringProp>
             <stringProp name="Argument.desc">true</stringProp>
           </elementProp>
-          <elementProp name="filters[placeholder]" elementType="HTTPArgument">
+          <elementProp name="export_filter[group_id]" elementType="HTTPArgument">
             <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">true</stringProp>
+            <stringProp name="Argument.value"/>
             <stringProp name="Argument.metadata">=</stringProp>
             <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">filters[placeholder]</stringProp>
+            <stringProp name="Argument.name">export_filter[group_id]</stringProp>
             <stringProp name="Argument.desc">true</stringProp>
           </elementProp>
-          <elementProp name="paging[pageSize]" elementType="HTTPArgument">
+          <elementProp name="export_filter[lastname]" elementType="HTTPArgument">
             <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">${products_page_size}</stringProp>
+            <stringProp name="Argument.value"/>
             <stringProp name="Argument.metadata">=</stringProp>
             <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">paging[pageSize]</stringProp>
+            <stringProp name="Argument.name">export_filter[lastname]</stringProp>
             <stringProp name="Argument.desc">true</stringProp>
           </elementProp>
-          <elementProp name="paging[current]" elementType="HTTPArgument">
+          <elementProp name="export_filter[middlename]" elementType="HTTPArgument">
             <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">${page_number}</stringProp>
+            <stringProp name="Argument.value"/>
             <stringProp name="Argument.metadata">=</stringProp>
             <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">paging[current]</stringProp>
+            <stringProp name="Argument.name">export_filter[middlename]</stringProp>
             <stringProp name="Argument.desc">true</stringProp>
           </elementProp>
-          <elementProp name="sorting[field]" elementType="HTTPArgument">
+          <elementProp name="export_filter[password_hash]" elementType="HTTPArgument">
             <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">entity_id</stringProp>
+            <stringProp name="Argument.value"/>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">export_filter[password_hash]</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
+          </elementProp>
+          <elementProp name="export_filter[prefix]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value"/>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">export_filter[prefix]</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
+          </elementProp>
+          <elementProp name="export_filter[reward_update_notification][]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">,</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">export_filter[reward_update_notification][]</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
+          </elementProp>
+          <elementProp name="export_filter[reward_warning_notification][]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">,</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">export_filter[reward_warning_notification][]</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
+          </elementProp>
+          <elementProp name="export_filter[rp_token]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value"/>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">export_filter[rp_token]</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
+          </elementProp>
+          <elementProp name="export_filter[rp_token_created_at][]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">,</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">export_filter[rp_token_created_at][]</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
+          </elementProp>
+          <elementProp name="export_filter[store_id]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value"/>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">export_filter[store_id]</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
+          </elementProp>
+          <elementProp name="export_filter[suffix]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value"/>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">export_filter[suffix]</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
+          </elementProp>
+          <elementProp name="export_filter[taxvat]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value"/>
             <stringProp name="Argument.metadata">=</stringProp>
             <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">sorting[field]</stringProp>
+            <stringProp name="Argument.name">export_filter[taxvat]</stringProp>
             <stringProp name="Argument.desc">true</stringProp>
           </elementProp>
-          <elementProp name="sorting[direction]" elementType="HTTPArgument">
+          <elementProp name="export_filter[website_id]" elementType="HTTPArgument">
             <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">asc</stringProp>
+            <stringProp name="Argument.value"/>
             <stringProp name="Argument.metadata">=</stringProp>
             <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">sorting[direction]</stringProp>
+            <stringProp name="Argument.name">export_filter[website_id]</stringProp>
             <stringProp name="Argument.desc">true</stringProp>
           </elementProp>
-          <elementProp name="isAjax" elementType="HTTPArgument">
+          <elementProp name="frontend_label" elementType="HTTPArgument">
             <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">true</stringProp>
+            <stringProp name="Argument.value"/>
             <stringProp name="Argument.metadata">=</stringProp>
             <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">isAjax</stringProp>
+            <stringProp name="Argument.name">frontend_label</stringProp>
             <stringProp name="Argument.desc">true</stringProp>
           </elementProp>
         </collectionProp>
@@ -28129,75 +19584,116 @@ vars.put("visibility", String.valueOf(randomVisibility));
       <stringProp name="HTTPSampler.response_timeout"/>
       <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
       <stringProp name="HTTPSampler.contentEncoding"/>
-      <stringProp name="HTTPSampler.path">${base_path}${admin_path}/mui/index/render/</stringProp>
-      <stringProp name="HTTPSampler.method">GET</stringProp>
+      <stringProp name="HTTPSampler.path">${base_path}${admin_path}/admin/export/export/entity/customer/file_format/csv</stringProp>
+      <stringProp name="HTTPSampler.method">POST</stringProp>
       <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
       <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
       <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
       <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
       <boolProp name="HTTPSampler.monitor">false</boolProp>
       <stringProp name="HTTPSampler.embedded_url_re"/>
-    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_browse_products_grid/products_grid_mass_actions/display_grid.jmx</stringProp></HTTPSamplerProxy>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/export_customers/export_customers.jmx</stringProp></HTTPSamplerProxy>
     <hashTree>
       <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Response Assertion" enabled="true">
         <collectionProp name="Asserion.test_strings">
-          <stringProp name="1637639774">totalRecords</stringProp>
+          <stringProp name="-2040454917">user_1@example.com</stringProp>
         </collectionProp>
         <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
         <boolProp name="Assertion.assume_success">false</boolProp>
-        <intProp name="Assertion.test_type">2</intProp>
+        <intProp name="Assertion.test_type">16</intProp>
       </ResponseAssertion>
       <hashTree/>
     </hashTree>
+  </hashTree>
   
-    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Display Update Attributes" enabled="true">
+    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Logout" enabled="true">
       <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
+        <collectionProp name="Arguments.arguments"/>
+      </elementProp>
+      <stringProp name="HTTPSampler.domain"/>
+      <stringProp name="HTTPSampler.port"/>
+      <stringProp name="HTTPSampler.connect_timeout"/>
+      <stringProp name="HTTPSampler.response_timeout"/>
+      <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
+      <stringProp name="HTTPSampler.contentEncoding"/>
+      <stringProp name="HTTPSampler.path">${base_path}${admin_path}/admin/auth/logout/</stringProp>
+      <stringProp name="HTTPSampler.method">GET</stringProp>
+      <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
+      <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
+      <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
+      <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
+      <boolProp name="HTTPSampler.monitor">false</boolProp>
+      <stringProp name="HTTPSampler.embedded_url_re"/>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/setup/admin_logout.jmx</stringProp></HTTPSamplerProxy>
+    <hashTree>
+    
+    <BeanShellPostProcessor guiclass="TestBeanGUI" testclass="BeanShellPostProcessor" testname="Return Admin to Pool" enabled="true">
+        <boolProp name="resetInterpreter">false</boolProp>
+        <stringProp name="parameters"/>
+        <stringProp name="filename"/>
+        <stringProp name="script">
+adminUserList = props.get("adminUserList");
+adminUserList.add(vars.get("admin_user"));
+        </stringProp>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/common/return_admin_email_to_pool.jmx</stringProp></BeanShellPostProcessor>
+    <hashTree/>
+  </hashTree>
+  </hashTree>
+
+  
+    <ThroughputController guiclass="ThroughputControllerGui" testclass="ThroughputController" testname="API" enabled="true">
+      <intProp name="ThroughputController.style">1</intProp>
+      <boolProp name="ThroughputController.perThread">false</boolProp>
+      <intProp name="ThroughputController.maxThroughput">1</intProp>
+      <stringProp name="ThroughputController.percentThroughput">${apiBasePercentage}</stringProp>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/_system/scenario_controller_tmpl.jmx</stringProp></ThroughputController>
+    <hashTree>
+        <JSR223PreProcessor guiclass="TestBeanGUI" testclass="JSR223PreProcessor" testname="Set Test Label" enabled="true">
+            <stringProp name="script">
+var testLabel = "${testLabel}" ? " (${testLabel})" : "";
+if (testLabel
+    &amp;&amp; sampler.getClass().getName() == 'org.apache.jmeter.protocol.http.sampler.HTTPSamplerProxy'
+) {
+    if (sampler.getName().indexOf(testLabel) == -1) {
+       sampler.setName(sampler.getName() + testLabel);
+    }
+} else if (sampler.getName().indexOf("SetUp - ") == -1) {
+    sampler.setName("SetUp - " + sampler.getName());
+}
+            </stringProp>
+            <stringProp name="scriptLanguage">javascript</stringProp>
+        <stringProp name="TestPlan.comments">mpaf/tool/fragments/_system/setup_label.jmx</stringProp></JSR223PreProcessor>
+        <hashTree/>
+        <BeanShellSampler guiclass="BeanShellSamplerGui" testclass="BeanShellSampler" testname="SetUp - Set Label" enabled="true">
+            <stringProp name="BeanShellSampler.query">
+                vars.put("testLabel", "API");
+            </stringProp>
+            <boolProp name="BeanShellSampler.resetInterpreter">true</boolProp>
+        </BeanShellSampler>
+        <hashTree/>
+    
+    <HeaderManager guiclass="HeaderPanel" testclass="HeaderManager" testname="HTTP Header Manager" enabled="true">
+      <collectionProp name="HeaderManager.headers">
+        <elementProp name="" elementType="Header">
+          <stringProp name="Header.name">Content-Type</stringProp>
+          <stringProp name="Header.value">application/json</stringProp>
+        </elementProp>
+        <elementProp name="" elementType="Header">
+          <stringProp name="Header.name">Accept</stringProp>
+          <stringProp name="Header.value">*/*</stringProp>
+        </elementProp>
+      </collectionProp>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/api/header_manager_before_token.jmx</stringProp></HeaderManager>
+    <hashTree/>
+  
+    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="SetUp - Admin Token Retrieval" enabled="true">
+      <boolProp name="HTTPSampler.postBodyRaw">true</boolProp>
+      <elementProp name="HTTPsampler.Arguments" elementType="Arguments">
         <collectionProp name="Arguments.arguments">
-          <elementProp name="selected[0]" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">${productId1}</stringProp>
-            <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">selected[0]</stringProp>
-          </elementProp>
-          <elementProp name="selected[1]" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">${productId2}</stringProp>
-            <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">selected[1]</stringProp>
-          </elementProp>
-          <elementProp name="selected[2]" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">${productId3}</stringProp>
-            <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">selected[2]</stringProp>
-            <stringProp name="Argument.desc">true</stringProp>
-          </elementProp>
-          <elementProp name="filters[placeholder]" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">true</stringProp>
-            <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">filters[placeholder]</stringProp>
-            <stringProp name="Argument.desc">false</stringProp>
-          </elementProp>
-          <elementProp name="form_key" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">${admin_form_key}</stringProp>
-            <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">form_key</stringProp>
-            <stringProp name="Argument.desc">false</stringProp>
-          </elementProp>
-          <elementProp name="namespace" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">product_listing</stringProp>
+          <elementProp name="" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">false</boolProp>
+            <stringProp name="Argument.value">{"username":"${admin_user}","password":"${admin_password}"}</stringProp>
             <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">namespace</stringProp>
-            <stringProp name="Argument.desc">false</stringProp>
           </elementProp>
         </collectionProp>
       </elementProp>
@@ -28207,244 +19703,52 @@ vars.put("visibility", String.valueOf(randomVisibility));
       <stringProp name="HTTPSampler.response_timeout"/>
       <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
       <stringProp name="HTTPSampler.contentEncoding"/>
-      <stringProp name="HTTPSampler.path">${base_path}${admin_path}/catalog/product_action_attribute/edit</stringProp>
-      <stringProp name="HTTPSampler.method">GET</stringProp>
+      <stringProp name="HTTPSampler.path">${base_path}rest/V1/integration/admin/token</stringProp>
+      <stringProp name="HTTPSampler.method">POST</stringProp>
       <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
       <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
       <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
       <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
       <boolProp name="HTTPSampler.monitor">false</boolProp>
       <stringProp name="HTTPSampler.embedded_url_re"/>
-    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_browse_products_grid/products_grid_mass_actions/display_update_attributes.jmx</stringProp></HTTPSamplerProxy>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/api/admin_token_retrieval.jmx</stringProp></HTTPSamplerProxy>
     <hashTree>
-      <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Response Assertion" enabled="true">
+      <com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor guiclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.gui.JSONPathExtractorGui" testclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor" testname="jp@gc - JSON Path Extractor" enabled="true">
+        <stringProp name="VAR">admin_token</stringProp>
+        <stringProp name="JSONPATH">$</stringProp>
+        <stringProp name="DEFAULT"/>
+        <stringProp name="VARIABLE"/>
+        <stringProp name="SUBJECT">BODY</stringProp>
+      </com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor>
+      <hashTree/>
+      <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert token not null" enabled="true">
         <collectionProp name="Asserion.test_strings">
-          <stringProp name="1862384910">Update Attributes</stringProp>
+          <stringProp name="484395188">^[a-z0-9-]+$</stringProp>
         </collectionProp>
         <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
         <boolProp name="Assertion.assume_success">false</boolProp>
-        <intProp name="Assertion.test_type">2</intProp>
+        <intProp name="Assertion.test_type">1</intProp>
+        <stringProp name="Assertion.scope">variable</stringProp>
+        <stringProp name="Scope.variable">admin_token</stringProp>
       </ResponseAssertion>
       <hashTree/>
     </hashTree>
   
-  <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Validate Attributes" enabled="true">
-    <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
-      <collectionProp name="Arguments.arguments">
-        <elementProp name="isAjax" elementType="HTTPArgument">
-          <boolProp name="HTTPArgument.always_encode">true</boolProp>
-          <stringProp name="Argument.value">true</stringProp>
-          <stringProp name="Argument.metadata">=</stringProp>
-          <boolProp name="HTTPArgument.use_equals">true</boolProp>
-          <stringProp name="Argument.name">isAjax</stringProp>
-          <stringProp name="Argument.desc">true</stringProp>
-        </elementProp>
-        <elementProp name="form_key" elementType="HTTPArgument">
-          <boolProp name="HTTPArgument.always_encode">true</boolProp>
-          <stringProp name="Argument.value">${admin_form_key}</stringProp>
-          <stringProp name="Argument.metadata">=</stringProp>
-          <boolProp name="HTTPArgument.use_equals">true</boolProp>
-          <stringProp name="Argument.name">form_key</stringProp>
-          <stringProp name="Argument.desc">true</stringProp>
-        </elementProp>
-        <elementProp name="product[product_has_weight]" elementType="HTTPArgument">
-          <boolProp name="HTTPArgument.always_encode">true</boolProp>
-          <stringProp name="Argument.value">1</stringProp>
-          <stringProp name="Argument.metadata">=</stringProp>
-          <boolProp name="HTTPArgument.use_equals">true</boolProp>
-          <stringProp name="Argument.name">product[product_has_weight]</stringProp>
-          <stringProp name="Argument.desc">true</stringProp>
-        </elementProp>
-        <elementProp name="product[use_config_gift_message_available]" elementType="HTTPArgument">
-          <boolProp name="HTTPArgument.always_encode">true</boolProp>
-          <stringProp name="Argument.value">1</stringProp>
-          <stringProp name="Argument.metadata">=</stringProp>
-          <boolProp name="HTTPArgument.use_equals">true</boolProp>
-          <stringProp name="Argument.name">product[use_config_gift_message_available]</stringProp>
-          <stringProp name="Argument.desc">true</stringProp>
-        </elementProp>
-        <elementProp name="product[use_config_gift_wrapping_available]" elementType="HTTPArgument">
-          <boolProp name="HTTPArgument.always_encode">true</boolProp>
-          <stringProp name="Argument.value">1</stringProp>
-          <stringProp name="Argument.metadata">=</stringProp>
-          <boolProp name="HTTPArgument.use_equals">true</boolProp>
-          <stringProp name="Argument.name">product[use_config_gift_wrapping_available]</stringProp>
-          <stringProp name="Argument.desc">true</stringProp>
-        </elementProp>
-        <elementProp name="inventory[qty]" elementType="HTTPArgument">
-          <boolProp name="HTTPArgument.always_encode">true</boolProp>
-          <stringProp name="Argument.value">${quantity}</stringProp>
-          <stringProp name="Argument.metadata">=</stringProp>
-          <boolProp name="HTTPArgument.use_equals">true</boolProp>
-          <stringProp name="Argument.name">inventory[qty]</stringProp>
-          <stringProp name="Argument.desc">true</stringProp>
-        </elementProp>
-        <elementProp name="attributes[price]" elementType="HTTPArgument">
-          <boolProp name="HTTPArgument.always_encode">true</boolProp>
-          <stringProp name="Argument.value">${price}</stringProp>
-          <stringProp name="Argument.metadata">=</stringProp>
-          <boolProp name="HTTPArgument.use_equals">true</boolProp>
-          <stringProp name="Argument.name">attributes[price]</stringProp>
-        </elementProp>
-        <elementProp name="attributes[visibility]" elementType="HTTPArgument">
-          <boolProp name="HTTPArgument.always_encode">true</boolProp>
-          <stringProp name="Argument.value">${visibility}</stringProp>
-          <stringProp name="Argument.metadata">=</stringProp>
-          <boolProp name="HTTPArgument.use_equals">true</boolProp>
-          <stringProp name="Argument.name">attributes[visibility]</stringProp>
-        </elementProp>
-      </collectionProp>
-    </elementProp>
-    <stringProp name="HTTPSampler.domain"/>
-    <stringProp name="HTTPSampler.port"/>
-    <stringProp name="HTTPSampler.connect_timeout"/>
-    <stringProp name="HTTPSampler.response_timeout"/>
-    <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
-    <stringProp name="HTTPSampler.contentEncoding"/>
-    <stringProp name="HTTPSampler.path">${base_path}${admin_path}/catalog/product_action_attribute/validate</stringProp>
-    <stringProp name="HTTPSampler.method">POST</stringProp>
-    <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
-    <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
-    <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
-    <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
-    <boolProp name="HTTPSampler.monitor">false</boolProp>
-    <stringProp name="HTTPSampler.embedded_url_re"/>
-  <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_browse_products_grid/products_grid_mass_actions/change_attributes.jmx</stringProp></HTTPSamplerProxy>
-  <hashTree>
-    <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Response Assertion" enabled="true">
-      <collectionProp name="Asserion.test_strings">
-        <stringProp name="1853918323">{"error":false}</stringProp>
-      </collectionProp>
-      <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
-      <boolProp name="Assertion.assume_success">false</boolProp>
-      <intProp name="Assertion.test_type">2</intProp>
-    </ResponseAssertion>
-    <hashTree/>
-  </hashTree>
-  <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Save Attributes" enabled="true">
-    <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
-      <collectionProp name="Arguments.arguments">
-        <elementProp name="isAjax" elementType="HTTPArgument">
-          <boolProp name="HTTPArgument.always_encode">true</boolProp>
-          <stringProp name="Argument.value">true</stringProp>
-          <stringProp name="Argument.metadata">=</stringProp>
-          <boolProp name="HTTPArgument.use_equals">true</boolProp>
-          <stringProp name="Argument.name">isAjax</stringProp>
-          <stringProp name="Argument.desc">false</stringProp>
-        </elementProp>
-        <elementProp name="form_key" elementType="HTTPArgument">
-          <boolProp name="HTTPArgument.always_encode">true</boolProp>
-          <stringProp name="Argument.value">${admin_form_key}</stringProp>
-          <stringProp name="Argument.metadata">=</stringProp>
-          <boolProp name="HTTPArgument.use_equals">true</boolProp>
-          <stringProp name="Argument.name">form_key</stringProp>
-          <stringProp name="Argument.desc">false</stringProp>
-        </elementProp>
-        <elementProp name="product[product_has_weight]" elementType="HTTPArgument">
-          <boolProp name="HTTPArgument.always_encode">true</boolProp>
-          <stringProp name="Argument.value">1</stringProp>
-          <stringProp name="Argument.metadata">=</stringProp>
-          <boolProp name="HTTPArgument.use_equals">true</boolProp>
-          <stringProp name="Argument.name">product[product_has_weight]</stringProp>
-          <stringProp name="Argument.desc">true</stringProp>
-        </elementProp>
-        <elementProp name="product[use_config_gift_message_available]" elementType="HTTPArgument">
-          <boolProp name="HTTPArgument.always_encode">true</boolProp>
-          <stringProp name="Argument.value">1</stringProp>
-          <stringProp name="Argument.metadata">=</stringProp>
-          <boolProp name="HTTPArgument.use_equals">true</boolProp>
-          <stringProp name="Argument.name">product[use_config_gift_message_available]</stringProp>
-        </elementProp>
-        <elementProp name="product[use_config_gift_wrapping_available]" elementType="HTTPArgument">
-          <boolProp name="HTTPArgument.always_encode">true</boolProp>
-          <stringProp name="Argument.value">1</stringProp>
-          <stringProp name="Argument.metadata">=</stringProp>
-          <boolProp name="HTTPArgument.use_equals">true</boolProp>
-          <stringProp name="Argument.name">product[use_config_gift_wrapping_available]</stringProp>
-          <stringProp name="Argument.desc">true</stringProp>
-        </elementProp>
-        <elementProp name="inventory[qty]" elementType="HTTPArgument">
-          <boolProp name="HTTPArgument.always_encode">true</boolProp>
-          <stringProp name="Argument.value">${quantity}</stringProp>
-          <stringProp name="Argument.metadata">=</stringProp>
-          <boolProp name="HTTPArgument.use_equals">true</boolProp>
-          <stringProp name="Argument.name">inventory[qty]</stringProp>
-        </elementProp>
-        <elementProp name="toggle_qty" elementType="HTTPArgument">
-          <boolProp name="HTTPArgument.always_encode">true</boolProp>
-          <stringProp name="Argument.value">on</stringProp>
-          <stringProp name="Argument.metadata">=</stringProp>
-          <boolProp name="HTTPArgument.use_equals">true</boolProp>
-          <stringProp name="Argument.name">toggle_price</stringProp>
-          <stringProp name="Argument.desc">true</stringProp>
-        </elementProp>
-        <elementProp name="attributes[price]" elementType="HTTPArgument">
-          <boolProp name="HTTPArgument.always_encode">true</boolProp>
-          <stringProp name="Argument.value">${price}</stringProp>
-          <stringProp name="Argument.metadata">=</stringProp>
-          <boolProp name="HTTPArgument.use_equals">true</boolProp>
-          <stringProp name="Argument.name">attributes[price]</stringProp>
-        </elementProp>
-        <elementProp name="toggle_price" elementType="HTTPArgument">
-          <boolProp name="HTTPArgument.always_encode">true</boolProp>
-          <stringProp name="Argument.value">on</stringProp>
-          <stringProp name="Argument.metadata">=</stringProp>
-          <boolProp name="HTTPArgument.use_equals">true</boolProp>
-          <stringProp name="Argument.name">toggle_price</stringProp>
-          <stringProp name="Argument.desc">true</stringProp>
-        </elementProp>
-        <elementProp name="attributes[visibility]" elementType="HTTPArgument">
-          <boolProp name="HTTPArgument.always_encode">true</boolProp>
-          <stringProp name="Argument.value">${visibility}</stringProp>
-          <stringProp name="Argument.metadata">=</stringProp>
-          <boolProp name="HTTPArgument.use_equals">true</boolProp>
-          <stringProp name="Argument.name">attributes[visibility]</stringProp>
-        </elementProp>
-        <elementProp name="toggle_visibility" elementType="HTTPArgument">
-          <boolProp name="HTTPArgument.always_encode">true</boolProp>
-          <stringProp name="Argument.value">on</stringProp>
-          <stringProp name="Argument.metadata">=</stringProp>
-          <boolProp name="HTTPArgument.use_equals">true</boolProp>
-          <stringProp name="Argument.name">toggle_visibility</stringProp>
-          <stringProp name="Argument.desc">true</stringProp>
+    <HeaderManager guiclass="HeaderPanel" testclass="HeaderManager" testname="HTTP Header Manager" enabled="true">
+      <collectionProp name="HeaderManager.headers">
+        <elementProp name="" elementType="Header">
+          <stringProp name="Header.name">Authorization</stringProp>
+          <stringProp name="Header.value">Bearer ${admin_token}</stringProp>
         </elementProp>
       </collectionProp>
-    </elementProp>
-    <stringProp name="HTTPSampler.domain"/>
-    <stringProp name="HTTPSampler.port"/>
-    <stringProp name="HTTPSampler.connect_timeout"/>
-    <stringProp name="HTTPSampler.response_timeout"/>
-    <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
-    <stringProp name="HTTPSampler.contentEncoding"/>
-    <stringProp name="HTTPSampler.path">${base_path}${admin_path}/catalog/product_action_attribute/save/store/0/active_tab/attributes</stringProp>
-    <stringProp name="HTTPSampler.method">POST</stringProp>
-    <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
-    <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
-    <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
-    <boolProp name="HTTPSampler.DO_MULTIPART_POST">true</boolProp>
-    <boolProp name="HTTPSampler.monitor">false</boolProp>
-    <stringProp name="HTTPSampler.embedded_url_re"/>
-  </HTTPSamplerProxy>
-  <hashTree>
-    <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Response Assertion" enabled="true">
-      <collectionProp name="Asserion.test_strings">
-        <stringProp name="1848809106">were updated.</stringProp>
-      </collectionProp>
-      <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
-      <boolProp name="Assertion.assume_success">false</boolProp>
-      <intProp name="Assertion.test_type">2</intProp>
-    </ResponseAssertion>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/api/header_manager.jmx</stringProp></HeaderManager>
     <hashTree/>
-  </hashTree>
-</hashTree>
-  </hashTree>
-
   
-    <ThroughputController guiclass="ThroughputControllerGui" testclass="ThroughputController" testname="Admin Account management" enabled="true">
+    <ThroughputController guiclass="ThroughputControllerGui" testclass="ThroughputController" testname="API Process Orders" enabled="true">
       <intProp name="ThroughputController.style">1</intProp>
       <boolProp name="ThroughputController.perThread">false</boolProp>
       <intProp name="ThroughputController.maxThroughput">1</intProp>
-      <stringProp name="ThroughputController.percentThroughput">${adminAccountManagementPercentage}</stringProp>
+      <stringProp name="ThroughputController.percentThroughput">100</stringProp>
     <stringProp name="TestPlan.comments">mpaf/tool/fragments/_system/scenario_controller_tmpl.jmx</stringProp></ThroughputController>
     <hashTree>
         <JSR223PreProcessor guiclass="TestBeanGUI" testclass="JSR223PreProcessor" testname="Set Test Label" enabled="true">
@@ -28465,108 +19769,100 @@ if (testLabel
         <hashTree/>
         <BeanShellSampler guiclass="BeanShellSamplerGui" testclass="BeanShellSampler" testname="SetUp - Set Label" enabled="true">
             <stringProp name="BeanShellSampler.query">
-                vars.put("testLabel", "Admin Account management");
+                vars.put("testLabel", "API Process Orders");
             </stringProp>
             <boolProp name="BeanShellSampler.resetInterpreter">true</boolProp>
         </BeanShellSampler>
         <hashTree/>
     
-    <CookieManager guiclass="CookiePanel" testclass="CookieManager" testname="HTTP Cookie Manager" enabled="true">
-      <collectionProp name="CookieManager.cookies">
-        <elementProp name="product_list_limit" elementType="Cookie" testname="product_list_limit">
-          <stringProp name="Cookie.value">30</stringProp>
-          <stringProp name="Cookie.domain">${host}</stringProp>
-          <stringProp name="Cookie.path">/</stringProp>
-          <boolProp name="Cookie.secure">false</boolProp>
-          <longProp name="Cookie.expires">0</longProp>
-          <boolProp name="Cookie.path_specified">true</boolProp>
-          <boolProp name="Cookie.domain_specified">true</boolProp>
-        </elementProp>
-        <elementProp name="product_list_limit" elementType="Cookie" testname="form_key">
-          <stringProp name="Cookie.value">${form_key}</stringProp>
-          <stringProp name="Cookie.domain">${host}</stringProp>
-          <stringProp name="Cookie.path">${base_path}</stringProp>
-          <boolProp name="Cookie.secure">false</boolProp>
-          <longProp name="Cookie.expires">0</longProp>
-          <boolProp name="Cookie.path_specified">true</boolProp>
-          <boolProp name="Cookie.domain_specified">true</boolProp>
-        </elementProp>
-      </collectionProp>
-      <boolProp name="CookieManager.clearEachIteration">true</boolProp>
-    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/http_cookie_manager.jmx</stringProp></CookieManager>
-    <hashTree/>
-  
-    <BeanShellSampler guiclass="BeanShellSamplerGui" testclass="BeanShellSampler" testname="SetUp - Get Customer Email" enabled="true">
-      <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/get_customer_email.jmx</stringProp>
-      <stringProp name="BeanShellSampler.query">import org.apache.jmeter.samplers.SampleResult;
+    <BeanShellSampler guiclass="BeanShellSamplerGui" testclass="BeanShellSampler" testname="SetUp - Set Arguments" enabled="true">
+      <stringProp name="BeanShellSampler.query">// Each thread gets an equal number of orders, based on how many orders are available.
 
-String siterator = vars.get("customer_emails_index");
-int iterator;
-if(siterator == null){
-    iterator = 0;
-    vars.put("customer_emails_index", "0");
-} else {
-    iterator = Integer.parseInt(siterator);
-    iterator ++;
-    vars.put("customer_emails_index", iterator.toString());
-}
+      int apiProcessOrders = Integer.parseInt("${apiProcessOrders}");
+      if (apiProcessOrders &gt; 0) {
+      ordersPerThread = apiProcessOrders;
+      } else {
+      ordersPerThread = 1;
+      }
 
-emails_list = props.get("customer_emails_list");
 
-threadsNumber = ctx.getThreadGroup().getNumThreads();
-emailsCount = emails_list.size();
-if (threadsNumber &gt; emailsCount) {
-    log.error(" There are not enough customers for this scenario.");
-} else {
-    clusterLength = Math.round(emailsCount / threadsNumber);
-    threadNum = ctx.getThreadNum();
-    emails_index = clusterLength * threadNum + iterator;
-    maxLimit = clusterLength * (threadNum + 1);
-    if (emails_index &gt;= maxLimit) {
-        iterator = 0;
-        emails_index = clusterLength * threadNum + iterator;
-        vars.put("customer_emails_index", iterator.toString());
-    }
-}
-vars.put("customer_email", emails_list.get(emails_index));</stringProp>
+      threadNum = ${__threadNum};
+      vars.put("ordersPerThread", String.valueOf(ordersPerThread));
+      vars.put("threadNum", String.valueOf(threadNum));
+
+      </stringProp>
       <stringProp name="BeanShellSampler.filename"/>
       <stringProp name="BeanShellSampler.parameters"/>
-      <boolProp name="BeanShellSampler.resetInterpreter">true</boolProp>
-    </BeanShellSampler>
+      <boolProp name="BeanShellSampler.resetInterpreter">false</boolProp>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/api/process_orders/setup.jmx</stringProp></BeanShellSampler>
     <hashTree/>
   
-      <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Open Home Page" enabled="true">
-        <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
-          <collectionProp name="Arguments.arguments"/>
-        </elementProp>
-        <stringProp name="HTTPSampler.domain"/>
-        <stringProp name="HTTPSampler.port"/>
-        <stringProp name="HTTPSampler.connect_timeout"/>
-        <stringProp name="HTTPSampler.response_timeout"/>
-        <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
-        <stringProp name="HTTPSampler.contentEncoding"/>
-        <stringProp name="HTTPSampler.path">${base_path}</stringProp>
-        <stringProp name="HTTPSampler.method">GET</stringProp>
-        <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
-        <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
-        <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
-        <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
-        <boolProp name="HTTPSampler.monitor">false</boolProp>
-        <stringProp name="HTTPSampler.embedded_url_re"/>
-      <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/common/open_home_page.jmx</stringProp></HTTPSamplerProxy>
-      <hashTree>
-        <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Response Assertion" enabled="true">
-          <collectionProp name="Asserion.test_strings">
-            <stringProp name="571386695">&lt;title&gt;Home page&lt;/title&gt;</stringProp>
-          </collectionProp>
-          <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
-          <boolProp name="Assertion.assume_success">false</boolProp>
-          <intProp name="Assertion.test_type">2</intProp>
-        </ResponseAssertion>
-        <hashTree/>
-      </hashTree>
+    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Get Orders" enabled="true">
+      <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
+        <collectionProp name="Arguments.arguments">
+          <elementProp name="searchCriteria[filterGroups][0][filters][0][field]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">status</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">searchCriteria[filterGroups][0][filters][0][field]</stringProp>
+          </elementProp>
+          <elementProp name="searchCriteria[filterGroups][0][filters][0][value]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">Pending</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">searchCriteria[filterGroups][0][filters][0][value]</stringProp>
+          </elementProp>
+          <elementProp name="searchCriteria[pageSize]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">${ordersPerThread}</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">searchCriteria[pageSize]</stringProp>
+          </elementProp>
+          <elementProp name="searchCriteria[current_page]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">${threadNum}</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">searchCriteria[current_page]</stringProp>
+          </elementProp>
+        </collectionProp>
+      </elementProp>
+      <stringProp name="HTTPSampler.domain"/>
+      <stringProp name="HTTPSampler.port"/>
+      <stringProp name="HTTPSampler.connect_timeout"/>
+      <stringProp name="HTTPSampler.response_timeout"/>
+      <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
+      <stringProp name="HTTPSampler.contentEncoding"/>
+      <stringProp name="HTTPSampler.path">${base_path}rest/default/V1/orders</stringProp>
+      <stringProp name="HTTPSampler.method">GET</stringProp>
+      <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
+      <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
+      <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
+      <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
+      <boolProp name="HTTPSampler.monitor">false</boolProp>
+      <stringProp name="HTTPSampler.embedded_url_re"/>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/api/process_orders/get_orders.jmx</stringProp></HTTPSamplerProxy>
+    <hashTree>
+      <com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor guiclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.gui.JSONPathExtractorGui" testclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor" testname="Extract entity ids" enabled="true">
+        <stringProp name="VAR">entity_ids</stringProp>
+        <stringProp name="JSONPATH">$.items[*].entity_id</stringProp>
+        <stringProp name="DEFAULT"/>
+        <stringProp name="VARIABLE"/>
+        <stringProp name="SUBJECT">BODY</stringProp>
+      </com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor>
+      <hashTree/>
+    </hashTree>
   
-    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Open Login Page" enabled="true">
+    <ForeachController guiclass="ForeachControlPanel" testclass="ForeachController" testname="ForEach Order" enabled="true">
+      <stringProp name="ForeachController.inputVal">entity_ids</stringProp>
+      <stringProp name="ForeachController.returnVal">order_id</stringProp>
+      <boolProp name="ForeachController.useSeparator">true</boolProp>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/api/process_orders/for_each_order.jmx</stringProp></ForeachController>
+    <hashTree>
+    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Create Invoice" enabled="true">
       <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
         <collectionProp name="Arguments.arguments"/>
       </elementProp>
@@ -28576,19 +19872,19 @@ vars.put("customer_email", emails_list.get(emails_index));</stringProp>
       <stringProp name="HTTPSampler.response_timeout"/>
       <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
       <stringProp name="HTTPSampler.contentEncoding"/>
-      <stringProp name="HTTPSampler.path">${base_path}customer/account/login/</stringProp>
-      <stringProp name="HTTPSampler.method">GET</stringProp>
+      <stringProp name="HTTPSampler.path">${base_path}rest/default/V1/order/${order_id}/invoice</stringProp>
+      <stringProp name="HTTPSampler.method">POST</stringProp>
       <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
       <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
       <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
       <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
       <boolProp name="HTTPSampler.monitor">false</boolProp>
       <stringProp name="HTTPSampler.embedded_url_re"/>
-    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/common/open_login_page.jmx</stringProp></HTTPSamplerProxy>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/api/process_orders/create_invoice.jmx</stringProp></HTTPSamplerProxy>
     <hashTree>
       <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Response Assertion" enabled="true">
         <collectionProp name="Asserion.test_strings">
-          <stringProp name="637394530">&lt;title&gt;Customer Login&lt;/title&gt;</stringProp>
+          <stringProp name="34237953">"\d+"</stringProp>
         </collectionProp>
         <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
         <boolProp name="Assertion.assume_success">false</boolProp>
@@ -28597,38 +19893,9 @@ vars.put("customer_email", emails_list.get(emails_index));</stringProp>
       <hashTree/>
     </hashTree>
   
-    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Login" enabled="true">
+    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Create Shipment" enabled="true">
       <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
-        <collectionProp name="Arguments.arguments">
-          <elementProp name="form_key" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">${form_key}</stringProp>
-            <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">form_key</stringProp>
-          </elementProp>
-          <elementProp name="login[username]" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">${customer_email}</stringProp>
-            <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">login[username]</stringProp>
-          </elementProp>
-          <elementProp name="login[password]" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">${customer_password}</stringProp>
-            <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">login[password]</stringProp>
-          </elementProp>
-          <elementProp name="send" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value"/>
-            <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">send</stringProp>
-          </elementProp>
-        </collectionProp>
+        <collectionProp name="Arguments.arguments"/>
       </elementProp>
       <stringProp name="HTTPSampler.domain"/>
       <stringProp name="HTTPSampler.port"/>
@@ -28636,7 +19903,7 @@ vars.put("customer_email", emails_list.get(emails_index));</stringProp>
       <stringProp name="HTTPSampler.response_timeout"/>
       <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
       <stringProp name="HTTPSampler.contentEncoding"/>
-      <stringProp name="HTTPSampler.path">${base_path}customer/account/loginPost/</stringProp>
+      <stringProp name="HTTPSampler.path">${base_path}rest/default/V1/order/${order_id}/ship</stringProp>
       <stringProp name="HTTPSampler.method">POST</stringProp>
       <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
       <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
@@ -28644,61 +19911,67 @@ vars.put("customer_email", emails_list.get(emails_index));</stringProp>
       <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
       <boolProp name="HTTPSampler.monitor">false</boolProp>
       <stringProp name="HTTPSampler.embedded_url_re"/>
-    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/common/login.jmx</stringProp></HTTPSamplerProxy>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/api/process_orders/create_shipment.jmx</stringProp></HTTPSamplerProxy>
     <hashTree>
       <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Response Assertion" enabled="true">
         <collectionProp name="Asserion.test_strings">
-          <stringProp name="1312950388">&lt;title&gt;My Account&lt;/title&gt;</stringProp>
+          <stringProp name="34237953">"\d+"</stringProp>
         </collectionProp>
         <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
         <boolProp name="Assertion.assume_success">false</boolProp>
         <intProp name="Assertion.test_type">2</intProp>
       </ResponseAssertion>
       <hashTree/>
-      <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract Address" enabled="true">
-        <stringProp name="RegexExtractor.useHeaders">false</stringProp>
-        <stringProp name="RegexExtractor.refname">addressId</stringProp>
-        <stringProp name="RegexExtractor.regex">customer/address/edit/id/([^'"]+)/</stringProp>
-        <stringProp name="RegexExtractor.template">$1$</stringProp>
-        <stringProp name="RegexExtractor.default"/>
-        <stringProp name="RegexExtractor.match_number">1</stringProp>
-      </RegexExtractor>
-      <hashTree/>
-      <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert addressId extracted" enabled="true">
-        <collectionProp name="Asserion.test_strings">
-          <stringProp name="2845929">^.+$</stringProp>
-        </collectionProp>
-        <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
-        <boolProp name="Assertion.assume_success">false</boolProp>
-        <intProp name="Assertion.test_type">1</intProp>
-        <stringProp name="Assertion.scope">variable</stringProp>
-        <stringProp name="Scope.variable">addressId</stringProp>
-      </ResponseAssertion>
-      <hashTree/>
     </hashTree>
-    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Load Customer Private Data" enabled="true">
-      <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
+  </hashTree>
+  </hashTree>
+
+  
+    <ThroughputController guiclass="ThroughputControllerGui" testclass="ThroughputController" testname="API Product Management" enabled="true">
+      <intProp name="ThroughputController.style">1</intProp>
+      <boolProp name="ThroughputController.perThread">false</boolProp>
+      <intProp name="ThroughputController.maxThroughput">1</intProp>
+      <stringProp name="ThroughputController.percentThroughput">100</stringProp>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/_system/scenario_controller_tmpl.jmx</stringProp></ThroughputController>
+    <hashTree>
+        <JSR223PreProcessor guiclass="TestBeanGUI" testclass="JSR223PreProcessor" testname="Set Test Label" enabled="true">
+            <stringProp name="script">
+var testLabel = "${testLabel}" ? " (${testLabel})" : "";
+if (testLabel
+    &amp;&amp; sampler.getClass().getName() == 'org.apache.jmeter.protocol.http.sampler.HTTPSamplerProxy'
+) {
+    if (sampler.getName().indexOf(testLabel) == -1) {
+       sampler.setName(sampler.getName() + testLabel);
+    }
+} else if (sampler.getName().indexOf("SetUp - ") == -1) {
+    sampler.setName("SetUp - " + sampler.getName());
+}
+            </stringProp>
+            <stringProp name="scriptLanguage">javascript</stringProp>
+        <stringProp name="TestPlan.comments">mpaf/tool/fragments/_system/setup_label.jmx</stringProp></JSR223PreProcessor>
+        <hashTree/>
+        <BeanShellSampler guiclass="BeanShellSamplerGui" testclass="BeanShellSampler" testname="SetUp - Set Label" enabled="true">
+            <stringProp name="BeanShellSampler.query">
+                vars.put("testLabel", "API Product Management");
+            </stringProp>
+            <boolProp name="BeanShellSampler.resetInterpreter">true</boolProp>
+        </BeanShellSampler>
+        <hashTree/>
+    
+    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Create product" enabled="true">
+      <boolProp name="HTTPSampler.postBodyRaw">true</boolProp>
+      <elementProp name="HTTPsampler.Arguments" elementType="Arguments">
         <collectionProp name="Arguments.arguments">
-          <elementProp name="sections" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value"/>
-            <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">sections</stringProp>
-          </elementProp>
-          <elementProp name="update_section_id" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">false</stringProp>
-            <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">update_section_id</stringProp>
-          </elementProp>
-          <elementProp name="_" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">${__time()}${__Random(1,1000000)}</stringProp>
+          <elementProp name="" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">false</boolProp>
+            <stringProp name="Argument.value">{&#xD;
+    "product": {&#xD;
+        "sku": "psku-test-${__time()}-${__threadNum}-${__Random(1,1000000)}",&#xD;
+        "name": "Product_${__time()}-${__threadNum}-${__Random(1,1000000)}",&#xD;
+        "attributeSetId": 4&#xD;
+    }&#xD;
+}</stringProp>
             <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">_</stringProp>
           </elementProp>
         </collectionProp>
       </elementProp>
@@ -28708,20 +19981,91 @@ vars.put("customer_email", emails_list.get(emails_index));</stringProp>
       <stringProp name="HTTPSampler.response_timeout"/>
       <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
       <stringProp name="HTTPSampler.contentEncoding"/>
-      <stringProp name="HTTPSampler.path">${base_path}customer/section/load/</stringProp>
-      <stringProp name="HTTPSampler.method">GET</stringProp>
+      <stringProp name="HTTPSampler.path">${base_path}rest/default/V1/products</stringProp>
+      <stringProp name="HTTPSampler.method">POST</stringProp>
       <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
       <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
       <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
       <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
       <boolProp name="HTTPSampler.monitor">false</boolProp>
       <stringProp name="HTTPSampler.embedded_url_re"/>
-    </HTTPSamplerProxy>
-    <hashTree/>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/api/create_product_no_custom_attributes.jmx</stringProp></HTTPSamplerProxy>
+    <hashTree>
+      <com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor guiclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.gui.JSONPathExtractorGui" testclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor" testname="Extract product id" enabled="true">
+        <stringProp name="VAR">simple_product_id</stringProp>
+        <stringProp name="JSONPATH">$.id</stringProp>
+        <stringProp name="DEFAULT"/>
+        <stringProp name="VARIABLE"/>
+        <stringProp name="SUBJECT">BODY</stringProp>
+      </com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor>
+      <hashTree/>
+      <com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor guiclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.gui.JSONPathExtractorGui" testclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor" testname="Extract product sku" enabled="true">
+        <stringProp name="VAR">simple_product_sku</stringProp>
+        <stringProp name="JSONPATH">$.sku</stringProp>
+        <stringProp name="DEFAULT"/>
+        <stringProp name="VARIABLE"/>
+        <stringProp name="SUBJECT">BODY</stringProp>
+      </com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor>
+      <hashTree/>
+      <com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor guiclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.gui.JSONPathExtractorGui" testclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor" testname="Extract stock item id" enabled="true">
+        <stringProp name="VAR">simple_stock_item_id</stringProp>
+        <stringProp name="JSONPATH">$.extension_attributes.stock_item.item_id</stringProp>
+        <stringProp name="DEFAULT"/>
+        <stringProp name="VARIABLE"/>
+        <stringProp name="SUBJECT">BODY</stringProp>
+      </com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor>
+      <hashTree/>
+      <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert product id not null" enabled="true">
+        <collectionProp name="Asserion.test_strings">
+          <stringProp name="89649215">^\d+$</stringProp>
+        </collectionProp>
+        <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
+        <boolProp name="Assertion.assume_success">false</boolProp>
+        <intProp name="Assertion.test_type">1</intProp>
+        <stringProp name="Assertion.scope">variable</stringProp>
+        <stringProp name="Scope.variable">simple_product_id</stringProp>
+      </ResponseAssertion>
+      <hashTree/>
+      <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert product sku not null" enabled="true">
+        <collectionProp name="Asserion.test_strings">
+          <stringProp name="484395188">^[a-z0-9-]+$</stringProp>
+        </collectionProp>
+        <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
+        <boolProp name="Assertion.assume_success">false</boolProp>
+        <intProp name="Assertion.test_type">1</intProp>
+        <stringProp name="Assertion.scope">variable</stringProp>
+        <stringProp name="Scope.variable">simple_product_sku</stringProp>
+      </ResponseAssertion>
+      <hashTree/>
+      <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert stock item id not null" enabled="true">
+        <collectionProp name="Asserion.test_strings">
+          <stringProp name="89649215">^\d+$</stringProp>
+        </collectionProp>
+        <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
+        <boolProp name="Assertion.assume_success">false</boolProp>
+        <intProp name="Assertion.test_type">1</intProp>
+        <stringProp name="Assertion.scope">variable</stringProp>
+        <stringProp name="Scope.variable">simple_stock_item_id</stringProp>
+      </ResponseAssertion>
+      <hashTree/>
+    </hashTree>
   
-    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="My Orders" enabled="true">
-      <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
-        <collectionProp name="Arguments.arguments"/>
+    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Update product stock info" enabled="true">
+      <boolProp name="HTTPSampler.postBodyRaw">true</boolProp>
+      <elementProp name="HTTPsampler.Arguments" elementType="Arguments">
+        <collectionProp name="Arguments.arguments">
+          <elementProp name="" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">false</boolProp>
+            <stringProp name="Argument.value">{&#xD;
+        "stock_item": {   &#xD;
+        	"manage_stock": true,    &#xD;
+        	"is_in_stock": true,&#xD;
+          "qty": ${simple_product_id}&#xD;
+        }&#xD;
+    }</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+          </elementProp>
+        </collectionProp>
       </elementProp>
       <stringProp name="HTTPSampler.domain"/>
       <stringProp name="HTTPSampler.port"/>
@@ -28729,162 +20073,36 @@ vars.put("customer_email", emails_list.get(emails_index));</stringProp>
       <stringProp name="HTTPSampler.response_timeout"/>
       <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
       <stringProp name="HTTPSampler.contentEncoding"/>
-      <stringProp name="HTTPSampler.path">${base_path}sales/order/history/</stringProp>
-      <stringProp name="HTTPSampler.method">GET</stringProp>
+      <stringProp name="HTTPSampler.path">${base_path}rest/default/V1/products/${simple_product_sku}/stockItems/${simple_stock_item_id}</stringProp>
+      <stringProp name="HTTPSampler.method">PUT</stringProp>
       <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
       <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
       <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
       <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
       <boolProp name="HTTPSampler.monitor">false</boolProp>
       <stringProp name="HTTPSampler.embedded_url_re"/>
-    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/account_management/my_orders.jmx</stringProp></HTTPSamplerProxy>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/api/update_product_stock_info.jmx</stringProp></HTTPSamplerProxy>
     <hashTree>
-      <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Response Assertion" enabled="true">
-        <collectionProp name="Asserion.test_strings">
-          <stringProp name="220295440">&lt;title&gt;My Orders&lt;/title&gt;</stringProp>
-        </collectionProp>
-        <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
-        <boolProp name="Assertion.assume_success">false</boolProp>
-        <intProp name="Assertion.test_type">2</intProp>
-      </ResponseAssertion>
-      <hashTree/>
-      <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract orderId" enabled="true">
-        <stringProp name="RegexExtractor.useHeaders">false</stringProp>
-        <stringProp name="RegexExtractor.refname">orderId</stringProp>
-        <stringProp name="RegexExtractor.regex">sales/order/view/order_id/(\d+)/</stringProp>
-        <stringProp name="RegexExtractor.template">$1$</stringProp>
-        <stringProp name="RegexExtractor.default">NOT_FOUND</stringProp>
-        <stringProp name="RegexExtractor.match_number">1</stringProp>
-      </RegexExtractor>
+      <com.atlantbh.jmeter.plugins.jsonutils.jsonpathassertion.JSONPathAssertion guiclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathassertion.gui.JSONPathAssertionGui" testclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathassertion.JSONPathAssertion" testname="jp@gc - JSON Path Assertion" enabled="true">
+        <stringProp name="JSON_PATH">$</stringProp>
+        <stringProp name="EXPECTED_VALUE">${simple_stock_item_id}</stringProp>
+        <boolProp name="JSONVALIDATION">true</boolProp>
+        <boolProp name="EXPECT_NULL">false</boolProp>
+        <boolProp name="INVERT">false</boolProp>
+      </com.atlantbh.jmeter.plugins.jsonutils.jsonpathassertion.JSONPathAssertion>
       <hashTree/>
     </hashTree>
   
-    <IfController guiclass="IfControllerPanel" testclass="IfController" testname="If Orders Controller" enabled="true">
-      <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/account_management/if_orders.jmx</stringProp>
-      <stringProp name="IfController.condition">"${orderId}" != "NOT_FOUND"</stringProp>
-      <boolProp name="IfController.evaluateAll">false</boolProp>
-    </IfController>
-    <hashTree>
-      <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="View Order" enabled="true">
-        <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
-          <collectionProp name="Arguments.arguments"/>
-        </elementProp>
-        <stringProp name="HTTPSampler.domain"/>
-        <stringProp name="HTTPSampler.port"/>
-        <stringProp name="HTTPSampler.connect_timeout"/>
-        <stringProp name="HTTPSampler.response_timeout"/>
-        <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
-        <stringProp name="HTTPSampler.contentEncoding"/>
-        <stringProp name="HTTPSampler.path">${base_path}sales/order/view/order_id/${orderId}</stringProp>
-        <stringProp name="HTTPSampler.method">GET</stringProp>
-        <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
-        <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
-        <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
-        <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
-        <boolProp name="HTTPSampler.monitor">false</boolProp>
-        <stringProp name="HTTPSampler.embedded_url_re"/>
-      </HTTPSamplerProxy>
-      <hashTree>
-        <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Response Assertion" enabled="true">
-          <collectionProp name="Asserion.test_strings">
-            <stringProp name="1956770127">&lt;title&gt;Order #</stringProp>
-          </collectionProp>
-          <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
-          <boolProp name="Assertion.assume_success">false</boolProp>
-          <intProp name="Assertion.test_type">2</intProp>
-        </ResponseAssertion>
-        <hashTree/>
-        <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract shipment tab" enabled="true">
-          <stringProp name="RegexExtractor.useHeaders">false</stringProp>
-          <stringProp name="RegexExtractor.refname">shipment_tab</stringProp>
-          <stringProp name="RegexExtractor.regex">sales/order/shipment/order_id/(\d+)..Order Shipments</stringProp>
-          <stringProp name="RegexExtractor.template">$1$</stringProp>
-          <stringProp name="RegexExtractor.default">NOT_FOUND</stringProp>
-          <stringProp name="RegexExtractor.match_number">1</stringProp>
-        </RegexExtractor>
-        <hashTree/>
-      </hashTree>
-      <IfController guiclass="IfControllerPanel" testclass="IfController" testname="If Shipments Controller" enabled="true">
-        <stringProp name="TestPlan.comments">May not have shipped</stringProp>
-        <stringProp name="IfController.condition">"${shipment_tab}" != "NOT_FOUND"</stringProp>
-        <boolProp name="IfController.evaluateAll">false</boolProp>
-      </IfController>
-      <hashTree>
-        <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="View Order Shipments" enabled="true">
-          <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
-            <collectionProp name="Arguments.arguments"/>
-          </elementProp>
-          <stringProp name="HTTPSampler.domain"/>
-          <stringProp name="HTTPSampler.port"/>
-          <stringProp name="HTTPSampler.connect_timeout"/>
-          <stringProp name="HTTPSampler.response_timeout"/>
-          <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
-          <stringProp name="HTTPSampler.contentEncoding"/>
-          <stringProp name="HTTPSampler.path">${base_path}sales/order/shipment/order_id/${orderId}</stringProp>
-          <stringProp name="HTTPSampler.method">GET</stringProp>
-          <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
-          <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
-          <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
-          <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
-          <boolProp name="HTTPSampler.monitor">false</boolProp>
-          <stringProp name="HTTPSampler.embedded_url_re"/>
-        </HTTPSamplerProxy>
-        <hashTree>
-          <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Response Assertion" enabled="true">
-            <collectionProp name="Asserion.test_strings">
-              <stringProp name="120578727">Track this shipment</stringProp>
-            </collectionProp>
-            <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
-            <boolProp name="Assertion.assume_success">false</boolProp>
-            <intProp name="Assertion.test_type">2</intProp>
-          </ResponseAssertion>
-          <hashTree/>
-          <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract popup link" enabled="true">
-            <stringProp name="RegexExtractor.useHeaders">false</stringProp>
-            <stringProp name="RegexExtractor.refname">popupLink</stringProp>
-            <stringProp name="RegexExtractor.regex">popupWindow": {"windowURL":"([^'"]+)",</stringProp>
-            <stringProp name="RegexExtractor.template">$1$</stringProp>
-            <stringProp name="RegexExtractor.default"/>
-            <stringProp name="RegexExtractor.match_number">1</stringProp>
-          </RegexExtractor>
-          <hashTree/>
-        </hashTree>
-        <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Track Shipment" enabled="true">
-          <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
-            <collectionProp name="Arguments.arguments"/>
+    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Check product" enabled="true">
+      <boolProp name="HTTPSampler.postBodyRaw">true</boolProp>
+      <elementProp name="HTTPsampler.Arguments" elementType="Arguments">
+        <collectionProp name="Arguments.arguments">
+          <elementProp name="" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value"/>
+            <stringProp name="Argument.metadata">=</stringProp>
           </elementProp>
-          <stringProp name="HTTPSampler.domain"/>
-          <stringProp name="HTTPSampler.port"/>
-          <stringProp name="HTTPSampler.connect_timeout"/>
-          <stringProp name="HTTPSampler.response_timeout"/>
-          <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
-          <stringProp name="HTTPSampler.contentEncoding"/>
-          <stringProp name="HTTPSampler.path">${popupLink}</stringProp>
-          <stringProp name="HTTPSampler.method">GET</stringProp>
-          <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
-          <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
-          <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
-          <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
-          <boolProp name="HTTPSampler.monitor">false</boolProp>
-          <stringProp name="HTTPSampler.embedded_url_re"/>
-        </HTTPSamplerProxy>
-        <hashTree>
-          <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Response Assertion" enabled="true">
-            <collectionProp name="Asserion.test_strings">
-              <stringProp name="-760430210">&lt;title&gt;Tracking Information&lt;/title&gt;</stringProp>
-            </collectionProp>
-            <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
-            <boolProp name="Assertion.assume_success">false</boolProp>
-            <intProp name="Assertion.test_type">2</intProp>
-          </ResponseAssertion>
-          <hashTree/>
-        </hashTree>
-      </hashTree>
-    </hashTree>
-  
-    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="My Downloadable Products" enabled="true">
-      <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
-        <collectionProp name="Arguments.arguments"/>
+        </collectionProp>
       </elementProp>
       <stringProp name="HTTPSampler.domain"/>
       <stringProp name="HTTPSampler.port"/>
@@ -28892,7 +20110,7 @@ vars.put("customer_email", emails_list.get(emails_index));</stringProp>
       <stringProp name="HTTPSampler.response_timeout"/>
       <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
       <stringProp name="HTTPSampler.contentEncoding"/>
-      <stringProp name="HTTPSampler.path">${base_path}downloadable/customer/products</stringProp>
+      <stringProp name="HTTPSampler.path">${base_path}rest/default/V1/products/${simple_product_sku}</stringProp>
       <stringProp name="HTTPSampler.method">GET</stringProp>
       <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
       <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
@@ -28900,46 +20118,94 @@ vars.put("customer_email", emails_list.get(emails_index));</stringProp>
       <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
       <boolProp name="HTTPSampler.monitor">false</boolProp>
       <stringProp name="HTTPSampler.embedded_url_re"/>
-    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/account_management/my_downloadable_products.jmx</stringProp></HTTPSamplerProxy>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/api/check_product.jmx</stringProp></HTTPSamplerProxy>
     <hashTree>
-      <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Response Assertion" enabled="true">
-        <collectionProp name="Asserion.test_strings">
-          <stringProp name="358050505">&lt;title&gt;My Downloadable Products&lt;/title&gt;</stringProp>
-        </collectionProp>
-        <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
-        <boolProp name="Assertion.assume_success">false</boolProp>
-        <intProp name="Assertion.test_type">2</intProp>
-      </ResponseAssertion>
+      <com.atlantbh.jmeter.plugins.jsonutils.jsonpathassertion.JSONPathAssertion guiclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathassertion.gui.JSONPathAssertionGui" testclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathassertion.JSONPathAssertion" testname="Assert product sku" enabled="true">
+        <stringProp name="JSON_PATH">$.sku</stringProp>
+        <stringProp name="EXPECTED_VALUE">${simple_product_sku}</stringProp>
+        <boolProp name="JSONVALIDATION">true</boolProp>
+        <boolProp name="EXPECT_NULL">false</boolProp>
+        <boolProp name="INVERT">false</boolProp>
+      </com.atlantbh.jmeter.plugins.jsonutils.jsonpathassertion.JSONPathAssertion>
       <hashTree/>
-      <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract orderId" enabled="true">
-        <stringProp name="RegexExtractor.useHeaders">false</stringProp>
-        <stringProp name="RegexExtractor.refname">orderId</stringProp>
-        <stringProp name="RegexExtractor.regex">sales/order/view/order_id/(\d+)/</stringProp>
-        <stringProp name="RegexExtractor.template">$1$</stringProp>
-        <stringProp name="RegexExtractor.default">NOT_FOUND</stringProp>
-        <stringProp name="RegexExtractor.match_number">1</stringProp>
-      </RegexExtractor>
+      <com.atlantbh.jmeter.plugins.jsonutils.jsonpathassertion.JSONPathAssertion guiclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathassertion.gui.JSONPathAssertionGui" testclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathassertion.JSONPathAssertion" testname="Assert product id" enabled="true">
+        <stringProp name="JSON_PATH">$.id</stringProp>
+        <stringProp name="EXPECTED_VALUE">${simple_product_id}</stringProp>
+        <boolProp name="JSONVALIDATION">true</boolProp>
+        <boolProp name="EXPECT_NULL">false</boolProp>
+        <boolProp name="INVERT">false</boolProp>
+      </com.atlantbh.jmeter.plugins.jsonutils.jsonpathassertion.JSONPathAssertion>
       <hashTree/>
-      <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract linkId" enabled="true">
-        <stringProp name="RegexExtractor.useHeaders">false</stringProp>
-        <stringProp name="RegexExtractor.refname">linkId</stringProp>
-        <stringProp name="RegexExtractor.regex">downloadable/download/link/id/(\d+)/</stringProp>
-        <stringProp name="RegexExtractor.template">$1$</stringProp>
-        <stringProp name="RegexExtractor.default"/>
-        <stringProp name="RegexExtractor.match_number">1</stringProp>
-      </RegexExtractor>
+      <com.atlantbh.jmeter.plugins.jsonutils.jsonpathassertion.JSONPathAssertion guiclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathassertion.gui.JSONPathAssertionGui" testclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathassertion.JSONPathAssertion" testname="Assert stock item id" enabled="true">
+        <stringProp name="JSON_PATH">$.extension_attributes.stock_item.item_id</stringProp>
+        <stringProp name="EXPECTED_VALUE">${simple_stock_item_id}</stringProp>
+        <boolProp name="JSONVALIDATION">true</boolProp>
+        <boolProp name="EXPECT_NULL">false</boolProp>
+        <boolProp name="INVERT">false</boolProp>
+      </com.atlantbh.jmeter.plugins.jsonutils.jsonpathassertion.JSONPathAssertion>
+      <hashTree/>
+      <com.atlantbh.jmeter.plugins.jsonutils.jsonpathassertion.JSONPathAssertion guiclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathassertion.gui.JSONPathAssertionGui" testclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathassertion.JSONPathAssertion" testname="Assert updated quantity" enabled="true">
+        <stringProp name="JSON_PATH">$.extension_attributes.stock_item.qty</stringProp>
+        <stringProp name="EXPECTED_VALUE">${simple_product_id}</stringProp>
+        <boolProp name="JSONVALIDATION">true</boolProp>
+        <boolProp name="EXPECT_NULL">false</boolProp>
+        <boolProp name="INVERT">false</boolProp>
+      </com.atlantbh.jmeter.plugins.jsonutils.jsonpathassertion.JSONPathAssertion>
       <hashTree/>
     </hashTree>
   
-    <IfController guiclass="IfControllerPanel" testclass="IfController" testname="If Downloadables Controller" enabled="true">
-      <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/account_management/if_downloadables.jmx</stringProp>
-      <stringProp name="IfController.condition">"${orderId}" != "NOT_FOUND"</stringProp>
-      <boolProp name="IfController.evaluateAll">false</boolProp>
-    </IfController>
-    <hashTree>
-    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="View Downloadable Product" enabled="true">
-      <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
-        <collectionProp name="Arguments.arguments"/>
+    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Create product with extensible data objects" enabled="true">
+      <boolProp name="HTTPSampler.postBodyRaw">true</boolProp>
+      <elementProp name="HTTPsampler.Arguments" elementType="Arguments">
+        <collectionProp name="Arguments.arguments">
+          <elementProp name="" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">false</boolProp>
+            <stringProp name="Argument.value">{&#xD;
+    "product": {&#xD;
+        "sku": "apsku-test-${__time()}-${__threadNum}-${__Random(1,1000000)}",&#xD;
+        "name": "Extensible_Product_${__time()}-${__threadNum}-${__Random(1,1000000)}",&#xD;
+        "visibility": "4",&#xD;
+        "type_id": "simple",&#xD;
+        "price": "3.62",&#xD;
+        "status": "1",&#xD;
+        "attribute_set_id": "4",&#xD;
+        "custom_attributes": [&#xD;
+            {&#xD;
+                "attribute_code": "cost",&#xD;
+                "value": ""&#xD;
+            },&#xD;
+            {&#xD;
+                "attribute_code": "description",&#xD;
+                "value": "Description"&#xD;
+            }&#xD;
+        ],&#xD;
+        "extension_attributes":{&#xD;
+		"stock_item":{&#xD;
+		"manage_stock": true,    &#xD;
+		"is_in_stock": true,&#xD;
+		"qty":"100"&#xD;
+		}&#xD;
+    	   }        ,&#xD;
+    	   "media_gallery_entries":&#xD;
+    	   	[{&#xD;
+    	   		"id": null,&#xD;
+    	   		"label":"test_label_${__time()}-${__threadNum}-${__Random(1,1000000)}",&#xD;
+    	   		"position":1,&#xD;
+    	   		"disabled":false,&#xD;
+    	   		"media_type":"image",&#xD;
+    	   		"types":["image"],&#xD;
+    	   		"content":{&#xD;
+    	   			"base64_encoded_data": "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",&#xD;
+        "type": "image/jpeg",&#xD;
+        "name": "test_image_${__time(YMDHMS)}-${__threadNum}-${__Random(1,1000000)}.jpeg"&#xD;
+    	   			}&#xD;
+    	   	}&#xD;
+    	   	]&#xD;
+    }&#xD;
+}</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+          </elementProp>
+        </collectionProp>
       </elementProp>
       <stringProp name="HTTPSampler.domain"/>
       <stringProp name="HTTPSampler.port"/>
@@ -28947,30 +20213,85 @@ vars.put("customer_email", emails_list.get(emails_index));</stringProp>
       <stringProp name="HTTPSampler.response_timeout"/>
       <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
       <stringProp name="HTTPSampler.contentEncoding"/>
-      <stringProp name="HTTPSampler.path">${base_path}sales/order/view/order_id/${orderId}</stringProp>
-      <stringProp name="HTTPSampler.method">GET</stringProp>
+      <stringProp name="HTTPSampler.path">${base_path}rest/default/V1/products</stringProp>
+      <stringProp name="HTTPSampler.method">POST</stringProp>
       <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
       <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
       <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
       <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
       <boolProp name="HTTPSampler.monitor">false</boolProp>
       <stringProp name="HTTPSampler.embedded_url_re"/>
-    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/account_management/view_downloadable_products.jmx</stringProp></HTTPSamplerProxy>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/api/create_product_with_extensible_data_objects.jmx</stringProp></HTTPSamplerProxy>
     <hashTree>
-      <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Response Assertion" enabled="true">
+      <com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor guiclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.gui.JSONPathExtractorGui" testclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor" testname="Extract product id" enabled="true">
+        <stringProp name="VAR">simple_product_id</stringProp>
+        <stringProp name="JSONPATH">$.id</stringProp>
+        <stringProp name="DEFAULT"/>
+        <stringProp name="VARIABLE"/>
+        <stringProp name="SUBJECT">BODY</stringProp>
+      </com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor>
+      <hashTree/>
+      <com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor guiclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.gui.JSONPathExtractorGui" testclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor" testname="Extract product sku" enabled="true">
+        <stringProp name="VAR">simple_product_sku</stringProp>
+        <stringProp name="JSONPATH">$.sku</stringProp>
+        <stringProp name="DEFAULT"/>
+        <stringProp name="VARIABLE"/>
+        <stringProp name="SUBJECT">BODY</stringProp>
+      </com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor>
+      <hashTree/>
+      <com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor guiclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.gui.JSONPathExtractorGui" testclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor" testname="Extract stock item id" enabled="true">
+        <stringProp name="VAR">simple_stock_item_id</stringProp>
+        <stringProp name="JSONPATH">$.extension_attributes.stock_item.item_id</stringProp>
+        <stringProp name="DEFAULT"/>
+        <stringProp name="VARIABLE"/>
+        <stringProp name="SUBJECT">BODY</stringProp>
+      </com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor>
+      <hashTree/>
+      <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert product id not null" enabled="true">
         <collectionProp name="Asserion.test_strings">
-          <stringProp name="1956770127">&lt;title&gt;Order #</stringProp>
+          <stringProp name="89649215">^\d+$</stringProp>
         </collectionProp>
         <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
         <boolProp name="Assertion.assume_success">false</boolProp>
-        <intProp name="Assertion.test_type">2</intProp>
+        <intProp name="Assertion.test_type">1</intProp>
+        <stringProp name="Assertion.scope">variable</stringProp>
+        <stringProp name="Scope.variable">simple_product_id</stringProp>
+      </ResponseAssertion>
+      <hashTree/>
+      <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert product sku not null" enabled="true">
+        <collectionProp name="Asserion.test_strings">
+          <stringProp name="484395188">^[a-z0-9-]+$</stringProp>
+        </collectionProp>
+        <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
+        <boolProp name="Assertion.assume_success">false</boolProp>
+        <intProp name="Assertion.test_type">1</intProp>
+        <stringProp name="Assertion.scope">variable</stringProp>
+        <stringProp name="Scope.variable">simple_product_sku</stringProp>
+      </ResponseAssertion>
+      <hashTree/>
+      <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert stock item id not null" enabled="true">
+        <collectionProp name="Asserion.test_strings">
+          <stringProp name="89649215">^\d+$</stringProp>
+        </collectionProp>
+        <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
+        <boolProp name="Assertion.assume_success">false</boolProp>
+        <intProp name="Assertion.test_type">1</intProp>
+        <stringProp name="Assertion.scope">variable</stringProp>
+        <stringProp name="Scope.variable">simple_stock_item_id</stringProp>
       </ResponseAssertion>
       <hashTree/>
     </hashTree>
   
-    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Download Product" enabled="true">
-      <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
-        <collectionProp name="Arguments.arguments"/>
+    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Check product with extensible data objects" enabled="true">
+      <boolProp name="HTTPSampler.postBodyRaw">true</boolProp>
+      <elementProp name="HTTPsampler.Arguments" elementType="Arguments">
+        <collectionProp name="Arguments.arguments">
+          <elementProp name="" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value"/>
+            <stringProp name="Argument.metadata">=</stringProp>
+          </elementProp>
+        </collectionProp>
       </elementProp>
       <stringProp name="HTTPSampler.domain"/>
       <stringProp name="HTTPSampler.port"/>
@@ -28978,7 +20299,7 @@ vars.put("customer_email", emails_list.get(emails_index));</stringProp>
       <stringProp name="HTTPSampler.response_timeout"/>
       <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
       <stringProp name="HTTPSampler.contentEncoding"/>
-      <stringProp name="HTTPSampler.path">${base_path}downloadable/download/link/id/${linkId}</stringProp>
+      <stringProp name="HTTPSampler.path">${base_path}rest/default/V1/products/${simple_product_sku}</stringProp>
       <stringProp name="HTTPSampler.method">GET</stringProp>
       <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
       <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
@@ -28986,13 +20307,91 @@ vars.put("customer_email", emails_list.get(emails_index));</stringProp>
       <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
       <boolProp name="HTTPSampler.monitor">false</boolProp>
       <stringProp name="HTTPSampler.embedded_url_re"/>
-    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/account_management/download_product.jmx</stringProp></HTTPSamplerProxy>
-    <hashTree/>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/api/check_product_with_extensible_data_objects.jmx</stringProp></HTTPSamplerProxy>
+    <hashTree>
+      <com.atlantbh.jmeter.plugins.jsonutils.jsonpathassertion.JSONPathAssertion guiclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathassertion.gui.JSONPathAssertionGui" testclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathassertion.JSONPathAssertion" testname="Assert product sku" enabled="true">
+        <stringProp name="JSON_PATH">$.sku</stringProp>
+        <stringProp name="EXPECTED_VALUE">${simple_product_sku}</stringProp>
+        <boolProp name="JSONVALIDATION">true</boolProp>
+        <boolProp name="EXPECT_NULL">false</boolProp>
+        <boolProp name="INVERT">false</boolProp>
+      </com.atlantbh.jmeter.plugins.jsonutils.jsonpathassertion.JSONPathAssertion>
+      <hashTree/>
+      <com.atlantbh.jmeter.plugins.jsonutils.jsonpathassertion.JSONPathAssertion guiclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathassertion.gui.JSONPathAssertionGui" testclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathassertion.JSONPathAssertion" testname="Assert product id" enabled="true">
+        <stringProp name="JSON_PATH">$.id</stringProp>
+        <stringProp name="EXPECTED_VALUE">${simple_product_id}</stringProp>
+        <boolProp name="JSONVALIDATION">true</boolProp>
+        <boolProp name="EXPECT_NULL">false</boolProp>
+        <boolProp name="INVERT">false</boolProp>
+      </com.atlantbh.jmeter.plugins.jsonutils.jsonpathassertion.JSONPathAssertion>
+      <hashTree/>
+      <com.atlantbh.jmeter.plugins.jsonutils.jsonpathassertion.JSONPathAssertion guiclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathassertion.gui.JSONPathAssertionGui" testclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathassertion.JSONPathAssertion" testname="Assert stock item id" enabled="true">
+        <stringProp name="JSON_PATH">$.extension_attributes.stock_item.item_id</stringProp>
+        <stringProp name="EXPECTED_VALUE">${simple_stock_item_id}</stringProp>
+        <boolProp name="JSONVALIDATION">true</boolProp>
+        <boolProp name="EXPECT_NULL">false</boolProp>
+        <boolProp name="INVERT">false</boolProp>
+      </com.atlantbh.jmeter.plugins.jsonutils.jsonpathassertion.JSONPathAssertion>
+      <hashTree/>
+      <com.atlantbh.jmeter.plugins.jsonutils.jsonpathassertion.JSONPathAssertion guiclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathassertion.gui.JSONPathAssertionGui" testclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathassertion.JSONPathAssertion" testname="Assert updated quantity" enabled="true">
+        <stringProp name="JSON_PATH">$.extension_attributes.stock_item.qty</stringProp>
+        <stringProp name="EXPECTED_VALUE">100</stringProp>
+        <boolProp name="JSONVALIDATION">true</boolProp>
+        <boolProp name="EXPECT_NULL">false</boolProp>
+        <boolProp name="INVERT">false</boolProp>
+      </com.atlantbh.jmeter.plugins.jsonutils.jsonpathassertion.JSONPathAssertion>
+      <hashTree/>
+    </hashTree>
   </hashTree>
+
   
-    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="My Wish List" enabled="true">
-      <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
-        <collectionProp name="Arguments.arguments"/>
+    <ThroughputController guiclass="ThroughputControllerGui" testclass="ThroughputController" testname="API Product Attribute Management" enabled="true">
+      <intProp name="ThroughputController.style">1</intProp>
+      <boolProp name="ThroughputController.perThread">false</boolProp>
+      <intProp name="ThroughputController.maxThroughput">1</intProp>
+      <stringProp name="ThroughputController.percentThroughput">100</stringProp>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/_system/scenario_controller_tmpl.jmx</stringProp></ThroughputController>
+    <hashTree>
+        <JSR223PreProcessor guiclass="TestBeanGUI" testclass="JSR223PreProcessor" testname="Set Test Label" enabled="true">
+            <stringProp name="script">
+var testLabel = "${testLabel}" ? " (${testLabel})" : "";
+if (testLabel
+    &amp;&amp; sampler.getClass().getName() == 'org.apache.jmeter.protocol.http.sampler.HTTPSamplerProxy'
+) {
+    if (sampler.getName().indexOf(testLabel) == -1) {
+       sampler.setName(sampler.getName() + testLabel);
+    }
+} else if (sampler.getName().indexOf("SetUp - ") == -1) {
+    sampler.setName("SetUp - " + sampler.getName());
+}
+            </stringProp>
+            <stringProp name="scriptLanguage">javascript</stringProp>
+        <stringProp name="TestPlan.comments">mpaf/tool/fragments/_system/setup_label.jmx</stringProp></JSR223PreProcessor>
+        <hashTree/>
+        <BeanShellSampler guiclass="BeanShellSamplerGui" testclass="BeanShellSampler" testname="SetUp - Set Label" enabled="true">
+            <stringProp name="BeanShellSampler.query">
+                vars.put("testLabel", "API Product Attribute Management");
+            </stringProp>
+            <boolProp name="BeanShellSampler.resetInterpreter">true</boolProp>
+        </BeanShellSampler>
+        <hashTree/>
+    
+    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Create attribute set" enabled="true">
+      <boolProp name="HTTPSampler.postBodyRaw">true</boolProp>
+      <elementProp name="HTTPsampler.Arguments" elementType="Arguments">
+        <collectionProp name="Arguments.arguments">
+          <elementProp name="" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">false</boolProp>
+            <stringProp name="Argument.value">{&#xD;
+    "attributeSet": {&#xD;
+        "attribute_set_name": "new_attribute_set_${__time()}-${__threadNum}-${__Random(1,1000000)}",&#xD;
+        "sort_order": 500&#xD;
+    },&#xD;
+    "skeletonId": "4"&#xD;
+}</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+          </elementProp>
+        </collectionProp>
       </elementProp>
       <stringProp name="HTTPSampler.domain"/>
       <stringProp name="HTTPSampler.port"/>
@@ -29000,55 +20399,52 @@ vars.put("customer_email", emails_list.get(emails_index));</stringProp>
       <stringProp name="HTTPSampler.response_timeout"/>
       <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
       <stringProp name="HTTPSampler.contentEncoding"/>
-      <stringProp name="HTTPSampler.path">${base_path}wishlist</stringProp>
-      <stringProp name="HTTPSampler.method">GET</stringProp>
+      <stringProp name="HTTPSampler.path">${base_path}rest/default/V1/products/attribute-sets/</stringProp>
+      <stringProp name="HTTPSampler.method">POST</stringProp>
       <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
       <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
       <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
       <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
       <boolProp name="HTTPSampler.monitor">false</boolProp>
       <stringProp name="HTTPSampler.embedded_url_re"/>
-    </HTTPSamplerProxy>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/api/create_attribute_set.jmx</stringProp></HTTPSamplerProxy>
     <hashTree>
-      <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Response Assertion" enabled="true">
+      <com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor guiclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.gui.JSONPathExtractorGui" testclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor" testname="Extract attribute_set_id" enabled="true">
+        <stringProp name="VAR">attribute_set_id</stringProp>
+        <stringProp name="JSONPATH">$.attribute_set_id</stringProp>
+        <stringProp name="DEFAULT"/>
+        <stringProp name="VARIABLE"/>
+        <stringProp name="SUBJECT">BODY</stringProp>
+      </com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor>
+      <hashTree/>
+      <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert attribute_set_id not null" enabled="true">
         <collectionProp name="Asserion.test_strings">
-          <stringProp name="-1907714722">&lt;title&gt;My Wish List&lt;/title&gt;</stringProp>
+          <stringProp name="89649215">^\d+$</stringProp>
         </collectionProp>
         <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
         <boolProp name="Assertion.assume_success">false</boolProp>
-        <intProp name="Assertion.test_type">2</intProp>
+        <intProp name="Assertion.test_type">1</intProp>
+        <stringProp name="Assertion.scope">variable</stringProp>
+        <stringProp name="Scope.variable">attribute_set_id</stringProp>
       </ResponseAssertion>
       <hashTree/>
-      <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract wishlistId" enabled="true">
-        <stringProp name="RegexExtractor.useHeaders">false</stringProp>
-        <stringProp name="RegexExtractor.refname">wishlistId</stringProp>
-        <stringProp name="RegexExtractor.regex">wishlist/index/update/wishlist_id/([^'"]+)/</stringProp>
-        <stringProp name="RegexExtractor.template">$1$</stringProp>
-        <stringProp name="RegexExtractor.default"/>
-        <stringProp name="RegexExtractor.match_number">1</stringProp>
-        <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/account_management/my_wish_list.jmx</stringProp>
-      </RegexExtractor>
-      <hashTree/>
-      <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Verify that there are items in the wishlist" enabled="true">
-        <stringProp name="RegexExtractor.useHeaders">false</stringProp>
-        <stringProp name="RegexExtractor.refname">buttonTitle</stringProp>
-        <stringProp name="RegexExtractor.regex">Update Wish List</stringProp>
-        <stringProp name="RegexExtractor.template">FOUND</stringProp>
-        <stringProp name="RegexExtractor.default">NOT_FOUND</stringProp>
-        <stringProp name="RegexExtractor.match_number">1</stringProp>
-      </RegexExtractor>
-      <hashTree/>
     </hashTree>
   
-    <IfController guiclass="IfControllerPanel" testclass="IfController" testname="If Wish List Controller" enabled="true">
-      <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/account_management/if_wishlist.jmx</stringProp>
-      <stringProp name="IfController.condition">"${buttonTitle}" === "FOUND"</stringProp>
-      <boolProp name="IfController.evaluateAll">false</boolProp>
-    </IfController>
-    <hashTree>
-    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Share Wish List" enabled="true">
-      <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
-        <collectionProp name="Arguments.arguments"/>
+    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Create attribute group" enabled="true">
+      <boolProp name="HTTPSampler.postBodyRaw">true</boolProp>
+      <elementProp name="HTTPsampler.Arguments" elementType="Arguments">
+        <collectionProp name="Arguments.arguments">
+          <elementProp name="" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">false</boolProp>
+            <stringProp name="Argument.value">{&#xD;
+    "group": {&#xD;
+        "attribute_group_name": "empty_attribute_group_${__time()}-${__threadNum}-${__Random(1,1000000)}",&#xD;
+        "attribute_set_id": ${attribute_set_id}&#xD;
+    }&#xD;
+}</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+          </elementProp>
+        </collectionProp>
       </elementProp>
       <stringProp name="HTTPSampler.domain"/>
       <stringProp name="HTTPSampler.port"/>
@@ -29056,51 +20452,58 @@ vars.put("customer_email", emails_list.get(emails_index));</stringProp>
       <stringProp name="HTTPSampler.response_timeout"/>
       <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
       <stringProp name="HTTPSampler.contentEncoding"/>
-      <stringProp name="HTTPSampler.path">${base_path}wishlist/index/share/wishlist_id/${wishlistId}/</stringProp>
-      <stringProp name="HTTPSampler.method">GET</stringProp>
+      <stringProp name="HTTPSampler.path">${base_path}rest/default/V1/products/attribute-sets/groups</stringProp>
+      <stringProp name="HTTPSampler.method">POST</stringProp>
       <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
       <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
       <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
       <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
       <boolProp name="HTTPSampler.monitor">false</boolProp>
       <stringProp name="HTTPSampler.embedded_url_re"/>
-    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/account_management/share_wish_list.jmx</stringProp></HTTPSamplerProxy>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/api/create_attribute_group.jmx</stringProp></HTTPSamplerProxy>
     <hashTree>
-      <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Response Assertion" enabled="true">
+      <com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor guiclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.gui.JSONPathExtractorGui" testclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor" testname="Extract attribute_group_id" enabled="true">
+        <stringProp name="VAR">attribute_group_id</stringProp>
+        <stringProp name="JSONPATH">$.attribute_group_id</stringProp>
+        <stringProp name="DEFAULT"/>
+        <stringProp name="VARIABLE"/>
+        <stringProp name="SUBJECT">BODY</stringProp>
+      </com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor>
+      <hashTree/>
+      <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert attribute_group_id not null" enabled="true">
         <collectionProp name="Asserion.test_strings">
-          <stringProp name="1257102154">&lt;title&gt;Wish List Sharing&lt;/title&gt;</stringProp>
+          <stringProp name="89649215">^\d+$</stringProp>
         </collectionProp>
         <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
         <boolProp name="Assertion.assume_success">false</boolProp>
-        <intProp name="Assertion.test_type">2</intProp>
+        <intProp name="Assertion.test_type">1</intProp>
+        <stringProp name="Assertion.scope">variable</stringProp>
+        <stringProp name="Scope.variable">attribute_set_id</stringProp>
       </ResponseAssertion>
       <hashTree/>
     </hashTree>
   
-    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Send Wish List" enabled="true">
-      <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
+    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Create attribute" enabled="true">
+      <boolProp name="HTTPSampler.postBodyRaw">true</boolProp>
+      <elementProp name="HTTPsampler.Arguments" elementType="Arguments">
         <collectionProp name="Arguments.arguments">
-          <elementProp name="form_key" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">${form_key}</stringProp>
-            <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">form_key</stringProp>
-            <stringProp name="Argument.desc">true</stringProp>
-          </elementProp>
-          <elementProp name="emails" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">${customer_email}</stringProp>
-            <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">emails</stringProp>
-          </elementProp>
-          <elementProp name="message" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">[TEST] See my wishlist!!!</stringProp>
+          <elementProp name="" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">false</boolProp>
+            <stringProp name="Argument.value">{&#xD;
+    "attribute": {&#xD;
+        "attribute_code": "attr_code_${__time()}",&#xD;
+        "frontend_labels": [&#xD;
+            {&#xD;
+                "store_id": 0,&#xD;
+                "label": "front_lbl_${__time(YMDHMS)}-${__threadNum}-${__Random(1,1000000)}"&#xD;
+            }&#xD;
+        ],&#xD;
+        "default_value": "default value",&#xD;
+        "frontend_input": "textarea",&#xD;
+        "is_required": true&#xD;
+    }&#xD;
+}</stringProp>
             <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">message</stringProp>
           </elementProp>
         </collectionProp>
       </elementProp>
@@ -29110,7 +20513,7 @@ vars.put("customer_email", emails_list.get(emails_index));</stringProp>
       <stringProp name="HTTPSampler.response_timeout"/>
       <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
       <stringProp name="HTTPSampler.contentEncoding"/>
-      <stringProp name="HTTPSampler.path">${base_path}wishlist/index/send/wishlist_id/${wishlistId}/</stringProp>
+      <stringProp name="HTTPSampler.path">${base_path}rest/default/V1/products/attributes/</stringProp>
       <stringProp name="HTTPSampler.method">POST</stringProp>
       <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
       <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
@@ -29118,23 +20521,63 @@ vars.put("customer_email", emails_list.get(emails_index));</stringProp>
       <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
       <boolProp name="HTTPSampler.monitor">false</boolProp>
       <stringProp name="HTTPSampler.embedded_url_re"/>
-    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/account_management/send_wish_list.jmx</stringProp></HTTPSamplerProxy>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/api/create_attribute.jmx</stringProp></HTTPSamplerProxy>
     <hashTree>
-      <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Response Assertion" enabled="true">
+      <com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor guiclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.gui.JSONPathExtractorGui" testclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor" testname="Extract attribute_id" enabled="true">
+        <stringProp name="VAR">attribute_id</stringProp>
+        <stringProp name="JSONPATH">$.attribute_id</stringProp>
+        <stringProp name="DEFAULT"/>
+        <stringProp name="VARIABLE"/>
+        <stringProp name="SUBJECT">BODY</stringProp>
+      </com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor>
+      <hashTree/>
+      <com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor guiclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.gui.JSONPathExtractorGui" testclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor" testname="Extract attribute_code" enabled="true">
+        <stringProp name="VAR">attribute_code</stringProp>
+        <stringProp name="JSONPATH">$.attribute_code</stringProp>
+        <stringProp name="DEFAULT"/>
+        <stringProp name="VARIABLE"/>
+        <stringProp name="SUBJECT">BODY</stringProp>
+      </com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor>
+      <hashTree/>
+      <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert attribute_id not null" enabled="true">
         <collectionProp name="Asserion.test_strings">
-          <stringProp name="-1907714722">&lt;title&gt;My Wish List&lt;/title&gt;</stringProp>
+          <stringProp name="89649215">^\d+$</stringProp>
         </collectionProp>
         <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
         <boolProp name="Assertion.assume_success">false</boolProp>
-        <intProp name="Assertion.test_type">2</intProp>
+        <intProp name="Assertion.test_type">1</intProp>
+        <stringProp name="Assertion.scope">variable</stringProp>
+        <stringProp name="Scope.variable">attribute_id</stringProp>
+      </ResponseAssertion>
+      <hashTree/>
+      <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert attribute_code not null" enabled="true">
+        <collectionProp name="Asserion.test_strings">
+          <stringProp name="2131456825">^[a-z0-9-_]+$</stringProp>
+        </collectionProp>
+        <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
+        <boolProp name="Assertion.assume_success">false</boolProp>
+        <intProp name="Assertion.test_type">1</intProp>
+        <stringProp name="Assertion.scope">variable</stringProp>
+        <stringProp name="Scope.variable">attribute_code</stringProp>
       </ResponseAssertion>
       <hashTree/>
     </hashTree>
-  </hashTree>
   
-    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Logout" enabled="true">
-      <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
-        <collectionProp name="Arguments.arguments"/>
+    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Add attribute to attribute set" enabled="true">
+      <boolProp name="HTTPSampler.postBodyRaw">true</boolProp>
+      <elementProp name="HTTPsampler.Arguments" elementType="Arguments">
+        <collectionProp name="Arguments.arguments">
+          <elementProp name="" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">false</boolProp>
+            <stringProp name="Argument.value">{&#xD;
+    "attributeSetId": "${attribute_set_id}",&#xD;
+    "attributeGroupId": "${attribute_group_id}",&#xD;
+    "attributeCode": "${attribute_code}",&#xD;
+    "sortOrder": 3&#xD;
+}</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+          </elementProp>
+        </collectionProp>
       </elementProp>
       <stringProp name="HTTPSampler.domain"/>
       <stringProp name="HTTPSampler.port"/>
@@ -29142,34 +20585,35 @@ vars.put("customer_email", emails_list.get(emails_index));</stringProp>
       <stringProp name="HTTPSampler.response_timeout"/>
       <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
       <stringProp name="HTTPSampler.contentEncoding"/>
-      <stringProp name="HTTPSampler.path">${base_path}customer/account/logout/</stringProp>
-      <stringProp name="HTTPSampler.method">GET</stringProp>
+      <stringProp name="HTTPSampler.path">${base_path}rest/default/V1/products/attribute-sets/attributes</stringProp>
+      <stringProp name="HTTPSampler.method">POST</stringProp>
       <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
       <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
       <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
       <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
       <boolProp name="HTTPSampler.monitor">false</boolProp>
       <stringProp name="HTTPSampler.embedded_url_re"/>
-    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/common/logout.jmx</stringProp></HTTPSamplerProxy>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/api/add_attribute_to_attribute_set.jmx</stringProp></HTTPSamplerProxy>
     <hashTree>
-      <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert success" enabled="true">
-        <collectionProp name="Asserion.test_strings">
-          <stringProp name="1723813687">You are signed out.</stringProp>
-        </collectionProp>
-        <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
-        <boolProp name="Assertion.assume_success">false</boolProp>
-        <intProp name="Assertion.test_type">2</intProp>
-      </ResponseAssertion>
+      <com.atlantbh.jmeter.plugins.jsonutils.jsonpathassertion.JSONPathAssertion guiclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathassertion.gui.JSONPathAssertionGui" testclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathassertion.JSONPathAssertion" testname="Assert response is not null" enabled="true">
+        <stringProp name="JSON_PATH">$</stringProp>
+        <stringProp name="EXPECTED_VALUE">(\d+)</stringProp>
+        <boolProp name="JSONVALIDATION">true</boolProp>
+        <boolProp name="EXPECT_NULL">false</boolProp>
+        <boolProp name="INVERT">false</boolProp>
+      </com.atlantbh.jmeter.plugins.jsonutils.jsonpathassertion.JSONPathAssertion>
       <hashTree/>
     </hashTree>
   </hashTree>
 
+  </hashTree>
+
   
-    <ThroughputController guiclass="ThroughputControllerGui" testclass="ThroughputController" testname="Catalog Browsing By Customer" enabled="true">
+    <ThroughputController guiclass="ThroughputControllerGui" testclass="ThroughputController" testname="Admin Create Product" enabled="true">
       <intProp name="ThroughputController.style">1</intProp>
       <boolProp name="ThroughputController.perThread">false</boolProp>
       <intProp name="ThroughputController.maxThroughput">1</intProp>
-      <stringProp name="ThroughputController.percentThroughput">${browseCatalogByCustomerPercentage}</stringProp>
+      <stringProp name="ThroughputController.percentThroughput">${adminProductCreationPercentage}</stringProp>
     <stringProp name="TestPlan.comments">mpaf/tool/fragments/_system/scenario_controller_tmpl.jmx</stringProp></ThroughputController>
     <hashTree>
         <JSR223PreProcessor guiclass="TestBeanGUI" testclass="JSR223PreProcessor" testname="Set Test Label" enabled="true">
@@ -29190,111 +20634,97 @@ if (testLabel
         <hashTree/>
         <BeanShellSampler guiclass="BeanShellSamplerGui" testclass="BeanShellSampler" testname="SetUp - Set Label" enabled="true">
             <stringProp name="BeanShellSampler.query">
-                vars.put("testLabel", "Catalog Browsing By Customer");
+                vars.put("testLabel", "Admin Create Product");
             </stringProp>
             <boolProp name="BeanShellSampler.resetInterpreter">true</boolProp>
         </BeanShellSampler>
         <hashTree/>
     
-    <CookieManager guiclass="CookiePanel" testclass="CookieManager" testname="HTTP Cookie Manager" enabled="true">
-      <collectionProp name="CookieManager.cookies">
-        <elementProp name="product_list_limit" elementType="Cookie" testname="product_list_limit">
-          <stringProp name="Cookie.value">30</stringProp>
-          <stringProp name="Cookie.domain">${host}</stringProp>
-          <stringProp name="Cookie.path">/</stringProp>
-          <boolProp name="Cookie.secure">false</boolProp>
-          <longProp name="Cookie.expires">0</longProp>
-          <boolProp name="Cookie.path_specified">true</boolProp>
-          <boolProp name="Cookie.domain_specified">true</boolProp>
-        </elementProp>
-        <elementProp name="product_list_limit" elementType="Cookie" testname="form_key">
-          <stringProp name="Cookie.value">${form_key}</stringProp>
-          <stringProp name="Cookie.domain">${host}</stringProp>
-          <stringProp name="Cookie.path">${base_path}</stringProp>
-          <boolProp name="Cookie.secure">false</boolProp>
-          <longProp name="Cookie.expires">0</longProp>
-          <boolProp name="Cookie.path_specified">true</boolProp>
-          <boolProp name="Cookie.domain_specified">true</boolProp>
-        </elementProp>
-      </collectionProp>
-      <boolProp name="CookieManager.clearEachIteration">true</boolProp>
-    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/http_cookie_manager.jmx</stringProp></CookieManager>
-    <hashTree/>
-  
-      <BeanShellSampler guiclass="BeanShellSamplerGui" testclass="BeanShellSampler" testname="SetUp - Init Random Generator" enabled="true">
-        <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/common/init_random_generator_setup.jmx</stringProp>
-        <stringProp name="BeanShellSampler.query">
-import java.util.Random;
-
-Random random = new Random();
-if (${seedForRandom} &gt; 0) {
-    random.setSeed(${seedForRandom} + ${__threadNum});
-}
+        <JSR223PostProcessor guiclass="TestBeanGUI" testclass="JSR223PostProcessor" testname="Get admin form key PostProcessor" enabled="true">
+        <stringProp name="script">
+        function getFormKeyFromResponse()
+        {
+            var url = prev.getUrlAsString(),
+            responseCode =  prev.getResponseCode(),
+            formKey = null;
+            searchPattern = /var FORM_KEY = '(.+)'/;
+            if (responseCode == "200" &amp;&amp; url) {
+                response = prev.getResponseDataAsString();
+                formKey = response  &amp;&amp; response.match(searchPattern) ? response.match(searchPattern)[1] : null;
+            }
+            return formKey;
+        }
 
-vars.putObject("randomIntGenerator", random);
-        </stringProp>
-        <stringProp name="BeanShellSampler.filename"/>
-        <stringProp name="BeanShellSampler.parameters"/>
-        <boolProp name="BeanShellSampler.resetInterpreter">true</boolProp>
-      </BeanShellSampler>
-      <hashTree/>
-    
-      <BeanShellSampler guiclass="BeanShellSamplerGui" testclass="BeanShellSampler" testname="SetUp - Prepare Category Data" enabled="true">
-        <stringProp name="BeanShellSampler.query">
-import java.util.Random;
+        formKey = vars.get("form_key_storage");
 
-Random random = vars.getObject("randomIntGenerator");
-number = random.nextInt(props.get("category_url_keys_list").size());
+	   currentFormKey = getFormKeyFromResponse();
 
-vars.put("category_url_key", props.get("category_url_keys_list").get(number));
-vars.put("category_name", props.get("category_names_list").get(number));
+	   if (currentFormKey != null &amp;&amp; currentFormKey != formKey) {
+		  vars.put("form_key_storage", currentFormKey);
+	   }
         </stringProp>
-        <stringProp name="BeanShellSampler.filename"/>
-        <stringProp name="BeanShellSampler.parameters"/>
-        <boolProp name="BeanShellSampler.resetInterpreter">false</boolProp>
-      <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/common/extract_category_setup.jmx</stringProp></BeanShellSampler>
-      <hashTree/>
+        <stringProp name="scriptLanguage">javascript</stringProp>
+        <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin/handle_admin_form_key.jmx</stringProp></JSR223PostProcessor>
+        <hashTree/>
+        <JSR223PreProcessor guiclass="TestBeanGUI" testclass="JSR223PreProcessor" testname="Set admin form key PreProcessor" enabled="true">
+            <stringProp name="script">
+                formKey =  vars.get("form_key_storage");
+                if (formKey
+                    &amp;&amp; sampler.getClass().getName() == 'org.apache.jmeter.protocol.http.sampler.HTTPSamplerProxy'
+                    &amp;&amp; sampler.getMethod() == "POST")
+                    {
+                        arguments = sampler.getArguments();
+                        for (i=0; i&lt;arguments.getArgumentCount(); i++)
+                        {
+                            argument = arguments.getArgument(i);
+                            if (argument.getName() == 'form_key' &amp;&amp; argument.getValue() != formKey) {
+                            log.info("admin form key updated: " + argument.getValue() + " =&gt; " + formKey);
+                            argument.setValue(formKey);
+                        }
+                    }
+                }
+            </stringProp>
+            <stringProp name="scriptLanguage">javascript</stringProp>
+        </JSR223PreProcessor>
+        <hashTree/>
     
-    <BeanShellSampler guiclass="BeanShellSamplerGui" testclass="BeanShellSampler" testname="SetUp - Get Customer Email" enabled="true">
-      <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/get_customer_email.jmx</stringProp>
-      <stringProp name="BeanShellSampler.query">import org.apache.jmeter.samplers.SampleResult;
-
-String siterator = vars.get("customer_emails_index");
-int iterator;
-if(siterator == null){
-    iterator = 0;
-    vars.put("customer_emails_index", "0");
-} else {
-    iterator = Integer.parseInt(siterator);
-    iterator ++;
-    vars.put("customer_emails_index", iterator.toString());
-}
-
-emails_list = props.get("customer_emails_list");
-
-threadsNumber = ctx.getThreadGroup().getNumThreads();
-emailsCount = emails_list.size();
-if (threadsNumber &gt; emailsCount) {
-    log.error(" There are not enough customers for this scenario.");
-} else {
-    clusterLength = Math.round(emailsCount / threadsNumber);
-    threadNum = ctx.getThreadNum();
-    emails_index = clusterLength * threadNum + iterator;
-    maxLimit = clusterLength * (threadNum + 1);
-    if (emails_index &gt;= maxLimit) {
-        iterator = 0;
-        emails_index = clusterLength * threadNum + iterator;
-        vars.put("customer_emails_index", iterator.toString());
-    }
+    <CookieManager guiclass="CookiePanel" testclass="CookieManager" testname="HTTP Cookie Manager" enabled="true">
+      <collectionProp name="CookieManager.cookies"/>
+      <boolProp name="CookieManager.clearEachIteration">false</boolProp>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/http_cookie_manager_without_clear_each_iteration.jmx</stringProp></CookieManager>
+    <hashTree/>
+  
+    <GenericController guiclass="LogicControllerGui" testclass="GenericController" testname="Admin Login" enabled="true">
+  <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/simple_controller.jmx</stringProp>
+</GenericController>
+    <hashTree>
+    <CriticalSectionController guiclass="CriticalSectionControllerGui" testclass="CriticalSectionController" testname="Admin Login Lock" enabled="true">
+        <stringProp name="CriticalSectionController.lockName">get-admin-email</stringProp>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/lock_controller.jmx</stringProp></CriticalSectionController>
+    <hashTree>
+    
+    <BeanShellSampler guiclass="BeanShellSamplerGui" testclass="BeanShellSampler" testname="SetUp - Get Admin Email" enabled="true">
+      <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/get_admin_email.jmx</stringProp>
+      <stringProp name="BeanShellSampler.query">
+adminUserList = props.get("adminUserList");
+adminUser = adminUserList.poll();
+if (adminUser == null) {
+  SampleResult.setResponseMessage("adminUser list is empty");
+  SampleResult.setResponseData("adminUser list is empty","UTF-8");
+  IsSuccess=false;
+  SampleResult.setSuccessful(false);
+  SampleResult.setStopThread(true);
 }
-vars.put("customer_email", emails_list.get(emails_index));</stringProp>
+vars.put("admin_user", adminUser);
+      </stringProp>
       <stringProp name="BeanShellSampler.filename"/>
       <stringProp name="BeanShellSampler.parameters"/>
       <boolProp name="BeanShellSampler.resetInterpreter">true</boolProp>
     </BeanShellSampler>
     <hashTree/>
+  </hashTree>
   
-    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Open Login Page" enabled="true">
+    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="SetUp - Login" enabled="true">
       <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
         <collectionProp name="Arguments.arguments"/>
       </elementProp>
@@ -29304,7 +20734,7 @@ vars.put("customer_email", emails_list.get(emails_index));</stringProp>
       <stringProp name="HTTPSampler.response_timeout"/>
       <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
       <stringProp name="HTTPSampler.contentEncoding"/>
-      <stringProp name="HTTPSampler.path">${base_path}customer/account/login/</stringProp>
+      <stringProp name="HTTPSampler.path">${base_path}${admin_path}</stringProp>
       <stringProp name="HTTPSampler.method">GET</stringProp>
       <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
       <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
@@ -29312,49 +20742,70 @@ vars.put("customer_email", emails_list.get(emails_index));</stringProp>
       <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
       <boolProp name="HTTPSampler.monitor">false</boolProp>
       <stringProp name="HTTPSampler.embedded_url_re"/>
-    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/common/open_login_page.jmx</stringProp></HTTPSamplerProxy>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_login/admin_login.jmx</stringProp></HTTPSamplerProxy>
     <hashTree>
-      <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Response Assertion" enabled="true">
+      <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert login form shown" enabled="true">
         <collectionProp name="Asserion.test_strings">
-          <stringProp name="637394530">&lt;title&gt;Customer Login&lt;/title&gt;</stringProp>
+          <stringProp name="-1397214398">Welcome</stringProp>
+          <stringProp name="-515240035">&lt;title&gt;Magento Admin&lt;/title&gt;</stringProp>
         </collectionProp>
         <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
         <boolProp name="Assertion.assume_success">false</boolProp>
         <intProp name="Assertion.test_type">2</intProp>
       </ResponseAssertion>
       <hashTree/>
+      <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract form key" enabled="true">
+        <stringProp name="RegexExtractor.useHeaders">false</stringProp>
+        <stringProp name="RegexExtractor.refname">admin_form_key</stringProp>
+        <stringProp name="RegexExtractor.regex">&lt;input name="form_key" type="hidden" value="([^'"]+)" /&gt;</stringProp>
+        <stringProp name="RegexExtractor.template">$1$</stringProp>
+        <stringProp name="RegexExtractor.default"/>
+        <stringProp name="RegexExtractor.match_number">1</stringProp>
+      </RegexExtractor>
+      <hashTree/>
+      <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert form_key extracted" enabled="true">
+        <collectionProp name="Asserion.test_strings">
+          <stringProp name="2845929">^.+$</stringProp>
+        </collectionProp>
+        <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
+        <boolProp name="Assertion.assume_success">false</boolProp>
+        <intProp name="Assertion.test_type">1</intProp>
+        <stringProp name="Assertion.scope">variable</stringProp>
+        <stringProp name="Scope.variable">admin_form_key</stringProp>
+      </ResponseAssertion>
+      <hashTree/>
     </hashTree>
   
-    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Login" enabled="true">
+    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="SetUp - Login Submit Form" enabled="true">
       <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
         <collectionProp name="Arguments.arguments">
-          <elementProp name="form_key" elementType="HTTPArgument">
+          <elementProp name="dummy" elementType="HTTPArgument">
             <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">${form_key}</stringProp>
+            <stringProp name="Argument.value"/>
             <stringProp name="Argument.metadata">=</stringProp>
             <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">form_key</stringProp>
+            <stringProp name="Argument.name">dummy</stringProp>
           </elementProp>
-          <elementProp name="login[username]" elementType="HTTPArgument">
+          <elementProp name="form_key" elementType="HTTPArgument">
             <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">${customer_email}</stringProp>
+            <stringProp name="Argument.value">${admin_form_key}</stringProp>
             <stringProp name="Argument.metadata">=</stringProp>
             <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">login[username]</stringProp>
+            <stringProp name="Argument.name">form_key</stringProp>
           </elementProp>
           <elementProp name="login[password]" elementType="HTTPArgument">
             <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">${customer_password}</stringProp>
+            <stringProp name="Argument.value">${admin_password}</stringProp>
             <stringProp name="Argument.metadata">=</stringProp>
             <boolProp name="HTTPArgument.use_equals">true</boolProp>
             <stringProp name="Argument.name">login[password]</stringProp>
           </elementProp>
-          <elementProp name="send" elementType="HTTPArgument">
+          <elementProp name="login[username]" elementType="HTTPArgument">
             <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value"/>
+            <stringProp name="Argument.value">${admin_user}</stringProp>
             <stringProp name="Argument.metadata">=</stringProp>
             <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">send</stringProp>
+            <stringProp name="Argument.name">login[username]</stringProp>
           </elementProp>
         </collectionProp>
       </elementProp>
@@ -29364,69 +20815,156 @@ vars.put("customer_email", emails_list.get(emails_index));</stringProp>
       <stringProp name="HTTPSampler.response_timeout"/>
       <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
       <stringProp name="HTTPSampler.contentEncoding"/>
-      <stringProp name="HTTPSampler.path">${base_path}customer/account/loginPost/</stringProp>
+      <stringProp name="HTTPSampler.path">${base_path}${admin_path}/admin/dashboard/</stringProp>
       <stringProp name="HTTPSampler.method">POST</stringProp>
       <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
       <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
       <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
       <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
+      <stringProp name="HTTPSampler.implementation">Java</stringProp>
       <boolProp name="HTTPSampler.monitor">false</boolProp>
       <stringProp name="HTTPSampler.embedded_url_re"/>
-    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/common/login.jmx</stringProp></HTTPSamplerProxy>
+      <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_login/admin_login_submit_form.jmx</stringProp>
+    </HTTPSamplerProxy>
     <hashTree>
-      <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Response Assertion" enabled="true">
-        <collectionProp name="Asserion.test_strings">
-          <stringProp name="1312950388">&lt;title&gt;My Account&lt;/title&gt;</stringProp>
+        <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract form key" enabled="true">
+            <stringProp name="RegexExtractor.useHeaders">false</stringProp>
+            <stringProp name="RegexExtractor.refname">admin_form_key</stringProp>
+            <stringProp name="RegexExtractor.regex">&lt;input name="form_key" type="hidden" value="([^'"]+)" /&gt;</stringProp>
+            <stringProp name="RegexExtractor.template">$1$</stringProp>
+            <stringProp name="RegexExtractor.default"/>
+            <stringProp name="RegexExtractor.match_number">1</stringProp>
+        <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_login/admin_retrieve_form_key.jmx</stringProp></RegexExtractor>
+        <hashTree/>
+    </hashTree>
+  </hashTree>
+  
+    <OnceOnlyController guiclass="OnceOnlyControllerGui" testclass="OnceOnlyController" testname="Once Only Controller" enabled="true">
+  <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/once_only_controller.jmx</stringProp>
+</OnceOnlyController>
+    <hashTree>
+    <BeanShellSampler guiclass="BeanShellSamplerGui" testclass="BeanShellSampler" testname="SetUp - Get Related Product Id" enabled="true">
+      <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_create_product/get_related_product_id.jmx</stringProp>
+      <stringProp name="BeanShellSampler.query">import org.apache.jmeter.samplers.SampleResult;
+import java.util.Random;
+Random random = new Random();
+if (${seedForRandom} &gt; 0) {
+    random.setSeed(${seedForRandom});
+}
+relatedIndex = random.nextInt(props.get("simple_products_list").size());
+vars.put("related_product_id", props.get("simple_products_list").get(relatedIndex).get("id"));</stringProp>
+      <stringProp name="BeanShellSampler.filename"/>
+      <stringProp name="BeanShellSampler.parameters"/>
+      <boolProp name="BeanShellSampler.resetInterpreter">true</boolProp>
+    </BeanShellSampler>
+    <hashTree/>
+  
+    <GenericController guiclass="LogicControllerGui" testclass="GenericController" testname="SetUp - Get Product Attributes" enabled="true">
+  <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/simple_controller.jmx</stringProp>
+</GenericController>
+    <hashTree>
+    <HeaderManager guiclass="HeaderPanel" testclass="HeaderManager" testname="HTTP Header Manager" enabled="true">
+      <collectionProp name="HeaderManager.headers">
+        <elementProp name="" elementType="Header">
+          <stringProp name="Header.name">Content-Type</stringProp>
+          <stringProp name="Header.value">application/json</stringProp>
+        </elementProp>
+        <elementProp name="" elementType="Header">
+          <stringProp name="Header.name">Accept</stringProp>
+          <stringProp name="Header.value">*/*</stringProp>
+        </elementProp>
+      </collectionProp>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/api/header_manager_before_token.jmx</stringProp></HeaderManager>
+    <hashTree/>
+  
+    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="SetUp - Admin Token Retrieval" enabled="true">
+      <boolProp name="HTTPSampler.postBodyRaw">true</boolProp>
+      <elementProp name="HTTPsampler.Arguments" elementType="Arguments">
+        <collectionProp name="Arguments.arguments">
+          <elementProp name="" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">false</boolProp>
+            <stringProp name="Argument.value">{"username":"${admin_user}","password":"${admin_password}"}</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+          </elementProp>
         </collectionProp>
-        <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
-        <boolProp name="Assertion.assume_success">false</boolProp>
-        <intProp name="Assertion.test_type">2</intProp>
-      </ResponseAssertion>
-      <hashTree/>
-      <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract Address" enabled="true">
-        <stringProp name="RegexExtractor.useHeaders">false</stringProp>
-        <stringProp name="RegexExtractor.refname">addressId</stringProp>
-        <stringProp name="RegexExtractor.regex">customer/address/edit/id/([^'"]+)/</stringProp>
-        <stringProp name="RegexExtractor.template">$1$</stringProp>
-        <stringProp name="RegexExtractor.default"/>
-        <stringProp name="RegexExtractor.match_number">1</stringProp>
-      </RegexExtractor>
+      </elementProp>
+      <stringProp name="HTTPSampler.domain"/>
+      <stringProp name="HTTPSampler.port"/>
+      <stringProp name="HTTPSampler.connect_timeout"/>
+      <stringProp name="HTTPSampler.response_timeout"/>
+      <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
+      <stringProp name="HTTPSampler.contentEncoding"/>
+      <stringProp name="HTTPSampler.path">${base_path}rest/V1/integration/admin/token</stringProp>
+      <stringProp name="HTTPSampler.method">POST</stringProp>
+      <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
+      <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
+      <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
+      <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
+      <boolProp name="HTTPSampler.monitor">false</boolProp>
+      <stringProp name="HTTPSampler.embedded_url_re"/>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/api/admin_token_retrieval.jmx</stringProp></HTTPSamplerProxy>
+    <hashTree>
+      <com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor guiclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.gui.JSONPathExtractorGui" testclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor" testname="jp@gc - JSON Path Extractor" enabled="true">
+        <stringProp name="VAR">admin_token</stringProp>
+        <stringProp name="JSONPATH">$</stringProp>
+        <stringProp name="DEFAULT"/>
+        <stringProp name="VARIABLE"/>
+        <stringProp name="SUBJECT">BODY</stringProp>
+      </com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor>
       <hashTree/>
-      <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert addressId extracted" enabled="true">
+      <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert token not null" enabled="true">
         <collectionProp name="Asserion.test_strings">
-          <stringProp name="2845929">^.+$</stringProp>
+          <stringProp name="484395188">^[a-z0-9-]+$</stringProp>
         </collectionProp>
         <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
         <boolProp name="Assertion.assume_success">false</boolProp>
         <intProp name="Assertion.test_type">1</intProp>
         <stringProp name="Assertion.scope">variable</stringProp>
-        <stringProp name="Scope.variable">addressId</stringProp>
+        <stringProp name="Scope.variable">admin_token</stringProp>
       </ResponseAssertion>
       <hashTree/>
     </hashTree>
-    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Load Customer Private Data" enabled="true">
+  
+    <HeaderManager guiclass="HeaderPanel" testclass="HeaderManager" testname="HTTP Header Manager" enabled="true">
+      <collectionProp name="HeaderManager.headers">
+        <elementProp name="" elementType="Header">
+          <stringProp name="Header.name">Authorization</stringProp>
+          <stringProp name="Header.value">Bearer ${admin_token}</stringProp>
+        </elementProp>
+      </collectionProp>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/api/header_manager.jmx</stringProp></HeaderManager>
+    <hashTree/>
+  
+    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="SetUp - API Get product attributes" enabled="true">
       <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
         <collectionProp name="Arguments.arguments">
-          <elementProp name="sections" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value"/>
+          <elementProp name="searchCriteria[filterGroups][0][filters][0][value]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">false</boolProp>
+            <stringProp name="Argument.value">mycolor</stringProp>
             <stringProp name="Argument.metadata">=</stringProp>
             <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">sections</stringProp>
+            <stringProp name="Argument.name">searchCriteria[filterGroups][0][filters][0][value]</stringProp>
           </elementProp>
-          <elementProp name="update_section_id" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">false</stringProp>
+          <elementProp name="searchCriteria[filterGroups][0][filters][0][field]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">false</boolProp>
+            <stringProp name="Argument.value">attribute_code</stringProp>
             <stringProp name="Argument.metadata">=</stringProp>
             <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">update_section_id</stringProp>
+            <stringProp name="Argument.name">searchCriteria[filterGroups][0][filters][0][field]</stringProp>
           </elementProp>
-          <elementProp name="_" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">${__time()}${__Random(1,1000000)}</stringProp>
+          <elementProp name="searchCriteria[filterGroups][0][filters][1][value]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">false</boolProp>
+            <stringProp name="Argument.value">mysize</stringProp>
             <stringProp name="Argument.metadata">=</stringProp>
             <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">_</stringProp>
+            <stringProp name="Argument.name">searchCriteria[filterGroups][0][filters][1][value]</stringProp>
+          </elementProp>
+          <elementProp name="searchCriteria[filterGroups][0][filters][1][field]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">false</boolProp>
+            <stringProp name="Argument.value">attribute_code</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">searchCriteria[filterGroups][0][filters][1][field]</stringProp>
           </elementProp>
         </collectionProp>
       </elementProp>
@@ -29436,7 +20974,7 @@ vars.put("customer_email", emails_list.get(emails_index));</stringProp>
       <stringProp name="HTTPSampler.response_timeout"/>
       <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
       <stringProp name="HTTPSampler.contentEncoding"/>
-      <stringProp name="HTTPSampler.path">${base_path}customer/section/load/</stringProp>
+      <stringProp name="HTTPSampler.path">${base_path}rest/default/V1/products/attributes</stringProp>
       <stringProp name="HTTPSampler.method">GET</stringProp>
       <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
       <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
@@ -29444,41 +20982,57 @@ vars.put("customer_email", emails_list.get(emails_index));</stringProp>
       <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
       <boolProp name="HTTPSampler.monitor">false</boolProp>
       <stringProp name="HTTPSampler.embedded_url_re"/>
-    </HTTPSamplerProxy>
-    <hashTree/>
-  
-      <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Open Home Page" enabled="true">
-        <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
-          <collectionProp name="Arguments.arguments"/>
-        </elementProp>
-        <stringProp name="HTTPSampler.domain"/>
-        <stringProp name="HTTPSampler.port"/>
-        <stringProp name="HTTPSampler.connect_timeout"/>
-        <stringProp name="HTTPSampler.response_timeout"/>
-        <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
-        <stringProp name="HTTPSampler.contentEncoding"/>
-        <stringProp name="HTTPSampler.path">${base_path}</stringProp>
-        <stringProp name="HTTPSampler.method">GET</stringProp>
-        <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
-        <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
-        <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
-        <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
-        <boolProp name="HTTPSampler.monitor">false</boolProp>
-        <stringProp name="HTTPSampler.embedded_url_re"/>
-      <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/common/open_home_page.jmx</stringProp></HTTPSamplerProxy>
-      <hashTree>
-        <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Response Assertion" enabled="true">
-          <collectionProp name="Asserion.test_strings">
-            <stringProp name="571386695">&lt;title&gt;Home page&lt;/title&gt;</stringProp>
-          </collectionProp>
-          <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
-          <boolProp name="Assertion.assume_success">false</boolProp>
-          <intProp name="Assertion.test_type">2</intProp>
-        </ResponseAssertion>
-        <hashTree/>
-      </hashTree>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_create_product/get_product_attributes.jmx</stringProp></HTTPSamplerProxy>
+    <hashTree>
+      <com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor guiclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.gui.JSONPathExtractorGui" testclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor" testname="Extract product attributes" enabled="true">
+        <stringProp name="VAR">product_attributes</stringProp>
+        <stringProp name="JSONPATH">$.items</stringProp>
+        <stringProp name="DEFAULT"/>
+        <stringProp name="VARIABLE"/>
+        <stringProp name="SUBJECT">BODY</stringProp>
+      </com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor>
+      <hashTree/>
+      <JSR223PostProcessor guiclass="TestBeanGUI" testclass="JSR223PostProcessor" testname="SetUp - Prepare product attributes" enabled="true">
+        <stringProp name="scriptLanguage">javascript</stringProp>
+        <stringProp name="parameters"/>
+        <stringProp name="filename"/>
+        <stringProp name="cacheKey"/>
+        <stringProp name="script">
+var attributesData = JSON.parse(vars.get("product_attributes")),
+maxOptions = 2;
+
+attributes = [];
+for (i in attributesData) {
+    if (i &gt;= 2) {
+        break;
+    }
+    var data = attributesData[i],
+        attribute = {
+            "id": data.attribute_id,
+            "code": data.attribute_code,
+            "label": data.default_frontend_label,
+            "options": []
+        };
+
+    var processedOptions = 0;
+    for (optionN in data.options) {
+        var option = data.options[optionN];
+        if (parseInt(option.value) &gt; 0 &amp;&amp; processedOptions &lt; maxOptions) {
+            processedOptions++;
+            attribute.options.push(option);
+        }
+    }
+    attributes.push(attribute);
+}
+
+vars.putObject("product_attributes", attributes);
+</stringProp>
+      </JSR223PostProcessor>
+      <hashTree/>
+    </hashTree>
+  </hashTree>
   
-    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Open Category" enabled="true">
+    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="SetUp - Get Attribute Set Id" enabled="true">
       <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
         <collectionProp name="Arguments.arguments"/>
       </elementProp>
@@ -29488,7 +21042,7 @@ vars.put("customer_email", emails_list.get(emails_index));</stringProp>
       <stringProp name="HTTPSampler.response_timeout"/>
       <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
       <stringProp name="HTTPSampler.contentEncoding"/>
-      <stringProp name="HTTPSampler.path">${base_path}${category_url_key}${url_suffix}</stringProp>
+      <stringProp name="HTTPSampler.path">${base_path}${admin_path}/catalog/product_set/index/filter/${attribute_set_filter}</stringProp>
       <stringProp name="HTTPSampler.method">GET</stringProp>
       <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
       <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
@@ -29496,474 +21050,1019 @@ vars.put("customer_email", emails_list.get(emails_index));</stringProp>
       <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
       <boolProp name="HTTPSampler.monitor">false</boolProp>
       <stringProp name="HTTPSampler.embedded_url_re"/>
-    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/common/open_category.jmx</stringProp></HTTPSamplerProxy>
+      <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_create_product/configurable_setup_attribute_set.jmx</stringProp>
+    </HTTPSamplerProxy>
     <hashTree>
-      <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Response Assertion" enabled="true">
-        <collectionProp name="Asserion.test_strings">
-          <stringProp name="1210004667">&lt;span class="base" data-ui-id="page-title"&gt;${category_name}&lt;/span&gt;</stringProp>
-        </collectionProp>
-        <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
-        <boolProp name="Assertion.assume_success">false</boolProp>
-        <intProp name="Assertion.test_type">6</intProp>
-      </ResponseAssertion>
-      <hashTree/>
-      <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Regular Expression Extractor: Extract category id" enabled="true">
+      <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Regular Expression Extractor" enabled="true">
         <stringProp name="RegexExtractor.useHeaders">false</stringProp>
-        <stringProp name="RegexExtractor.refname">category_id</stringProp>
-        <stringProp name="RegexExtractor.regex">&lt;li class="item category([^'"]+)"&gt;\s*&lt;strong&gt;${category_name}&lt;/strong&gt;\s*&lt;/li&gt;</stringProp>
+        <stringProp name="RegexExtractor.refname">attribute_set_id</stringProp>
+        <stringProp name="RegexExtractor.regex">catalog\/product_set\/edit\/id\/([\d]+)\/"[\D\d]*Attribute Set 1</stringProp>
         <stringProp name="RegexExtractor.template">$1$</stringProp>
         <stringProp name="RegexExtractor.default"/>
         <stringProp name="RegexExtractor.match_number">1</stringProp>
-        <stringProp name="Scope.variable">simple_product_1_url_key</stringProp>
       </RegexExtractor>
       <hashTree/>
-      <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Response Assertion: Assert category id" enabled="true">
-        <collectionProp name="Asserion.test_strings">
-          <stringProp name="1191417111">^[0-9]+$</stringProp>
-        </collectionProp>
-        <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
-        <boolProp name="Assertion.assume_success">false</boolProp>
-        <intProp name="Assertion.test_type">1</intProp>
-        <stringProp name="Assertion.scope">variable</stringProp>
-        <stringProp name="Scope.variable">category_id</stringProp>
-      </ResponseAssertion>
+      <BeanShellPreProcessor guiclass="TestBeanGUI" testclass="BeanShellPreProcessor" testname="SetUp - Set Attribute Set Filter" enabled="true">
+        <boolProp name="resetInterpreter">false</boolProp>
+        <stringProp name="parameters"/>
+        <stringProp name="filename"/>
+        <stringProp name="script">import org.apache.commons.codec.binary.Base64;
+
+byte[] encodedBytes = Base64.encodeBase64("set_name=Attribute Set 1".getBytes());
+vars.put("attribute_set_filter", new String(encodedBytes));
+</stringProp>
+      </BeanShellPreProcessor>
       <hashTree/>
     </hashTree>
+  </hashTree>
   
-    <LoopController guiclass="LoopControlPanel" testclass="LoopController" testname="View Simple Products" enabled="true">
-      <boolProp name="LoopController.continue_forever">true</boolProp>
-      <stringProp name="LoopController.loops">2</stringProp>
-    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/loop_controller.jmx</stringProp></LoopController>
+    <GenericController guiclass="LogicControllerGui" testclass="GenericController" testname="Simple Controller" enabled="true">
+  <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/simple_controller.jmx</stringProp>
+</GenericController>
     <hashTree>
-      <CounterConfig guiclass="CounterConfigGui" testclass="CounterConfig" testname="Counter" enabled="true">
-        <stringProp name="CounterConfig.start">1</stringProp>
-        <stringProp name="CounterConfig.end"/>
-        <stringProp name="CounterConfig.incr">1</stringProp>
-        <stringProp name="CounterConfig.name">_counter</stringProp>
-        <stringProp name="CounterConfig.format"/>
-        <boolProp name="CounterConfig.per_user">true</boolProp>
-        <boolProp name="CounterConfig.reset_on_tg_iteration">true</boolProp>
-      </CounterConfig>
-      <hashTree/>
-    
-    <BeanShellSampler guiclass="BeanShellSamplerGui" testclass="BeanShellSampler" testname="SetUp - Prepare Simple Product Data" enabled="true">
-      <stringProp name="BeanShellSampler.query">
+    <BeanShellSampler guiclass="BeanShellSamplerGui" testclass="BeanShellSampler" testname="SetUp - Set Arguments" enabled="true">
+      <stringProp name="BeanShellSampler.query">import org.apache.jmeter.samplers.SampleResult;
 import java.util.Random;
-
-Random random = vars.getObject("randomIntGenerator");
+Random random = new Random();
+if (${seedForRandom} &gt; 0) {
+    random.setSeed(${seedForRandom});
+}
 number = random.nextInt(props.get("simple_products_list").size());
-product = props.get("simple_products_list").get(number);
+simpleList = props.get("simple_products_list").get(number);
+vars.put("simple_product_1_id", simpleList.get("id"));
+vars.put("simple_product_1_name", simpleList.get("title"));
+
+do {
+    number1 = random.nextInt(props.get("simple_products_list").size());
+} while(number == number1);
+simpleList = props.get("simple_products_list").get(number1);
+vars.put("simple_product_2_id", simpleList.get("id"));
+vars.put("simple_product_2_name", simpleList.get("title"));
+
+number2 = random.nextInt(props.get("configurable_products_list").size());
+configurableList = props.get("configurable_products_list").get(number2);
+vars.put("configurable_product_1_id", configurableList.get("id"));
+vars.put("configurable_product_1_url_key", configurableList.get("url_key"));
+vars.put("configurable_product_1_name", configurableList.get("title"));
+
+//Additional category to be added
+//int categoryId = Integer.parseInt(vars.get("simple_product_category_id"));
+//vars.put("category_additional", (categoryId+1).toString());
+//New price
+vars.put("price_new", "9999");
+//New special price
+vars.put("special_price_new", "8888");
+//New quantity
+vars.put("quantity_new", "100600");
+vars.put("configurable_sku", "Configurable Product - ${__time(YMD)}-${__threadNum}-${__Random(1,1000000)}");
 
-vars.put("product_url_key", product.get("url_key"));
-vars.put("product_id", product.get("id"));
-vars.put("product_name", product.get("title"));
-vars.put("product_uenc", product.get("uenc"));
-vars.put("product_sku", product.get("sku"));
       </stringProp>
       <stringProp name="BeanShellSampler.filename"/>
       <stringProp name="BeanShellSampler.parameters"/>
       <boolProp name="BeanShellSampler.resetInterpreter">true</boolProp>
-    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/product_browsing_and_adding_items_to_the_cart/simple_products_setup.jmx</stringProp></BeanShellSampler>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_create_product/setup.jmx</stringProp></BeanShellSampler>
     <hashTree/>
   
-        <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Simple Product ${_counter} View" enabled="true">
-            <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
-                <collectionProp name="Arguments.arguments"/>
+    <TestFragmentController guiclass="TestFragmentControllerGui" testclass="TestFragmentController" testname="Admin Create Bundle Product" enabled="true">
+  <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_create_product/create_bundle_product.jmx</stringProp>
+</TestFragmentController>
+    <hashTree>
+      <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Catalog Product" enabled="true">
+        <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
+          <collectionProp name="Arguments.arguments"/>
+        </elementProp>
+        <stringProp name="HTTPSampler.domain"/>
+        <stringProp name="HTTPSampler.port"/>
+        <stringProp name="HTTPSampler.connect_timeout"/>
+        <stringProp name="HTTPSampler.response_timeout"/>
+        <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
+        <stringProp name="HTTPSampler.contentEncoding"/>
+        <stringProp name="HTTPSampler.path">${base_path}${admin_path}/catalog/product/</stringProp>
+        <stringProp name="HTTPSampler.method">GET</stringProp>
+        <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
+        <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
+        <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
+        <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
+        <boolProp name="HTTPSampler.monitor">false</boolProp>
+        <stringProp name="HTTPSampler.embedded_url_re"/>
+      </HTTPSamplerProxy>
+      <hashTree>
+        <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Response Assertion" enabled="true">
+          <collectionProp name="Asserion.test_strings">
+            <stringProp name="1509986340">records found</stringProp>
+          </collectionProp>
+          <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
+          <boolProp name="Assertion.assume_success">false</boolProp>
+          <intProp name="Assertion.test_type">2</intProp>
+        </ResponseAssertion>
+        <hashTree/>
+      </hashTree>
+      <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="New Bundle Product" enabled="true">
+        <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
+          <collectionProp name="Arguments.arguments"/>
+        </elementProp>
+        <stringProp name="HTTPSampler.domain"/>
+        <stringProp name="HTTPSampler.port"/>
+        <stringProp name="HTTPSampler.connect_timeout"/>
+        <stringProp name="HTTPSampler.response_timeout"/>
+        <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
+        <stringProp name="HTTPSampler.contentEncoding"/>
+        <stringProp name="HTTPSampler.path">${base_path}${admin_path}/catalog/product/new/set/4/type/bundle/</stringProp>
+        <stringProp name="HTTPSampler.method">GET</stringProp>
+        <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
+        <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
+        <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
+        <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
+        <boolProp name="HTTPSampler.monitor">false</boolProp>
+        <stringProp name="HTTPSampler.embedded_url_re"/>
+      </HTTPSamplerProxy>
+      <hashTree>
+        <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Response Assertion" enabled="true">
+          <collectionProp name="Asserion.test_strings">
+            <stringProp name="-144461265">New Product</stringProp>
+          </collectionProp>
+          <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
+          <boolProp name="Assertion.assume_success">false</boolProp>
+          <intProp name="Assertion.test_type">2</intProp>
+        </ResponseAssertion>
+        <hashTree/>
+      </hashTree>
+      <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="New Bundle Product Validate" enabled="true">
+        <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
+          <collectionProp name="Arguments.arguments">
+            <elementProp name="ajax" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">true</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">ajax</stringProp>
+              <stringProp name="Argument.desc">false</stringProp>
+            </elementProp>
+            <elementProp name="isAjax" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">true</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">isAjax</stringProp>
+              <stringProp name="Argument.desc">false</stringProp>
+            </elementProp>
+            <elementProp name="form_key" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">${admin_form_key}</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">form_key</stringProp>
+              <stringProp name="Argument.desc">false</stringProp>
+            </elementProp>
+            <elementProp name="product[name]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">Bundle Product ${__time(YMDHMS)}-${__threadNum}-${__Random(1,1000000)}</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[name]</stringProp>
+              <stringProp name="Argument.desc">false</stringProp>
+            </elementProp>
+            <elementProp name="product[sku]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">Bundle Product  ${__time(YMDHMS)}-${__threadNum}-${__Random(1,1000000)}</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[sku]</stringProp>
+              <stringProp name="Argument.desc">false</stringProp>
+            </elementProp>
+            <elementProp name="product[price]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">42</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[price]</stringProp>
+            </elementProp>
+            <elementProp name="product[tax_class_id]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">2</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[tax_class_id]</stringProp>
+            </elementProp>
+            <elementProp name="product[quantity_and_stock_status][qty]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">111</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[quantity_and_stock_status][qty]</stringProp>
+            </elementProp>
+            <elementProp name="product[quantity_and_stock_status][is_in_stock]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">1</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[quantity_and_stock_status][is_in_stock]</stringProp>
+            </elementProp>
+            <elementProp name="product[weight]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">1.0000</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[weight]</stringProp>
+            </elementProp>
+            <elementProp name="product[product_has_weight]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">1</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[product_has_weight]</stringProp>
+              <stringProp name="Argument.desc">true</stringProp>
+            </elementProp>
+            <elementProp name="product[category_ids][]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">2</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[category_ids][]</stringProp>
+            </elementProp>
+            <elementProp name="product[description]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">&lt;p&gt;Full bundle product description ${__time(YMDHMS)}-${__threadNum}-${__Random(1,1000000)}&lt;/p&gt;</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[description]</stringProp>
+            </elementProp>
+            <elementProp name="product[short_description]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">&lt;p&gt;Short bundle product description ${__time(YMDHMS)}-${__threadNum}-${__Random(1,1000000)}&lt;/p&gt;</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[short_description]</stringProp>
+            </elementProp>
+            <elementProp name="product[status]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">1</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[status]</stringProp>
+            </elementProp>
+            <elementProp name="product[configurable_variations]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value"/>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[configurable_variations]</stringProp>
+            </elementProp>
+            <elementProp name="affect_configurable_product_attributes" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">1</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">affect_configurable_product_attributes</stringProp>
+            </elementProp>
+            <elementProp name="product[image]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value"/>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[image]</stringProp>
+            </elementProp>
+            <elementProp name="product[small_image]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value"/>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[small_image]</stringProp>
+            </elementProp>
+            <elementProp name="product[thumbnail]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value"/>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[thumbnail]</stringProp>
+            </elementProp>
+            <elementProp name="product[url_key]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">bundle-product-${__time(YMDHMS)}-${__threadNum}-${__Random(1,1000000)}</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[url_key]</stringProp>
+            </elementProp>
+            <elementProp name="product[meta_title]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">Bundle Product ${__time(YMDHMS)}-${__threadNum}-${__Random(1,1000000)} Meta Title</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[meta_title]</stringProp>
+            </elementProp>
+            <elementProp name="product[meta_keyword]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">Bundle Product ${__time(YMDHMS)}-${__threadNum}-${__Random(1,1000000)} Meta Keyword</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[meta_keyword]</stringProp>
+            </elementProp>
+            <elementProp name="product[meta_description]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">Bundle Product ${__time(YMDHMS)}-${__threadNum}-${__Random(1,1000000)} Meta Description</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[meta_description]</stringProp>
+            </elementProp>
+            <elementProp name="product[website_ids][]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">1</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[website_ids][]</stringProp>
+            </elementProp>
+            <elementProp name="product[special_price]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">99</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[special_price]</stringProp>
+            </elementProp>
+            <elementProp name="product[stock_data][notify_stock_qty]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">1</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[stock_data][notify_stock_qty]</stringProp>
+            </elementProp>
+            <elementProp name="product[special_from_date]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value"/>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[special_from_date]</stringProp>
+            </elementProp>
+            <elementProp name="product[special_to_date]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value"/>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[special_to_date]</stringProp>
+            </elementProp>
+            <elementProp name="product[cost]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value"/>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[cost]</stringProp>
+            </elementProp>
+            <elementProp name="product[tier_price][0][website_id]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">0</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[tier_price][0][website_id]</stringProp>
+            </elementProp>
+            <elementProp name="product[tier_price][0][cust_group]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">32000</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[tier_price][0][cust_group]</stringProp>
+            </elementProp>
+            <elementProp name="product[tier_price][0][price_qty]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">100</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[tier_price][0][price_qty]</stringProp>
+            </elementProp>
+            <elementProp name="product[tier_price][0][price]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">90</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[tier_price][0][price]</stringProp>
+            </elementProp>
+            <elementProp name="product[tier_price][0][delete]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value"/>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[tier_price][0][delete]</stringProp>
+            </elementProp>
+            <elementProp name="product[tier_price][1][website_id]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">0</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[tier_price][1][website_id]</stringProp>
+            </elementProp>
+            <elementProp name="product[tier_price][1][cust_group]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">1</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[tier_price][1][cust_group]</stringProp>
+            </elementProp>
+            <elementProp name="product[tier_price][1][price_qty]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">101</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[tier_price][1][price_qty]</stringProp>
+            </elementProp>
+            <elementProp name="product[tier_price][1][price]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">99</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[tier_price][1][price]</stringProp>
+            </elementProp>
+            <elementProp name="product[tier_price][1][delete]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value"/>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[tier_price][1][delete]</stringProp>
+            </elementProp>
+            <elementProp name="product[stock_data][use_config_manage_stock]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">1</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[stock_data][use_config_manage_stock]</stringProp>
+            </elementProp>
+            <elementProp name="product[stock_data][original_inventory_qty]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">100500</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[stock_data][original_inventory_qty]</stringProp>
+            </elementProp>
+            <elementProp name="product[stock_data][qty]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">100500</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[stock_data][qty]</stringProp>
+            </elementProp>
+            <elementProp name="product[stock_data][min_qty]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">0</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[stock_data][min_qty]</stringProp>
+            </elementProp>
+            <elementProp name="product[stock_data][use_config_min_qty]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">1</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[stock_data][use_config_min_qty]</stringProp>
+            </elementProp>
+            <elementProp name="product[stock_data][min_sale_qty]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">1</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[stock_data][min_sale_qty]</stringProp>
+            </elementProp>
+            <elementProp name="product[stock_data][use_config_min_sale_qty]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">1</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[stock_data][use_config_min_sale_qty]</stringProp>
+            </elementProp>
+            <elementProp name="product[stock_data][max_sale_qty]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">10000</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[stock_data][max_sale_qty]</stringProp>
+            </elementProp>
+            <elementProp name="product[stock_data][use_config_max_sale_qty]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">1</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[stock_data][use_config_max_sale_qty]</stringProp>
+            </elementProp>
+            <elementProp name="product[stock_data][is_qty_decimal]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">0</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[stock_data][is_qty_decimal]</stringProp>
+            </elementProp>
+            <elementProp name="product[stock_data][is_decimal_divided]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">0</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[stock_data][is_decimal_divided]</stringProp>
+            </elementProp>
+            <elementProp name="product[stock_data][backorders]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">0</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[stock_data][backorders]</stringProp>
+            </elementProp>
+            <elementProp name="product[stock_data][use_config_backorders]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">1</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[stock_data][use_config_backorders]</stringProp>
+            </elementProp>
+            <elementProp name="product[stock_data][use_config_notify_stock_qty]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">1</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[stock_data][use_config_notify_stock_qty]</stringProp>
+            </elementProp>
+            <elementProp name="product[stock_data][enable_qty_increments]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">0</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[stock_data][enable_qty_increments]</stringProp>
+            </elementProp>
+            <elementProp name="product[stock_data][qty_increments]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">0</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[stock_data][qty_increments]</stringProp>
+            </elementProp>
+            <elementProp name="product[stock_data][use_config_qty_increments]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">1</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[stock_data][use_config_qty_increments]</stringProp>
+            </elementProp>
+            <elementProp name="product[stock_data][is_in_stock]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">1</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[stock_data][is_in_stock]</stringProp>
+            </elementProp>
+            <elementProp name="product[custom_design]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value"/>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[custom_design]</stringProp>
+            </elementProp>
+            <elementProp name="product[custom_design_from]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value"/>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[custom_design_from]</stringProp>
+            </elementProp>
+            <elementProp name="product[custom_design_to]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value"/>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[custom_design_to]</stringProp>
+            </elementProp>
+            <elementProp name="product[custom_layout_update]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value"/>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[custom_layout_update]</stringProp>
+            </elementProp>
+            <elementProp name="product[page_layout]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value"/>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[page_layout]</stringProp>
+            </elementProp>
+            <elementProp name="product[options_container]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">container2</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[options_container]</stringProp>
+            </elementProp>
+            <elementProp name="new-variations-attribute-set-id" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value"/>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">new-variations-attribute-set-id</stringProp>
+            </elementProp>
+            <elementProp name="product[shipment_type]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">0</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[shipment_type]</stringProp>
+            </elementProp>
+            <elementProp name="bundle_options[bundle_options][0][title]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">option title one</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">bundle_options[bundle_options][0][title]</stringProp>
+            </elementProp>
+            <elementProp name="bundle_options[bundle_options][0][option_id]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value"/>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">bundle_options[bundle_options][0][option_id]</stringProp>
+            </elementProp>
+            <elementProp name="bundle_options[bundle_options][0][delete]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value"/>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">bundle_options[bundle_options][0][delete]</stringProp>
+            </elementProp>
+            <elementProp name="bundle_options[bundle_options][0][type]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">select</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">bundle_options[bundle_options][0][type]</stringProp>
+            </elementProp>
+            <elementProp name="bundle_options[bundle_options][0][required]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">1</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">bundle_options[bundle_options][0][required]</stringProp>
+            </elementProp>
+            <elementProp name="bundle_options[bundle_options][0][position]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">0</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">bundle_options[bundle_options][0][position]</stringProp>
+            </elementProp>
+            <elementProp name="bundle_options[bundle_options][0][bundle_selections][0][selection_id]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value"/>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">bundle_options[bundle_options][0][bundle_selections][0][selection_id]</stringProp>
+            </elementProp>
+            <elementProp name="bundle_options[bundle_options][0][bundle_selections][0][option_id]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value"/>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">bundle_options[bundle_options][0][bundle_selections][0][option_id]</stringProp>
+            </elementProp>
+            <elementProp name="bundle_options[bundle_options][0][bundle_selections][0][product_id]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">${simple_product_1_id}</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">bundle_options[bundle_options][0][bundle_selections][0][product_id]</stringProp>
+            </elementProp>
+            <elementProp name="bundle_options[bundle_options][0][bundle_selections][0][delete]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value"/>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">bundle_options[bundle_options][0][bundle_selections][0][delete]</stringProp>
+            </elementProp>
+            <elementProp name="bundle_options[bundle_options][0][bundle_selections][0][selection_price_value]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">25</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">bundle_options[bundle_options][0][bundle_selections][0][selection_price_value]</stringProp>
+            </elementProp>
+            <elementProp name="bundle_options[bundle_options][0][bundle_selections][0][selection_price_type]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">1</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">bundle_options[bundle_options][0][bundle_selections][0][selection_price_type]</stringProp>
+            </elementProp>
+            <elementProp name="bundle_options[bundle_options][0][bundle_selections][0][selection_qty]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">1</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">bundle_options[bundle_options][0][bundle_selections][0][selection_qty]</stringProp>
+            </elementProp>
+            <elementProp name="bundle_options[bundle_options][0][bundle_selections][0][selection_can_change_qty]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">1</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">bundle_options[bundle_options][0][bundle_selections][0][selection_can_change_qty]</stringProp>
+            </elementProp>
+            <elementProp name="bundle_options[bundle_options][0][bundle_selections][0][position]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">0</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">bundle_options[bundle_options][0][bundle_selections][0][position]</stringProp>
+            </elementProp>
+            <elementProp name="bundle_options[bundle_options][0][bundle_selections][1][selection_id]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value"/>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">bundle_options[bundle_options][0][bundle_selections][1][selection_id]</stringProp>
+            </elementProp>
+            <elementProp name="bundle_options[bundle_options][0][bundle_selections][1][option_id]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value"/>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">bundle_options[bundle_options][0][bundle_selections][1][option_id]</stringProp>
+            </elementProp>
+            <elementProp name="bundle_options[bundle_options][0][bundle_selections][1][product_id]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">${simple_product_2_id}</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">bundle_options[bundle_options][0][bundle_selections][1][product_id]</stringProp>
+            </elementProp>
+            <elementProp name="bundle_options[bundle_options][0][bundle_selections][1][delete]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value"/>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">bundle_options[bundle_options][0][bundle_selections][1][delete]</stringProp>
+            </elementProp>
+            <elementProp name="bundle_options[bundle_options][0][bundle_selections][1][selection_price_value]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">10.99</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">bundle_options[bundle_options][0][bundle_selections][1][selection_price_value]</stringProp>
+            </elementProp>
+            <elementProp name="bundle_options[bundle_options][0][bundle_selections][1][selection_price_type]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">0</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">bundle_options[bundle_options][0][bundle_selections][1][selection_price_type]</stringProp>
+            </elementProp>
+            <elementProp name="bundle_options[bundle_options][0][bundle_selections][1][selection_qty]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">1</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">bundle_options[bundle_options][0][bundle_selections][1][selection_qty]</stringProp>
+            </elementProp>
+            <elementProp name="bundle_options[bundle_options][0][bundle_selections][1][selection_can_change_qty]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">1</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">bundle_options[bundle_options][0][bundle_selections][1][selection_can_change_qty]</stringProp>
+            </elementProp>
+            <elementProp name="bundle_options[bundle_options][0][bundle_selections][1][position]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">1</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">bundle_options[bundle_options][0][bundle_selections][1][position]</stringProp>
+            </elementProp>
+            <elementProp name="bundle_options[bundle_options][1][title]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">option title two</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">bundle_options[bundle_options][1][title]</stringProp>
+            </elementProp>
+            <elementProp name="bundle_options[bundle_options][1][option_id]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value"/>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">bundle_options[bundle_options][1][option_id]</stringProp>
+            </elementProp>
+            <elementProp name="bundle_options[bundle_options][1][delete]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value"/>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">bundle_options[bundle_options][1][delete]</stringProp>
+            </elementProp>
+            <elementProp name="bundle_options[bundle_options][1][type]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">select</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">bundle_options[bundle_options][1][type]</stringProp>
             </elementProp>
-            <stringProp name="HTTPSampler.domain"/>
-            <stringProp name="HTTPSampler.port"/>
-            <stringProp name="HTTPSampler.connect_timeout"/>
-            <stringProp name="HTTPSampler.response_timeout"/>
-            <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
-            <stringProp name="HTTPSampler.contentEncoding"/>
-            <stringProp name="HTTPSampler.path">${base_path}${product_url_key}${url_suffix}</stringProp>
-            <stringProp name="HTTPSampler.method">GET</stringProp>
-            <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
-            <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
-            <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
-            <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
-            <boolProp name="HTTPSampler.monitor">false</boolProp>
-            <stringProp name="HTTPSampler.embedded_url_re"/>
-        <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/product_browsing_and_adding_items_to_the_cart/product_view.jmx</stringProp></HTTPSamplerProxy>
-        <hashTree>
-            <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Response Assertion" enabled="true">
-                <collectionProp name="Asserion.test_strings">
-                    <stringProp name="-1787050162">&lt;span&gt;In stock&lt;/span&gt;</stringProp>
-                </collectionProp>
-                <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
-                <boolProp name="Assertion.assume_success">false</boolProp>
-                <intProp name="Assertion.test_type">2</intProp>
-            </ResponseAssertion>
-            <hashTree/>
-        </hashTree>
-    </hashTree>
-  
-    <LoopController guiclass="LoopControlPanel" testclass="LoopController" testname="View Configurable Products" enabled="true">
-      <boolProp name="LoopController.continue_forever">true</boolProp>
-      <stringProp name="LoopController.loops">1</stringProp>
-    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/loop_controller.jmx</stringProp></LoopController>
-    <hashTree>
-      <CounterConfig guiclass="CounterConfigGui" testclass="CounterConfig" testname="Counter" enabled="true">
-        <stringProp name="CounterConfig.start">1</stringProp>
-        <stringProp name="CounterConfig.end"/>
-        <stringProp name="CounterConfig.incr">1</stringProp>
-        <stringProp name="CounterConfig.name">_counter</stringProp>
-        <stringProp name="CounterConfig.format"/>
-        <boolProp name="CounterConfig.per_user">true</boolProp>
-        <boolProp name="CounterConfig.reset_on_tg_iteration">true</boolProp>
-      </CounterConfig>
-      <hashTree/>
-    
-    <BeanShellSampler guiclass="BeanShellSamplerGui" testclass="BeanShellSampler" testname="SetUp - Prepare Configurable Product Data" enabled="true">
-      <stringProp name="BeanShellSampler.query">
-import java.util.Random;
-
-Random random = vars.getObject("randomIntGenerator");
-number = random.nextInt(props.get("configurable_products_list").size());
-product = props.get("configurable_products_list").get(number);
-
-vars.put("product_url_key", product.get("url_key"));
-vars.put("product_id", product.get("id"));
-vars.put("product_name", product.get("title"));
-vars.put("product_uenc", product.get("uenc"));
-vars.put("product_sku", product.get("sku"));
-      </stringProp>
-      <stringProp name="BeanShellSampler.filename"/>
-      <stringProp name="BeanShellSampler.parameters"/>
-      <boolProp name="BeanShellSampler.resetInterpreter">true</boolProp>
-    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/product_browsing_and_adding_items_to_the_cart/configurable_products_setup.jmx</stringProp></BeanShellSampler>
-    <hashTree/>
-  
-        <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Configurable Product ${_counter} View" enabled="true">
-            <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
-                <collectionProp name="Arguments.arguments"/>
+            <elementProp name="bundle_options[bundle_options][1][required]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">1</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">bundle_options[bundle_options][1][required]</stringProp>
             </elementProp>
-            <stringProp name="HTTPSampler.domain"/>
-            <stringProp name="HTTPSampler.port"/>
-            <stringProp name="HTTPSampler.connect_timeout"/>
-            <stringProp name="HTTPSampler.response_timeout"/>
-            <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
-            <stringProp name="HTTPSampler.contentEncoding"/>
-            <stringProp name="HTTPSampler.path">${base_path}${product_url_key}${url_suffix}</stringProp>
-            <stringProp name="HTTPSampler.method">GET</stringProp>
-            <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
-            <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
-            <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
-            <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
-            <boolProp name="HTTPSampler.monitor">false</boolProp>
-            <stringProp name="HTTPSampler.embedded_url_re"/>
-        <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/product_browsing_and_adding_items_to_the_cart/product_view.jmx</stringProp></HTTPSamplerProxy>
-        <hashTree>
-            <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Response Assertion" enabled="true">
-                <collectionProp name="Asserion.test_strings">
-                    <stringProp name="-1787050162">&lt;span&gt;In stock&lt;/span&gt;</stringProp>
-                </collectionProp>
-                <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
-                <boolProp name="Assertion.assume_success">false</boolProp>
-                <intProp name="Assertion.test_type">2</intProp>
-            </ResponseAssertion>
-            <hashTree/>
-        </hashTree>
-    </hashTree>
-  </hashTree>
-
-  
-    <ThroughputController guiclass="ThroughputControllerGui" testclass="ThroughputController" testname="Add To Cart By Customer" enabled="true">
-      <intProp name="ThroughputController.style">1</intProp>
-      <boolProp name="ThroughputController.perThread">false</boolProp>
-      <intProp name="ThroughputController.maxThroughput">1</intProp>
-      <stringProp name="ThroughputController.percentThroughput">${addToCartByCustomerPercentage}</stringProp>
-    <stringProp name="TestPlan.comments">mpaf/tool/fragments/_system/scenario_controller_tmpl.jmx</stringProp></ThroughputController>
-    <hashTree>
-        <JSR223PreProcessor guiclass="TestBeanGUI" testclass="JSR223PreProcessor" testname="Set Test Label" enabled="true">
-            <stringProp name="script">
-var testLabel = "${testLabel}" ? " (${testLabel})" : "";
-if (testLabel
-    &amp;&amp; sampler.getClass().getName() == 'org.apache.jmeter.protocol.http.sampler.HTTPSamplerProxy'
-) {
-    if (sampler.getName().indexOf(testLabel) == -1) {
-       sampler.setName(sampler.getName() + testLabel);
-    }
-} else if (sampler.getName().indexOf("SetUp - ") == -1) {
-    sampler.setName("SetUp - " + sampler.getName());
-}
-            </stringProp>
-            <stringProp name="scriptLanguage">javascript</stringProp>
-        <stringProp name="TestPlan.comments">mpaf/tool/fragments/_system/setup_label.jmx</stringProp></JSR223PreProcessor>
-        <hashTree/>
-        <BeanShellSampler guiclass="BeanShellSamplerGui" testclass="BeanShellSampler" testname="SetUp - Set Label" enabled="true">
-            <stringProp name="BeanShellSampler.query">
-                vars.put("testLabel", "Add To Cart By Customer");
-            </stringProp>
-            <boolProp name="BeanShellSampler.resetInterpreter">true</boolProp>
-        </BeanShellSampler>
-        <hashTree/>
-    
-    <CookieManager guiclass="CookiePanel" testclass="CookieManager" testname="HTTP Cookie Manager" enabled="true">
-      <collectionProp name="CookieManager.cookies">
-        <elementProp name="product_list_limit" elementType="Cookie" testname="product_list_limit">
-          <stringProp name="Cookie.value">30</stringProp>
-          <stringProp name="Cookie.domain">${host}</stringProp>
-          <stringProp name="Cookie.path">/</stringProp>
-          <boolProp name="Cookie.secure">false</boolProp>
-          <longProp name="Cookie.expires">0</longProp>
-          <boolProp name="Cookie.path_specified">true</boolProp>
-          <boolProp name="Cookie.domain_specified">true</boolProp>
-        </elementProp>
-        <elementProp name="product_list_limit" elementType="Cookie" testname="form_key">
-          <stringProp name="Cookie.value">${form_key}</stringProp>
-          <stringProp name="Cookie.domain">${host}</stringProp>
-          <stringProp name="Cookie.path">${base_path}</stringProp>
-          <boolProp name="Cookie.secure">false</boolProp>
-          <longProp name="Cookie.expires">0</longProp>
-          <boolProp name="Cookie.path_specified">true</boolProp>
-          <boolProp name="Cookie.domain_specified">true</boolProp>
-        </elementProp>
-      </collectionProp>
-      <boolProp name="CookieManager.clearEachIteration">true</boolProp>
-    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/http_cookie_manager.jmx</stringProp></CookieManager>
-    <hashTree/>
-  
-      <BeanShellSampler guiclass="BeanShellSamplerGui" testclass="BeanShellSampler" testname="SetUp - Init Random Generator" enabled="true">
-        <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/common/init_random_generator_setup.jmx</stringProp>
-        <stringProp name="BeanShellSampler.query">
-import java.util.Random;
-
-Random random = new Random();
-if (${seedForRandom} &gt; 0) {
-    random.setSeed(${seedForRandom} + ${__threadNum});
-}
-
-vars.putObject("randomIntGenerator", random);
-        </stringProp>
-        <stringProp name="BeanShellSampler.filename"/>
-        <stringProp name="BeanShellSampler.parameters"/>
-        <boolProp name="BeanShellSampler.resetInterpreter">true</boolProp>
-      </BeanShellSampler>
-      <hashTree/>
-    
-      <BeanShellSampler guiclass="BeanShellSamplerGui" testclass="BeanShellSampler" testname="SetUp - Init Total Products In Cart" enabled="true">
-        <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/common/init_total_products_in_cart_setup.jmx</stringProp>
-        <stringProp name="BeanShellSampler.query">
-vars.put("totalProductsAdded", "0");
-        </stringProp>
-        <stringProp name="BeanShellSampler.filename"/>
-        <stringProp name="BeanShellSampler.parameters"/>
-        <boolProp name="BeanShellSampler.resetInterpreter">true</boolProp>
-      </BeanShellSampler>
-      <hashTree/>
-    
-      <BeanShellSampler guiclass="BeanShellSamplerGui" testclass="BeanShellSampler" testname="SetUp - Prepare Category Data" enabled="true">
-        <stringProp name="BeanShellSampler.query">
-import java.util.Random;
-
-Random random = vars.getObject("randomIntGenerator");
-number = random.nextInt(props.get("category_url_keys_list").size());
-
-vars.put("category_url_key", props.get("category_url_keys_list").get(number));
-vars.put("category_name", props.get("category_names_list").get(number));
-        </stringProp>
-        <stringProp name="BeanShellSampler.filename"/>
-        <stringProp name="BeanShellSampler.parameters"/>
-        <boolProp name="BeanShellSampler.resetInterpreter">false</boolProp>
-      <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/common/extract_category_setup.jmx</stringProp></BeanShellSampler>
-      <hashTree/>
-    
-    <BeanShellSampler guiclass="BeanShellSamplerGui" testclass="BeanShellSampler" testname="SetUp - Get Customer Email" enabled="true">
-      <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/get_customer_email.jmx</stringProp>
-      <stringProp name="BeanShellSampler.query">import org.apache.jmeter.samplers.SampleResult;
-
-String siterator = vars.get("customer_emails_index");
-int iterator;
-if(siterator == null){
-    iterator = 0;
-    vars.put("customer_emails_index", "0");
-} else {
-    iterator = Integer.parseInt(siterator);
-    iterator ++;
-    vars.put("customer_emails_index", iterator.toString());
-}
-
-emails_list = props.get("customer_emails_list");
-
-threadsNumber = ctx.getThreadGroup().getNumThreads();
-emailsCount = emails_list.size();
-if (threadsNumber &gt; emailsCount) {
-    log.error(" There are not enough customers for this scenario.");
-} else {
-    clusterLength = Math.round(emailsCount / threadsNumber);
-    threadNum = ctx.getThreadNum();
-    emails_index = clusterLength * threadNum + iterator;
-    maxLimit = clusterLength * (threadNum + 1);
-    if (emails_index &gt;= maxLimit) {
-        iterator = 0;
-        emails_index = clusterLength * threadNum + iterator;
-        vars.put("customer_emails_index", iterator.toString());
-    }
-}
-vars.put("customer_email", emails_list.get(emails_index));</stringProp>
-      <stringProp name="BeanShellSampler.filename"/>
-      <stringProp name="BeanShellSampler.parameters"/>
-      <boolProp name="BeanShellSampler.resetInterpreter">true</boolProp>
-    </BeanShellSampler>
-    <hashTree/>
-  
-    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Open Login Page" enabled="true">
-      <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
-        <collectionProp name="Arguments.arguments"/>
-      </elementProp>
-      <stringProp name="HTTPSampler.domain"/>
-      <stringProp name="HTTPSampler.port"/>
-      <stringProp name="HTTPSampler.connect_timeout"/>
-      <stringProp name="HTTPSampler.response_timeout"/>
-      <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
-      <stringProp name="HTTPSampler.contentEncoding"/>
-      <stringProp name="HTTPSampler.path">${base_path}customer/account/login/</stringProp>
-      <stringProp name="HTTPSampler.method">GET</stringProp>
-      <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
-      <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
-      <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
-      <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
-      <boolProp name="HTTPSampler.monitor">false</boolProp>
-      <stringProp name="HTTPSampler.embedded_url_re"/>
-    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/common/open_login_page.jmx</stringProp></HTTPSamplerProxy>
-    <hashTree>
-      <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Response Assertion" enabled="true">
-        <collectionProp name="Asserion.test_strings">
-          <stringProp name="637394530">&lt;title&gt;Customer Login&lt;/title&gt;</stringProp>
-        </collectionProp>
-        <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
-        <boolProp name="Assertion.assume_success">false</boolProp>
-        <intProp name="Assertion.test_type">2</intProp>
-      </ResponseAssertion>
-      <hashTree/>
-    </hashTree>
-  
-    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Login" enabled="true">
-      <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
-        <collectionProp name="Arguments.arguments">
-          <elementProp name="form_key" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">${form_key}</stringProp>
-            <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">form_key</stringProp>
-          </elementProp>
-          <elementProp name="login[username]" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">${customer_email}</stringProp>
-            <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">login[username]</stringProp>
-          </elementProp>
-          <elementProp name="login[password]" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">${customer_password}</stringProp>
-            <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">login[password]</stringProp>
-          </elementProp>
-          <elementProp name="send" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value"/>
-            <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">send</stringProp>
-          </elementProp>
-        </collectionProp>
-      </elementProp>
-      <stringProp name="HTTPSampler.domain"/>
-      <stringProp name="HTTPSampler.port"/>
-      <stringProp name="HTTPSampler.connect_timeout"/>
-      <stringProp name="HTTPSampler.response_timeout"/>
-      <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
-      <stringProp name="HTTPSampler.contentEncoding"/>
-      <stringProp name="HTTPSampler.path">${base_path}customer/account/loginPost/</stringProp>
-      <stringProp name="HTTPSampler.method">POST</stringProp>
-      <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
-      <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
-      <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
-      <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
-      <boolProp name="HTTPSampler.monitor">false</boolProp>
-      <stringProp name="HTTPSampler.embedded_url_re"/>
-    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/common/login.jmx</stringProp></HTTPSamplerProxy>
-    <hashTree>
-      <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Response Assertion" enabled="true">
-        <collectionProp name="Asserion.test_strings">
-          <stringProp name="1312950388">&lt;title&gt;My Account&lt;/title&gt;</stringProp>
-        </collectionProp>
-        <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
-        <boolProp name="Assertion.assume_success">false</boolProp>
-        <intProp name="Assertion.test_type">2</intProp>
-      </ResponseAssertion>
-      <hashTree/>
-      <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract Address" enabled="true">
-        <stringProp name="RegexExtractor.useHeaders">false</stringProp>
-        <stringProp name="RegexExtractor.refname">addressId</stringProp>
-        <stringProp name="RegexExtractor.regex">customer/address/edit/id/([^'"]+)/</stringProp>
-        <stringProp name="RegexExtractor.template">$1$</stringProp>
-        <stringProp name="RegexExtractor.default"/>
-        <stringProp name="RegexExtractor.match_number">1</stringProp>
-      </RegexExtractor>
-      <hashTree/>
-      <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert addressId extracted" enabled="true">
-        <collectionProp name="Asserion.test_strings">
-          <stringProp name="2845929">^.+$</stringProp>
-        </collectionProp>
-        <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
-        <boolProp name="Assertion.assume_success">false</boolProp>
-        <intProp name="Assertion.test_type">1</intProp>
-        <stringProp name="Assertion.scope">variable</stringProp>
-        <stringProp name="Scope.variable">addressId</stringProp>
-      </ResponseAssertion>
-      <hashTree/>
-    </hashTree>
-    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Load Customer Private Data" enabled="true">
-      <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
-        <collectionProp name="Arguments.arguments">
-          <elementProp name="sections" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value"/>
-            <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">sections</stringProp>
-          </elementProp>
-          <elementProp name="update_section_id" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">false</stringProp>
-            <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">update_section_id</stringProp>
-          </elementProp>
-          <elementProp name="_" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">${__time()}${__Random(1,1000000)}</stringProp>
-            <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">_</stringProp>
-          </elementProp>
-        </collectionProp>
-      </elementProp>
-      <stringProp name="HTTPSampler.domain"/>
-      <stringProp name="HTTPSampler.port"/>
-      <stringProp name="HTTPSampler.connect_timeout"/>
-      <stringProp name="HTTPSampler.response_timeout"/>
-      <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
-      <stringProp name="HTTPSampler.contentEncoding"/>
-      <stringProp name="HTTPSampler.path">${base_path}customer/section/load/</stringProp>
-      <stringProp name="HTTPSampler.method">GET</stringProp>
-      <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
-      <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
-      <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
-      <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
-      <boolProp name="HTTPSampler.monitor">false</boolProp>
-      <stringProp name="HTTPSampler.embedded_url_re"/>
-    </HTTPSamplerProxy>
-    <hashTree/>
-  
-      <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Open Home Page" enabled="true">
-        <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
-          <collectionProp name="Arguments.arguments"/>
+            <elementProp name="bundle_options[bundle_options][1][position]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">1</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">bundle_options[bundle_options][1][position]</stringProp>
+            </elementProp>
+            <elementProp name="bundle_options[bundle_options][1][bundle_selections][0][selection_id]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value"/>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">bundle_options[bundle_options][1][bundle_selections][0][selection_id]</stringProp>
+              <stringProp name="Argument.desc">true</stringProp>
+            </elementProp>
+            <elementProp name="bundle_options[bundle_options][1][bundle_selections][0][option_id]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value"/>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">bundle_options[bundle_options][1][bundle_selections][0][option_id]</stringProp>
+              <stringProp name="Argument.desc">true</stringProp>
+            </elementProp>
+            <elementProp name="bundle_options[bundle_options][1][bundle_selections][0][product_id]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">${simple_product_1_id}</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">bundle_options[bundle_options][1][bundle_selections][0][product_id]</stringProp>
+              <stringProp name="Argument.desc">true</stringProp>
+            </elementProp>
+            <elementProp name="bundle_options[bundle_options][1][bundle_selections][0][delete]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value"/>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">bundle_options[bundle_options][1][bundle_selections][0][delete]</stringProp>
+              <stringProp name="Argument.desc">true</stringProp>
+            </elementProp>
+            <elementProp name="bundle_options[bundle_options][1][bundle_selections][0][selection_price_value]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">5.00</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">bundle_options[bundle_options][1][bundle_selections][0][selection_price_value]</stringProp>
+              <stringProp name="Argument.desc">true</stringProp>
+            </elementProp>
+            <elementProp name="bundle_options[bundle_options][1][bundle_selections][0][selection_price_type]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">0</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">bundle_options[bundle_options][1][bundle_selections][0][selection_price_type]</stringProp>
+              <stringProp name="Argument.desc">true</stringProp>
+            </elementProp>
+            <elementProp name="bundle_options[bundle_options][1][bundle_selections][0][selection_qty]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">1</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">bundle_options[bundle_options][1][bundle_selections][0][selection_qty]</stringProp>
+              <stringProp name="Argument.desc">true</stringProp>
+            </elementProp>
+            <elementProp name="bundle_options[bundle_options][1][bundle_selections][0][selection_can_change_qty]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">1</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">bundle_options[bundle_options][1][bundle_selections][0][selection_can_change_qty]</stringProp>
+              <stringProp name="Argument.desc">true</stringProp>
+            </elementProp>
+            <elementProp name="bundle_options[bundle_options][1][bundle_selections][0][position]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">0</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">bundle_options[bundle_options][1][bundle_selections][0][position]</stringProp>
+              <stringProp name="Argument.desc">true</stringProp>
+            </elementProp>
+            <elementProp name="bundle_options[bundle_options][1][bundle_selections][1][selection_id]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value"/>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">bundle_options[bundle_options][1][bundle_selections][1][selection_id]</stringProp>
+              <stringProp name="Argument.desc">true</stringProp>
+            </elementProp>
+            <elementProp name="bundle_options[bundle_options][1][bundle_selections][1][option_id]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value"/>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">bundle_options[bundle_options][1][bundle_selections][1][option_id]</stringProp>
+              <stringProp name="Argument.desc">true</stringProp>
+            </elementProp>
+            <elementProp name="bundle_options[bundle_options][1][bundle_selections][1][product_id]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">${simple_product_2_id}</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">bundle_options[bundle_options][1][bundle_selections][1][product_id]</stringProp>
+              <stringProp name="Argument.desc">true</stringProp>
+            </elementProp>
+            <elementProp name="bundle_options[bundle_options][1][bundle_selections][1][delete]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value"/>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">bundle_options[bundle_options][1][bundle_selections][1][delete]</stringProp>
+              <stringProp name="Argument.desc">true</stringProp>
+            </elementProp>
+            <elementProp name="bundle_options[bundle_options][1][bundle_selections][1][selection_price_value]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">7.00</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">bundle_options[bundle_options][1][bundle_selections][1][selection_price_value]</stringProp>
+              <stringProp name="Argument.desc">true</stringProp>
+            </elementProp>
+            <elementProp name="bundle_options[bundle_options][1][bundle_selections][1][selection_price_type]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">0</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">bundle_options[bundle_options][1][bundle_selections][1][selection_price_type]</stringProp>
+              <stringProp name="Argument.desc">true</stringProp>
+            </elementProp>
+            <elementProp name="bundle_options[bundle_options][1][bundle_selections][1][selection_qty]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">1</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">bundle_options[bundle_options][1][bundle_selections][1][selection_qty]</stringProp>
+              <stringProp name="Argument.desc">true</stringProp>
+            </elementProp>
+            <elementProp name="bundle_options[bundle_options][1][bundle_selections][1][selection_can_change_qty]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">1</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">bundle_options[bundle_options][1][bundle_selections][1][selection_can_change_qty]</stringProp>
+              <stringProp name="Argument.desc">true</stringProp>
+            </elementProp>
+            <elementProp name="bundle_options[bundle_options][1][bundle_selections][1][position]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">1</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">bundle_options[bundle_options][1][bundle_selections][1][position]</stringProp>
+              <stringProp name="Argument.desc">true</stringProp>
+            </elementProp>
+            <elementProp name="affect_bundle_product_selections" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">2</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">affect_bundle_product_selections</stringProp>
+              <stringProp name="Argument.desc">true</stringProp>
+            </elementProp>
+            <elementProp name="links[related][0][id]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">${related_product_id}</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">links[related][0][id]</stringProp>
+            </elementProp>
+            <elementProp name="links[related][0][position]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">1</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">links[related][0][position]</stringProp>
+            </elementProp>
+            <elementProp name="links[upsell][0][id]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">${related_product_id}</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">links[upsell][0][id]</stringProp>
+            </elementProp>
+            <elementProp name="links[upsell][0][position]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">1</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">links[upsell][0][position]</stringProp>
+            </elementProp>
+            <elementProp name="links[crosssell][0][id]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">${related_product_id}</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">links[crosssell][0][id]</stringProp>
+            </elementProp>
+            <elementProp name="links[crosssell][0][position]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">1</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">links[crosssell][0][position]</stringProp>
+            </elementProp>
+          </collectionProp>
         </elementProp>
         <stringProp name="HTTPSampler.domain"/>
         <stringProp name="HTTPSampler.port"/>
@@ -29971,19 +22070,19 @@ vars.put("customer_email", emails_list.get(emails_index));</stringProp>
         <stringProp name="HTTPSampler.response_timeout"/>
         <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
         <stringProp name="HTTPSampler.contentEncoding"/>
-        <stringProp name="HTTPSampler.path">${base_path}</stringProp>
-        <stringProp name="HTTPSampler.method">GET</stringProp>
+        <stringProp name="HTTPSampler.path">${base_path}${admin_path}/catalog/product/validate/set/4/</stringProp>
+        <stringProp name="HTTPSampler.method">POST</stringProp>
         <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
         <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
         <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
         <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
         <boolProp name="HTTPSampler.monitor">false</boolProp>
         <stringProp name="HTTPSampler.embedded_url_re"/>
-      <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/common/open_home_page.jmx</stringProp></HTTPSamplerProxy>
+      </HTTPSamplerProxy>
       <hashTree>
         <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Response Assertion" enabled="true">
           <collectionProp name="Asserion.test_strings">
-            <stringProp name="571386695">&lt;title&gt;Home page&lt;/title&gt;</stringProp>
+            <stringProp name="1853918323">{"error":false}</stringProp>
           </collectionProp>
           <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
           <boolProp name="Assertion.assume_success">false</boolProp>
@@ -29991,389 +22090,911 @@ vars.put("customer_email", emails_list.get(emails_index));</stringProp>
         </ResponseAssertion>
         <hashTree/>
       </hashTree>
-  
-    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Open Category" enabled="true">
-      <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
-        <collectionProp name="Arguments.arguments"/>
-      </elementProp>
-      <stringProp name="HTTPSampler.domain"/>
-      <stringProp name="HTTPSampler.port"/>
-      <stringProp name="HTTPSampler.connect_timeout"/>
-      <stringProp name="HTTPSampler.response_timeout"/>
-      <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
-      <stringProp name="HTTPSampler.contentEncoding"/>
-      <stringProp name="HTTPSampler.path">${base_path}${category_url_key}${url_suffix}</stringProp>
-      <stringProp name="HTTPSampler.method">GET</stringProp>
-      <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
-      <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
-      <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
-      <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
-      <boolProp name="HTTPSampler.monitor">false</boolProp>
-      <stringProp name="HTTPSampler.embedded_url_re"/>
-    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/common/open_category.jmx</stringProp></HTTPSamplerProxy>
-    <hashTree>
-      <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Response Assertion" enabled="true">
-        <collectionProp name="Asserion.test_strings">
-          <stringProp name="1210004667">&lt;span class="base" data-ui-id="page-title"&gt;${category_name}&lt;/span&gt;</stringProp>
-        </collectionProp>
-        <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
-        <boolProp name="Assertion.assume_success">false</boolProp>
-        <intProp name="Assertion.test_type">6</intProp>
-      </ResponseAssertion>
-      <hashTree/>
-      <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Regular Expression Extractor: Extract category id" enabled="true">
-        <stringProp name="RegexExtractor.useHeaders">false</stringProp>
-        <stringProp name="RegexExtractor.refname">category_id</stringProp>
-        <stringProp name="RegexExtractor.regex">&lt;li class="item category([^'"]+)"&gt;\s*&lt;strong&gt;${category_name}&lt;/strong&gt;\s*&lt;/li&gt;</stringProp>
-        <stringProp name="RegexExtractor.template">$1$</stringProp>
-        <stringProp name="RegexExtractor.default"/>
-        <stringProp name="RegexExtractor.match_number">1</stringProp>
-        <stringProp name="Scope.variable">simple_product_1_url_key</stringProp>
-      </RegexExtractor>
-      <hashTree/>
-      <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Response Assertion: Assert category id" enabled="true">
-        <collectionProp name="Asserion.test_strings">
-          <stringProp name="1191417111">^[0-9]+$</stringProp>
-        </collectionProp>
-        <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
-        <boolProp name="Assertion.assume_success">false</boolProp>
-        <intProp name="Assertion.test_type">1</intProp>
-        <stringProp name="Assertion.scope">variable</stringProp>
-        <stringProp name="Scope.variable">category_id</stringProp>
-      </ResponseAssertion>
-      <hashTree/>
-    </hashTree>
-  
-    <LoopController guiclass="LoopControlPanel" testclass="LoopController" testname="Add Simple Products to Cart" enabled="true">
-      <boolProp name="LoopController.continue_forever">true</boolProp>
-      <stringProp name="LoopController.loops">2</stringProp>
-    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/loop_controller.jmx</stringProp></LoopController>
-    <hashTree>
-      <CounterConfig guiclass="CounterConfigGui" testclass="CounterConfig" testname="Counter" enabled="true">
-        <stringProp name="CounterConfig.start">1</stringProp>
-        <stringProp name="CounterConfig.end"/>
-        <stringProp name="CounterConfig.incr">1</stringProp>
-        <stringProp name="CounterConfig.name">_counter</stringProp>
-        <stringProp name="CounterConfig.format"/>
-        <boolProp name="CounterConfig.per_user">true</boolProp>
-        <boolProp name="CounterConfig.reset_on_tg_iteration">true</boolProp>
-      </CounterConfig>
-      <hashTree/>
-    
-    <BeanShellSampler guiclass="BeanShellSamplerGui" testclass="BeanShellSampler" testname="SetUp - Prepare Simple Product Data" enabled="true">
-      <stringProp name="BeanShellSampler.query">
-import java.util.Random;
-
-Random random = vars.getObject("randomIntGenerator");
-number = random.nextInt(props.get("simple_products_list").size());
-product = props.get("simple_products_list").get(number);
-
-vars.put("product_url_key", product.get("url_key"));
-vars.put("product_id", product.get("id"));
-vars.put("product_name", product.get("title"));
-vars.put("product_uenc", product.get("uenc"));
-vars.put("product_sku", product.get("sku"));
-      </stringProp>
-      <stringProp name="BeanShellSampler.filename"/>
-      <stringProp name="BeanShellSampler.parameters"/>
-      <boolProp name="BeanShellSampler.resetInterpreter">true</boolProp>
-    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/product_browsing_and_adding_items_to_the_cart/simple_products_setup.jmx</stringProp></BeanShellSampler>
-    <hashTree/>
-  
-    <BeanShellSampler guiclass="BeanShellSamplerGui" testclass="BeanShellSampler" testname="SetUp - Update Products Added Counter" enabled="true">
-      <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/loops/update_products_added_counter.jmx</stringProp>
-      <stringProp name="BeanShellSampler.query">
-productsAdded = Integer.parseInt(vars.get("totalProductsAdded"));
-productsAdded = productsAdded + 1;
-
-vars.put("totalProductsAdded", String.valueOf(productsAdded));
-      </stringProp>
-      <stringProp name="BeanShellSampler.filename"/>
-      <stringProp name="BeanShellSampler.parameters"/>
-      <boolProp name="BeanShellSampler.resetInterpreter">true</boolProp>
-    </BeanShellSampler>
-    <hashTree/>
-  
-        <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Simple Product ${_counter} View" enabled="true">
-            <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
-                <collectionProp name="Arguments.arguments"/>
+      <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="New Bundle Product Save" enabled="true">
+        <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
+          <collectionProp name="Arguments.arguments">
+            <elementProp name="ajax" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">true</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">ajax</stringProp>
+              <stringProp name="Argument.desc">false</stringProp>
+            </elementProp>
+            <elementProp name="isAjax" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">true</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">isAjax</stringProp>
+              <stringProp name="Argument.desc">false</stringProp>
+            </elementProp>
+            <elementProp name="form_key" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">${admin_form_key}</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">form_key</stringProp>
+              <stringProp name="Argument.desc">false</stringProp>
+            </elementProp>
+            <elementProp name="product[name]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">Bundle Product ${__time(YMDHMS)}-${__threadNum}-${__Random(1,1000000)}</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[name]</stringProp>
+              <stringProp name="Argument.desc">false</stringProp>
+            </elementProp>
+            <elementProp name="product[sku]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">Bundle Product ${__time(YMDHMS)}-${__threadNum}-${__Random(1,1000000)}</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[sku]</stringProp>
+              <stringProp name="Argument.desc">false</stringProp>
+            </elementProp>
+            <elementProp name="product[price]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">42</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[price]</stringProp>
+            </elementProp>
+            <elementProp name="product[tax_class_id]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">2</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[tax_class_id]</stringProp>
+            </elementProp>
+            <elementProp name="product[quantity_and_stock_status][qty]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">111</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[quantity_and_stock_status][qty]</stringProp>
+            </elementProp>
+            <elementProp name="product[quantity_and_stock_status][is_in_stock]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">1</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[quantity_and_stock_status][is_in_stock]</stringProp>
+            </elementProp>
+            <elementProp name="product[weight]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">1.0000</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[weight]</stringProp>
+            </elementProp>
+            <elementProp name="product[product_has_weight]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">1</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[product_has_weight]</stringProp>
+              <stringProp name="Argument.desc">true</stringProp>
+            </elementProp>
+            <elementProp name="product[category_ids][]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">2</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[category_ids][]</stringProp>
+            </elementProp>
+            <elementProp name="product[description]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">&lt;p&gt;Full bundle product Description ${__time(YMDHMS)}-${__threadNum}-${__Random(1,1000000)}&lt;/p&gt;</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[description]</stringProp>
+            </elementProp>
+            <elementProp name="product[short_description]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">&lt;p&gt;Short bundle product description ${__time(YMDHMS)}-${__threadNum}-${__Random(1,1000000)}&lt;/p&gt;</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[short_description]</stringProp>
+            </elementProp>
+            <elementProp name="product[status]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">1</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[status]</stringProp>
+            </elementProp>
+            <elementProp name="product[configurable_variations]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value"/>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[configurable_variations]</stringProp>
+            </elementProp>
+            <elementProp name="affect_configurable_product_attributes" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">1</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">affect_configurable_product_attributes</stringProp>
+            </elementProp>
+            <elementProp name="product[image]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value"/>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[image]</stringProp>
+            </elementProp>
+            <elementProp name="product[small_image]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value"/>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[small_image]</stringProp>
+            </elementProp>
+            <elementProp name="product[thumbnail]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value"/>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[thumbnail]</stringProp>
+            </elementProp>
+            <elementProp name="product[url_key]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">bundle-product-${__time(YMDHMS)}-${__threadNum}-${__Random(1,1000000)}</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[url_key]</stringProp>
+            </elementProp>
+            <elementProp name="product[meta_title]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">Bundle Product ${__time(YMDHMS)}-${__threadNum}-${__Random(1,1000000)} Meta Title</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[meta_title]</stringProp>
+            </elementProp>
+            <elementProp name="product[meta_keyword]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">Bundle Product ${__time(YMDHMS)}-${__threadNum}-${__Random(1,1000000)} Meta Keyword</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[meta_keyword]</stringProp>
+            </elementProp>
+            <elementProp name="product[meta_description]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">Bundle Product ${__time(YMDHMS)}-${__threadNum}-${__Random(1,1000000)} Meta Description</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[meta_description]</stringProp>
+            </elementProp>
+            <elementProp name="product[website_ids][]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">1</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[website_ids][]</stringProp>
+            </elementProp>
+            <elementProp name="product[special_price]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">99</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[special_price]</stringProp>
+            </elementProp>
+            <elementProp name="product[special_from_date]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value"/>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[special_from_date]</stringProp>
+            </elementProp>
+            <elementProp name="product[special_to_date]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value"/>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[special_to_date]</stringProp>
+            </elementProp>
+            <elementProp name="product[cost]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value"/>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[cost]</stringProp>
+            </elementProp>
+            <elementProp name="product[tier_price][0][website_id]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">0</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[tier_price][0][website_id]</stringProp>
+            </elementProp>
+            <elementProp name="product[tier_price][0][cust_group]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">32000</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[tier_price][0][cust_group]</stringProp>
+            </elementProp>
+            <elementProp name="product[tier_price][0][price_qty]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">100</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[tier_price][0][price_qty]</stringProp>
+            </elementProp>
+            <elementProp name="product[tier_price][0][price]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">90</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[tier_price][0][price]</stringProp>
+            </elementProp>
+            <elementProp name="product[tier_price][0][delete]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value"/>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[tier_price][0][delete]</stringProp>
+            </elementProp>
+            <elementProp name="product[tier_price][1][website_id]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">0</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[tier_price][1][website_id]</stringProp>
+            </elementProp>
+            <elementProp name="product[tier_price][1][cust_group]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">1</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[tier_price][1][cust_group]</stringProp>
+            </elementProp>
+            <elementProp name="product[tier_price][1][price_qty]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">101</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[tier_price][1][price_qty]</stringProp>
+            </elementProp>
+            <elementProp name="product[tier_price][1][price]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">99</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[tier_price][1][price]</stringProp>
+            </elementProp>
+            <elementProp name="product[tier_price][1][delete]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value"/>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[tier_price][1][delete]</stringProp>
+            </elementProp>
+            <elementProp name="product[stock_data][use_config_manage_stock]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">1</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[stock_data][use_config_manage_stock]</stringProp>
+            </elementProp>
+            <elementProp name="product[stock_data][original_inventory_qty]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">100500</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[stock_data][original_inventory_qty]</stringProp>
+            </elementProp>
+            <elementProp name="product[stock_data][qty]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">100500</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[stock_data][qty]</stringProp>
+            </elementProp>
+            <elementProp name="product[stock_data][min_qty]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">0</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[stock_data][min_qty]</stringProp>
+            </elementProp>
+            <elementProp name="product[stock_data][use_config_min_qty]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">1</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[stock_data][use_config_min_qty]</stringProp>
+            </elementProp>
+            <elementProp name="product[stock_data][min_sale_qty]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">1</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[stock_data][min_sale_qty]</stringProp>
+            </elementProp>
+            <elementProp name="product[stock_data][use_config_min_sale_qty]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">1</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[stock_data][use_config_min_sale_qty]</stringProp>
+            </elementProp>
+            <elementProp name="product[stock_data][max_sale_qty]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">10000</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[stock_data][max_sale_qty]</stringProp>
+            </elementProp>
+            <elementProp name="product[stock_data][use_config_max_sale_qty]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">1</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[stock_data][use_config_max_sale_qty]</stringProp>
+            </elementProp>
+            <elementProp name="product[stock_data][is_qty_decimal]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">0</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[stock_data][is_qty_decimal]</stringProp>
+            </elementProp>
+            <elementProp name="product[stock_data][is_decimal_divided]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">0</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[stock_data][is_decimal_divided]</stringProp>
+            </elementProp>
+            <elementProp name="product[stock_data][backorders]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">0</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[stock_data][backorders]</stringProp>
+            </elementProp>
+            <elementProp name="product[stock_data][use_config_backorders]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">1</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[stock_data][use_config_backorders]</stringProp>
+            </elementProp>
+            <elementProp name="product[stock_data][notify_stock_qty]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">1</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[stock_data][notify_stock_qty]</stringProp>
             </elementProp>
-            <stringProp name="HTTPSampler.domain"/>
-            <stringProp name="HTTPSampler.port"/>
-            <stringProp name="HTTPSampler.connect_timeout"/>
-            <stringProp name="HTTPSampler.response_timeout"/>
-            <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
-            <stringProp name="HTTPSampler.contentEncoding"/>
-            <stringProp name="HTTPSampler.path">${base_path}${product_url_key}${url_suffix}</stringProp>
-            <stringProp name="HTTPSampler.method">GET</stringProp>
-            <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
-            <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
-            <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
-            <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
-            <boolProp name="HTTPSampler.monitor">false</boolProp>
-            <stringProp name="HTTPSampler.embedded_url_re"/>
-        <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/product_browsing_and_adding_items_to_the_cart/product_view.jmx</stringProp></HTTPSamplerProxy>
-        <hashTree>
-            <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Response Assertion" enabled="true">
-                <collectionProp name="Asserion.test_strings">
-                    <stringProp name="-1787050162">&lt;span&gt;In stock&lt;/span&gt;</stringProp>
-                </collectionProp>
-                <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
-                <boolProp name="Assertion.assume_success">false</boolProp>
-                <intProp name="Assertion.test_type">2</intProp>
-            </ResponseAssertion>
-            <hashTree/>
-        </hashTree>
-    
-    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Simple Product ${_counter} Add To Cart" enabled="true">
-      <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
-        <collectionProp name="Arguments.arguments">
-          <elementProp name="product" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">${product_id}</stringProp>
-            <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">product</stringProp>
-          </elementProp>
-          <elementProp name="related_product" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value"/>
-            <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">related_product</stringProp>
-          </elementProp>
-          <elementProp name="qty" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">1</stringProp>
-            <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">qty</stringProp>
-          </elementProp>
-          <elementProp name="form_key" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">${form_key}</stringProp>
-            <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">form_key</stringProp>
-          </elementProp>
-        </collectionProp>
-      </elementProp>
-      <stringProp name="HTTPSampler.domain"/>
-      <stringProp name="HTTPSampler.port"/>
-      <stringProp name="HTTPSampler.connect_timeout"/>
-      <stringProp name="HTTPSampler.response_timeout"/>
-      <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
-      <stringProp name="HTTPSampler.contentEncoding"/>
-      <stringProp name="HTTPSampler.path">${base_path}checkout/cart/add/</stringProp>
-      <stringProp name="HTTPSampler.method">POST</stringProp>
-      <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
-      <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
-      <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
-      <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
-      <boolProp name="HTTPSampler.monitor">false</boolProp>
-      <stringProp name="HTTPSampler.embedded_url_re"/>
-    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/product_browsing_and_adding_items_to_the_cart/simple_product_add_to_cart.jmx</stringProp></HTTPSamplerProxy>
-    <hashTree>
-    <HeaderManager guiclass="HeaderPanel" testclass="HeaderManager" testname="HTTP Header Manager" enabled="true">
-      <collectionProp name="HeaderManager.headers">
-        <elementProp name="" elementType="Header">
-          <stringProp name="Header.name">X-Requested-With</stringProp>
-          <stringProp name="Header.value">XMLHttpRequest</stringProp>
-        </elementProp>
-      </collectionProp>
-    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/common/http_header_manager_ajax.jmx</stringProp></HeaderManager>
-    <hashTree/>
-  </hashTree>
-  
-    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Load Cart Section ${_counter}" enabled="true">
-      <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
-        <collectionProp name="Arguments.arguments">
-          <elementProp name="sections" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">cart,messages</stringProp>
-            <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">sections</stringProp>
-          </elementProp>
-          <elementProp name="update_section_id" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">true</stringProp>
-            <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">update_section_id</stringProp>
-          </elementProp>
-          <elementProp name="_" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">${__time()}${__Random(1,1000000)}</stringProp>
-            <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">_</stringProp>
-          </elementProp>
-        </collectionProp>
-      </elementProp>
-      <stringProp name="HTTPSampler.domain"/>
-      <stringProp name="HTTPSampler.port"/>
-      <stringProp name="HTTPSampler.connect_timeout"/>
-      <stringProp name="HTTPSampler.response_timeout"/>
-      <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
-      <stringProp name="HTTPSampler.contentEncoding"/>
-      <stringProp name="HTTPSampler.path">${base_path}customer/section/load/</stringProp>
-      <stringProp name="HTTPSampler.method">GET</stringProp>
-      <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
-      <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
-      <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
-      <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
-      <boolProp name="HTTPSampler.monitor">false</boolProp>
-      <stringProp name="HTTPSampler.embedded_url_re"/>
-    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/load_cart_section.jmx</stringProp></HTTPSamplerProxy>
-    <hashTree>
-      <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Response Assertion" enabled="true">
-        <collectionProp name="Asserion.test_strings">
-          <stringProp name="210217247">You added ${product_name} to your shopping cart.</stringProp>
-        </collectionProp>
-        <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
-        <boolProp name="Assertion.assume_success">false</boolProp>
-        <intProp name="Assertion.test_type">2</intProp>
-      </ResponseAssertion>
-      <hashTree/>
-      <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Response Assertion" enabled="true">
-        <collectionProp name="Asserion.test_strings">
-          <stringProp name="2057973164">This product is out of stock.</stringProp>
-        </collectionProp>
-        <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
-        <boolProp name="Assertion.assume_success">false</boolProp>
-        <intProp name="Assertion.test_type">6</intProp>
-      </ResponseAssertion>
-      <hashTree/>
-      <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Response Assertion" enabled="true">
-        <collectionProp name="Asserion.test_strings">
-          <stringProp name="-350323027">\"summary_count\":${totalProductsAdded}</stringProp>
-        </collectionProp>
-        <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
-        <boolProp name="Assertion.assume_success">false</boolProp>
-        <intProp name="Assertion.test_type">2</intProp>
-      </ResponseAssertion>
-      <hashTree/>
-    
-    <HeaderManager guiclass="HeaderPanel" testclass="HeaderManager" testname="HTTP Header Manager" enabled="true">
-      <collectionProp name="HeaderManager.headers">
-        <elementProp name="" elementType="Header">
-          <stringProp name="Header.name">X-Requested-With</stringProp>
-          <stringProp name="Header.value">XMLHttpRequest</stringProp>
-        </elementProp>
-      </collectionProp>
-    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/common/http_header_manager_ajax.jmx</stringProp></HeaderManager>
-    <hashTree/>
-  </hashTree>
-  </hashTree>
-  
-    <LoopController guiclass="LoopControlPanel" testclass="LoopController" testname="Add Configurable Products to Cart" enabled="true">
-      <boolProp name="LoopController.continue_forever">true</boolProp>
-      <stringProp name="LoopController.loops">1</stringProp>
-    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/loop_controller.jmx</stringProp></LoopController>
-    <hashTree>
-      <CounterConfig guiclass="CounterConfigGui" testclass="CounterConfig" testname="Counter" enabled="true">
-        <stringProp name="CounterConfig.start">1</stringProp>
-        <stringProp name="CounterConfig.end"/>
-        <stringProp name="CounterConfig.incr">1</stringProp>
-        <stringProp name="CounterConfig.name">_counter</stringProp>
-        <stringProp name="CounterConfig.format"/>
-        <boolProp name="CounterConfig.per_user">true</boolProp>
-        <boolProp name="CounterConfig.reset_on_tg_iteration">true</boolProp>
-      </CounterConfig>
-      <hashTree/>
-    
-    <BeanShellSampler guiclass="BeanShellSamplerGui" testclass="BeanShellSampler" testname="SetUp - Prepare Configurable Product Data" enabled="true">
-      <stringProp name="BeanShellSampler.query">
-import java.util.Random;
-
-Random random = vars.getObject("randomIntGenerator");
-number = random.nextInt(props.get("configurable_products_list").size());
-product = props.get("configurable_products_list").get(number);
-
-vars.put("product_url_key", product.get("url_key"));
-vars.put("product_id", product.get("id"));
-vars.put("product_name", product.get("title"));
-vars.put("product_uenc", product.get("uenc"));
-vars.put("product_sku", product.get("sku"));
-      </stringProp>
-      <stringProp name="BeanShellSampler.filename"/>
-      <stringProp name="BeanShellSampler.parameters"/>
-      <boolProp name="BeanShellSampler.resetInterpreter">true</boolProp>
-    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/product_browsing_and_adding_items_to_the_cart/configurable_products_setup.jmx</stringProp></BeanShellSampler>
-    <hashTree/>
-  
-    <BeanShellSampler guiclass="BeanShellSamplerGui" testclass="BeanShellSampler" testname="SetUp - Update Products Added Counter" enabled="true">
-      <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/loops/update_products_added_counter.jmx</stringProp>
-      <stringProp name="BeanShellSampler.query">
-productsAdded = Integer.parseInt(vars.get("totalProductsAdded"));
-productsAdded = productsAdded + 1;
-
-vars.put("totalProductsAdded", String.valueOf(productsAdded));
-      </stringProp>
-      <stringProp name="BeanShellSampler.filename"/>
-      <stringProp name="BeanShellSampler.parameters"/>
-      <boolProp name="BeanShellSampler.resetInterpreter">true</boolProp>
-    </BeanShellSampler>
-    <hashTree/>
-  
-        <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Configurable Product ${_counter} View" enabled="true">
-            <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
-                <collectionProp name="Arguments.arguments"/>
+            <elementProp name="product[stock_data][use_config_notify_stock_qty]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">1</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[stock_data][use_config_notify_stock_qty]</stringProp>
+            </elementProp>
+            <elementProp name="product[stock_data][enable_qty_increments]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">0</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[stock_data][enable_qty_increments]</stringProp>
+            </elementProp>
+            <elementProp name="product[stock_data][qty_increments]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">0</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[stock_data][qty_increments]</stringProp>
+            </elementProp>
+            <elementProp name="product[stock_data][use_config_qty_increments]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">1</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[stock_data][use_config_qty_increments]</stringProp>
+            </elementProp>
+            <elementProp name="product[stock_data][is_in_stock]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">1</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[stock_data][is_in_stock]</stringProp>
+            </elementProp>
+            <elementProp name="product[custom_design]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value"/>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[custom_design]</stringProp>
+            </elementProp>
+            <elementProp name="product[custom_design_from]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value"/>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[custom_design_from]</stringProp>
+            </elementProp>
+            <elementProp name="product[custom_design_to]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value"/>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[custom_design_to]</stringProp>
+            </elementProp>
+            <elementProp name="product[custom_layout_update]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value"/>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[custom_layout_update]</stringProp>
+            </elementProp>
+            <elementProp name="product[page_layout]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value"/>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[page_layout]</stringProp>
+            </elementProp>
+            <elementProp name="product[options_container]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">container2</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[options_container]</stringProp>
+            </elementProp>
+            <elementProp name="new-variations-attribute-set-id" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value"/>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">new-variations-attribute-set-id</stringProp>
+            </elementProp>
+            <elementProp name="product[shipment_type]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">0</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[shipment_type]</stringProp>
+              <stringProp name="Argument.desc">false</stringProp>
+            </elementProp>
+            <elementProp name="bundle_options[bundle_options][0][title]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">option title one</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">bundle_options[bundle_options][0][title]</stringProp>
+              <stringProp name="Argument.desc">false</stringProp>
+            </elementProp>
+            <elementProp name="bundle_options[bundle_options][0][option_id]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value"/>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">bundle_options[bundle_options][0][option_id]</stringProp>
+              <stringProp name="Argument.desc">false</stringProp>
+            </elementProp>
+            <elementProp name="bundle_options[bundle_options][0][delete]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value"/>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">bundle_options[bundle_options][0][delete]</stringProp>
+              <stringProp name="Argument.desc">false</stringProp>
+            </elementProp>
+            <elementProp name="bundle_options[bundle_options][0][type]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">select</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">bundle_options[bundle_options][0][type]</stringProp>
+              <stringProp name="Argument.desc">false</stringProp>
+            </elementProp>
+            <elementProp name="bundle_options[bundle_options][0][required]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">1</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">bundle_options[bundle_options][0][required]</stringProp>
+              <stringProp name="Argument.desc">false</stringProp>
+            </elementProp>
+            <elementProp name="bundle_options[bundle_options][0][position]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">0</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">bundle_options[bundle_options][0][position]</stringProp>
+              <stringProp name="Argument.desc">false</stringProp>
+            </elementProp>
+            <elementProp name="bundle_options[bundle_options][0][bundle_selections][0][selection_id]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value"/>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">bundle_options[bundle_options][0][bundle_selections][0][selection_id]</stringProp>
+              <stringProp name="Argument.desc">false</stringProp>
+            </elementProp>
+            <elementProp name="bundle_options[bundle_options][0][bundle_selections][0][option_id]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value"/>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">bundle_options[bundle_options][0][bundle_selections][0][option_id]</stringProp>
+              <stringProp name="Argument.desc">false</stringProp>
+            </elementProp>
+            <elementProp name="bundle_options[bundle_options][0][bundle_selections][0][product_id]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">${simple_product_1_id}</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">bundle_options[bundle_options][0][bundle_selections][0][product_id]</stringProp>
+              <stringProp name="Argument.desc">false</stringProp>
+            </elementProp>
+            <elementProp name="bundle_options[bundle_options][0][bundle_selections][0][delete]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value"/>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">bundle_options[bundle_options][0][bundle_selections][0][delete]</stringProp>
+              <stringProp name="Argument.desc">false</stringProp>
+            </elementProp>
+            <elementProp name="bundle_options[bundle_options][0][bundle_selections][0][selection_price_value]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">25</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">bundle_options[bundle_options][0][bundle_selections][0][selection_price_value]</stringProp>
+              <stringProp name="Argument.desc">false</stringProp>
+            </elementProp>
+            <elementProp name="bundle_options[bundle_options][0][bundle_selections][0][selection_price_type]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">1</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">bundle_options[bundle_options][0][bundle_selections][0][selection_price_type]</stringProp>
+              <stringProp name="Argument.desc">false</stringProp>
+            </elementProp>
+            <elementProp name="bundle_options[bundle_options][0][bundle_selections][0][selection_qty]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">1</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">bundle_options[bundle_options][0][bundle_selections][0][selection_qty]</stringProp>
+              <stringProp name="Argument.desc">false</stringProp>
+            </elementProp>
+            <elementProp name="bundle_options[bundle_options][0][bundle_selections][0][selection_can_change_qty]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">1</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">bundle_options[bundle_options][0][bundle_selections][0][selection_can_change_qty]</stringProp>
+              <stringProp name="Argument.desc">false</stringProp>
+            </elementProp>
+            <elementProp name="bundle_options[bundle_options][0][bundle_selections][0][position]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">0</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">bundle_options[bundle_options][0][bundle_selections][0][position]</stringProp>
+              <stringProp name="Argument.desc">false</stringProp>
+            </elementProp>
+            <elementProp name="bundle_options[bundle_options][0][bundle_selections][1][selection_id]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value"/>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">bundle_options[bundle_options][0][bundle_selections][1][selection_id]</stringProp>
+              <stringProp name="Argument.desc">false</stringProp>
+            </elementProp>
+            <elementProp name="bundle_options[bundle_options][0][bundle_selections][1][option_id]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value"/>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">bundle_options[bundle_options][0][bundle_selections][1][option_id]</stringProp>
+              <stringProp name="Argument.desc">false</stringProp>
+            </elementProp>
+            <elementProp name="bundle_options[bundle_options][0][bundle_selections][1][product_id]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">${simple_product_2_id}</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">bundle_options[bundle_options][0][bundle_selections][1][product_id]</stringProp>
+              <stringProp name="Argument.desc">false</stringProp>
+            </elementProp>
+            <elementProp name="bundle_options[bundle_options][0][bundle_selections][1][delete]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value"/>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">bundle_options[bundle_options][0][bundle_selections][1][delete]</stringProp>
+              <stringProp name="Argument.desc">false</stringProp>
+            </elementProp>
+            <elementProp name="bundle_options[bundle_options][0][bundle_selections][1][selection_price_value]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">10.99</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">bundle_options[bundle_options][0][bundle_selections][1][selection_price_value]</stringProp>
+              <stringProp name="Argument.desc">false</stringProp>
+            </elementProp>
+            <elementProp name="bundle_options[bundle_options][0][bundle_selections][1][selection_price_type]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">0</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">bundle_options[bundle_options][0][bundle_selections][1][selection_price_type]</stringProp>
+              <stringProp name="Argument.desc">false</stringProp>
+            </elementProp>
+            <elementProp name="bundle_options[bundle_options][0][bundle_selections][1][selection_qty]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">1</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">bundle_options[bundle_options][0][bundle_selections][1][selection_qty]</stringProp>
+              <stringProp name="Argument.desc">false</stringProp>
+            </elementProp>
+            <elementProp name="bundle_options[bundle_options][0][bundle_selections][1][selection_can_change_qty]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">1</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">bundle_options[bundle_options][0][bundle_selections][1][selection_can_change_qty]</stringProp>
+              <stringProp name="Argument.desc">false</stringProp>
+            </elementProp>
+            <elementProp name="bundle_options[bundle_options][0][bundle_selections][1][position]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">1</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">bundle_options[bundle_options][0][bundle_selections][1][position]</stringProp>
+              <stringProp name="Argument.desc">false</stringProp>
+            </elementProp>
+            <elementProp name="bundle_options[bundle_options][1][title]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">option title two</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">bundle_options[bundle_options][1][title]</stringProp>
+              <stringProp name="Argument.desc">false</stringProp>
+            </elementProp>
+            <elementProp name="bundle_options[bundle_options][1][option_id]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value"/>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">bundle_options[bundle_options][1][option_id]</stringProp>
+              <stringProp name="Argument.desc">false</stringProp>
+            </elementProp>
+            <elementProp name="bundle_options[bundle_options][1][delete]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value"/>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">bundle_options[bundle_options][1][delete]</stringProp>
+              <stringProp name="Argument.desc">false</stringProp>
+            </elementProp>
+            <elementProp name="bundle_options[bundle_options][1][type]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">select</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">bundle_options[bundle_options][1][type]</stringProp>
+              <stringProp name="Argument.desc">false</stringProp>
+            </elementProp>
+            <elementProp name="bundle_options[bundle_options][1][required]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">1</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">bundle_options[bundle_options][1][required]</stringProp>
+              <stringProp name="Argument.desc">false</stringProp>
+            </elementProp>
+            <elementProp name="bundle_options[bundle_options][1][position]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">1</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">bundle_options[bundle_options][1][position]</stringProp>
+              <stringProp name="Argument.desc">false</stringProp>
+            </elementProp>
+            <elementProp name="bundle_options[bundle_options][1][bundle_selections][0][selection_id]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value"/>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">bundle_options[bundle_options][1][bundle_selections][0][selection_id]</stringProp>
+              <stringProp name="Argument.desc">false</stringProp>
+            </elementProp>
+            <elementProp name="bundle_options[bundle_options][1][bundle_selections][0][option_id]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value"/>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">bundle_options[bundle_options][1][bundle_selections][0][option_id]</stringProp>
+              <stringProp name="Argument.desc">false</stringProp>
+            </elementProp>
+            <elementProp name="bundle_options[bundle_options][1][bundle_selections][0][product_id]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">${simple_product_1_id}</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">bundle_options[bundle_options][1][bundle_selections][0][product_id]</stringProp>
+              <stringProp name="Argument.desc">false</stringProp>
             </elementProp>
-            <stringProp name="HTTPSampler.domain"/>
-            <stringProp name="HTTPSampler.port"/>
-            <stringProp name="HTTPSampler.connect_timeout"/>
-            <stringProp name="HTTPSampler.response_timeout"/>
-            <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
-            <stringProp name="HTTPSampler.contentEncoding"/>
-            <stringProp name="HTTPSampler.path">${base_path}${product_url_key}${url_suffix}</stringProp>
-            <stringProp name="HTTPSampler.method">GET</stringProp>
-            <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
-            <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
-            <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
-            <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
-            <boolProp name="HTTPSampler.monitor">false</boolProp>
-            <stringProp name="HTTPSampler.embedded_url_re"/>
-        <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/product_browsing_and_adding_items_to_the_cart/product_view.jmx</stringProp></HTTPSamplerProxy>
-        <hashTree>
-            <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Response Assertion" enabled="true">
-                <collectionProp name="Asserion.test_strings">
-                    <stringProp name="-1787050162">&lt;span&gt;In stock&lt;/span&gt;</stringProp>
-                </collectionProp>
-                <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
-                <boolProp name="Assertion.assume_success">false</boolProp>
-                <intProp name="Assertion.test_type">2</intProp>
-            </ResponseAssertion>
-            <hashTree/>
-        </hashTree>
-    
-    <LoopController guiclass="LoopControlPanel" testclass="LoopController" testname="SetUp - Get Configurable Product Options" enabled="true">
-      <boolProp name="LoopController.continue_forever">true</boolProp>
-      <stringProp name="LoopController.loops">1</stringProp>
-    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/common/get_configurable_product_options.jmx</stringProp></LoopController>
-    <hashTree>
-      <HeaderManager guiclass="HeaderPanel" testclass="HeaderManager" testname="HTTP Header Manager" enabled="true">
-        <collectionProp name="HeaderManager.headers">
-          <elementProp name="" elementType="Header">
-            <stringProp name="Header.name">Content-Type</stringProp>
-            <stringProp name="Header.value">application/json</stringProp>
-          </elementProp>
-          <elementProp name="" elementType="Header">
-            <stringProp name="Header.name">Accept</stringProp>
-            <stringProp name="Header.value">*/*</stringProp>
-          </elementProp>
-        </collectionProp>
-      </HeaderManager>
-      <hashTree/>
-      <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="SetUp - Admin Token Retrieval" enabled="true">
-        <boolProp name="HTTPSampler.postBodyRaw">true</boolProp>
-        <elementProp name="HTTPsampler.Arguments" elementType="Arguments">
-          <collectionProp name="Arguments.arguments">
-            <elementProp name="" elementType="HTTPArgument">
-              <boolProp name="HTTPArgument.always_encode">false</boolProp>
-              <stringProp name="Argument.value">{"username":"${admin_user}","password":"${admin_password}"}</stringProp>
+            <elementProp name="bundle_options[bundle_options][1][bundle_selections][0][delete]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value"/>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">bundle_options[bundle_options][1][bundle_selections][0][delete]</stringProp>
+              <stringProp name="Argument.desc">false</stringProp>
+            </elementProp>
+            <elementProp name="bundle_options[bundle_options][1][bundle_selections][0][selection_price_value]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">5.00</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">bundle_options[bundle_options][1][bundle_selections][0][selection_price_value]</stringProp>
+              <stringProp name="Argument.desc">false</stringProp>
+            </elementProp>
+            <elementProp name="bundle_options[bundle_options][1][bundle_selections][0][selection_price_type]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">0</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">bundle_options[bundle_options][1][bundle_selections][0][selection_price_type]</stringProp>
+              <stringProp name="Argument.desc">false</stringProp>
+            </elementProp>
+            <elementProp name="bundle_options[bundle_options][1][bundle_selections][0][selection_qty]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">1</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">bundle_options[bundle_options][1][bundle_selections][0][selection_qty]</stringProp>
+              <stringProp name="Argument.desc">false</stringProp>
+            </elementProp>
+            <elementProp name="bundle_options[bundle_options][1][bundle_selections][0][selection_can_change_qty]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">1</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">bundle_options[bundle_options][1][bundle_selections][0][selection_can_change_qty]</stringProp>
+              <stringProp name="Argument.desc">false</stringProp>
+            </elementProp>
+            <elementProp name="bundle_options[bundle_options][1][bundle_selections][0][position]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">0</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">bundle_options[bundle_options][1][bundle_selections][0][position]</stringProp>
+              <stringProp name="Argument.desc">false</stringProp>
+            </elementProp>
+            <elementProp name="bundle_options[bundle_options][1][bundle_selections][1][selection_id]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value"/>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">bundle_options[bundle_options][1][bundle_selections][1][selection_id]</stringProp>
+              <stringProp name="Argument.desc">false</stringProp>
+            </elementProp>
+            <elementProp name="bundle_options[bundle_options][1][bundle_selections][1][option_id]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value"/>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">bundle_options[bundle_options][1][bundle_selections][1][option_id]</stringProp>
+              <stringProp name="Argument.desc">false</stringProp>
+            </elementProp>
+            <elementProp name="bundle_options[bundle_options][1][bundle_selections][1][product_id]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">${simple_product_2_id}</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">bundle_options[bundle_options][1][bundle_selections][1][product_id]</stringProp>
+              <stringProp name="Argument.desc">false</stringProp>
+            </elementProp>
+            <elementProp name="bundle_options[bundle_options][1][bundle_selections][1][delete]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value"/>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">bundle_options[bundle_options][1][bundle_selections][1][delete]</stringProp>
+              <stringProp name="Argument.desc">false</stringProp>
+            </elementProp>
+            <elementProp name="bundle_options[bundle_options][1][bundle_selections][1][selection_price_value]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">7.00</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">bundle_options[bundle_options][1][bundle_selections][1][selection_price_value]</stringProp>
+              <stringProp name="Argument.desc">false</stringProp>
+            </elementProp>
+            <elementProp name="bundle_options[bundle_options][1][bundle_selections][1][selection_price_type]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">0</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">bundle_options[bundle_options][1][bundle_selections][1][selection_price_type]</stringProp>
+              <stringProp name="Argument.desc">false</stringProp>
+            </elementProp>
+            <elementProp name="bundle_options[bundle_options][1][bundle_selections][1][selection_qty]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">1</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">bundle_options[bundle_options][1][bundle_selections][1][selection_qty]</stringProp>
+              <stringProp name="Argument.desc">false</stringProp>
+            </elementProp>
+            <elementProp name="bundle_options[bundle_options][1][bundle_selections][1][selection_can_change_qty]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">1</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">bundle_options[bundle_options][1][bundle_selections][1][selection_can_change_qty]</stringProp>
+              <stringProp name="Argument.desc">false</stringProp>
+            </elementProp>
+            <elementProp name="bundle_options[bundle_options][1][bundle_selections][1][position]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">1</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">bundle_options[bundle_options][1][bundle_selections][1][position]</stringProp>
+              <stringProp name="Argument.desc">false</stringProp>
+            </elementProp>
+            <elementProp name="affect_bundle_product_selections" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">2</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">affect_bundle_product_selections</stringProp>
+              <stringProp name="Argument.desc">false</stringProp>
+            </elementProp>
+            <elementProp name="links[related][0][id]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">${related_product_id}</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">links[related][0][id]</stringProp>
+            </elementProp>
+            <elementProp name="links[related][0][position]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">1</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">links[related][0][position]</stringProp>
+            </elementProp>
+            <elementProp name="links[upsell][0][id]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">${related_product_id}</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">links[upsell][0][id]</stringProp>
+            </elementProp>
+            <elementProp name="links[upsell][0][position]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">1</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">links[upsell][0][position]</stringProp>
+            </elementProp>
+            <elementProp name="links[crosssell][0][id]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">${related_product_id}</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">links[crosssell][0][id]</stringProp>
+            </elementProp>
+            <elementProp name="links[crosssell][0][position]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">1</stringProp>
               <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">links[crosssell][0][position]</stringProp>
             </elementProp>
           </collectionProp>
         </elementProp>
@@ -30383,7 +23004,7 @@ vars.put("totalProductsAdded", String.valueOf(productsAdded));
         <stringProp name="HTTPSampler.response_timeout"/>
         <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
         <stringProp name="HTTPSampler.contentEncoding"/>
-        <stringProp name="HTTPSampler.path">${base_path}rest/V1/integration/admin/token</stringProp>
+        <stringProp name="HTTPSampler.path">${base_path}${admin_path}/catalog/product/save/set/4/type/bundle/back/edit/active_tab/product-details/</stringProp>
         <stringProp name="HTTPSampler.method">POST</stringProp>
         <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
         <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
@@ -30393,865 +23014,30 @@ vars.put("totalProductsAdded", String.valueOf(productsAdded));
         <stringProp name="HTTPSampler.embedded_url_re"/>
       </HTTPSamplerProxy>
       <hashTree>
-        <com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor guiclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.gui.JSONPathExtractorGui" testclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor" testname="jp@gc - JSON Path Extractor" enabled="true">
-          <stringProp name="VAR">admin_token</stringProp>
-          <stringProp name="JSONPATH">$</stringProp>
-          <stringProp name="DEFAULT"/>
-          <stringProp name="VARIABLE"/>
-          <stringProp name="SUBJECT">BODY</stringProp>
-        </com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor>
-        <hashTree/>
-        <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert token not null" enabled="true">
+        <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Response Assertion" enabled="true">
           <collectionProp name="Asserion.test_strings">
-            <stringProp name="484395188">^[a-z0-9-]+$</stringProp>
-          </collectionProp>
-          <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
-          <boolProp name="Assertion.assume_success">false</boolProp>
-          <intProp name="Assertion.test_type">1</intProp>
-          <stringProp name="Assertion.scope">variable</stringProp>
-          <stringProp name="Scope.variable">admin_token</stringProp>
-        </ResponseAssertion>
-        <hashTree/>
-      </hashTree>
-      <HeaderManager guiclass="HeaderPanel" testclass="HeaderManager" testname="HTTP Header Manager" enabled="true">
-        <collectionProp name="HeaderManager.headers">
-          <elementProp name="" elementType="Header">
-            <stringProp name="Header.name">Authorization</stringProp>
-            <stringProp name="Header.value">Bearer ${admin_token}</stringProp>
-          </elementProp>
-        </collectionProp>
-      </HeaderManager>
-      <hashTree/>
-      <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Get Configurable Product Options" enabled="true">
-        <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
-          <collectionProp name="Arguments.arguments"/>
-        </elementProp>
-        <stringProp name="HTTPSampler.domain"/>
-        <stringProp name="HTTPSampler.port"/>
-        <stringProp name="HTTPSampler.connect_timeout"/>
-        <stringProp name="HTTPSampler.response_timeout"/>
-        <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
-        <stringProp name="HTTPSampler.contentEncoding"/>
-        <stringProp name="HTTPSampler.path">${base_path}rest/V1/configurable-products/${product_sku}/options/all</stringProp>
-        <stringProp name="HTTPSampler.method">GET</stringProp>
-        <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
-        <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
-        <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
-        <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
-        <boolProp name="HTTPSampler.monitor">false</boolProp>
-        <stringProp name="HTTPSampler.embedded_url_re"/>
-      </HTTPSamplerProxy>
-      <hashTree>
-        <com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor guiclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.gui.JSONPathExtractorGui" testclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor" testname="JSON Path Extractor: Extract attribute_ids" enabled="true">
-          <stringProp name="VAR">attribute_ids</stringProp>
-          <stringProp name="JSONPATH">$.[*].attribute_id</stringProp>
-          <stringProp name="DEFAULT">NO_VALUE</stringProp>
-          <stringProp name="VARIABLE"/>
-          <stringProp name="SUBJECT">BODY</stringProp>
-        </com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor>
-        <hashTree/>
-        <com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor guiclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.gui.JSONPathExtractorGui" testclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor" testname="JSON Path Extractor: Extract option_values" enabled="true">
-          <stringProp name="VAR">option_values</stringProp>
-          <stringProp name="JSONPATH">$.[*].values[0].value_index</stringProp>
-          <stringProp name="DEFAULT">NO_VALUE</stringProp>
-          <stringProp name="VARIABLE"/>
-          <stringProp name="SUBJECT">BODY</stringProp>
-        </com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor>
-        <hashTree/>
-      </hashTree>
-    </hashTree>
-  
-    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Configurable Product ${_counter} Add To Cart" enabled="true">
-      <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
-        <collectionProp name="Arguments.arguments">
-          <elementProp name="product" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">${product_id}</stringProp>
-            <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">product</stringProp>
-          </elementProp>
-          <elementProp name="related_product" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value"/>
-            <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">related_product</stringProp>
-          </elementProp>
-          <elementProp name="qty" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">1</stringProp>
-            <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">qty</stringProp>
-          </elementProp>
-          <elementProp name="form_key" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">${form_key}</stringProp>
-            <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">form_key</stringProp>
-          </elementProp>
-        </collectionProp>
-      </elementProp>
-      <stringProp name="HTTPSampler.domain"/>
-      <stringProp name="HTTPSampler.port"/>
-      <stringProp name="HTTPSampler.connect_timeout"/>
-      <stringProp name="HTTPSampler.response_timeout"/>
-      <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
-      <stringProp name="HTTPSampler.contentEncoding"/>
-      <stringProp name="HTTPSampler.path">${base_path}checkout/cart/add/</stringProp>
-      <stringProp name="HTTPSampler.method">POST</stringProp>
-      <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
-      <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
-      <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
-      <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
-      <boolProp name="HTTPSampler.monitor">false</boolProp>
-      <stringProp name="HTTPSampler.embedded_url_re"/>
-    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/product_browsing_and_adding_items_to_the_cart/configurable_product_add_to_cart.jmx</stringProp></HTTPSamplerProxy>
-    <hashTree>
-        <BeanShellPreProcessor guiclass="TestBeanGUI" testclass="BeanShellPreProcessor" testname="BeanShell PreProcessor" enabled="true">
-                <boolProp name="resetInterpreter">false</boolProp>
-                <stringProp name="parameters"/>
-                <stringProp name="filename"/>
-                <stringProp name="script">
-                    try {
-                    attribute_ids = vars.get("attribute_ids");
-                    option_values = vars.get("option_values");
-                    attribute_ids = attribute_ids.replace("[","").replace("]","").replace("\"", "");
-                    option_values = option_values.replace("[","").replace("]","").replace("\"", "");
-                    attribute_ids_array = attribute_ids.split(",");
-                    option_values_array = option_values.split(",");
-                    args = ctx.getCurrentSampler().getArguments();
-                    it = args.iterator();
-                    while (it.hasNext()) {
-                        argument = it.next();
-                        if (argument.getStringValue().contains("${")) {
-                            args.removeArgument(argument.getName());
-                        }
-                    }
-                    for (int i = 0; i &lt; attribute_ids_array.length; i++) {
-                        ctx.getCurrentSampler().addArgument("super_attribute[" + attribute_ids_array[i] + "]", option_values_array[i]);
-                    }
-                    } catch (Exception e) {
-                        log.error("eror&#x2026;", e);
-                    }
-                </stringProp>
-              <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/common/configurable_product_add_to_cart_preprocessor.jmx</stringProp></BeanShellPreProcessor>
-        <hashTree/>
-    
-    <HeaderManager guiclass="HeaderPanel" testclass="HeaderManager" testname="HTTP Header Manager" enabled="true">
-      <collectionProp name="HeaderManager.headers">
-        <elementProp name="" elementType="Header">
-          <stringProp name="Header.name">X-Requested-With</stringProp>
-          <stringProp name="Header.value">XMLHttpRequest</stringProp>
-        </elementProp>
-      </collectionProp>
-    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/common/http_header_manager_ajax.jmx</stringProp></HeaderManager>
-    <hashTree/>
-  </hashTree>
-  
-    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Load Cart Section ${_counter}" enabled="true">
-      <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
-        <collectionProp name="Arguments.arguments">
-          <elementProp name="sections" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">cart,messages</stringProp>
-            <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">sections</stringProp>
-          </elementProp>
-          <elementProp name="update_section_id" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">true</stringProp>
-            <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">update_section_id</stringProp>
-          </elementProp>
-          <elementProp name="_" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">${__time()}${__Random(1,1000000)}</stringProp>
-            <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">_</stringProp>
-          </elementProp>
-        </collectionProp>
-      </elementProp>
-      <stringProp name="HTTPSampler.domain"/>
-      <stringProp name="HTTPSampler.port"/>
-      <stringProp name="HTTPSampler.connect_timeout"/>
-      <stringProp name="HTTPSampler.response_timeout"/>
-      <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
-      <stringProp name="HTTPSampler.contentEncoding"/>
-      <stringProp name="HTTPSampler.path">${base_path}customer/section/load/</stringProp>
-      <stringProp name="HTTPSampler.method">GET</stringProp>
-      <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
-      <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
-      <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
-      <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
-      <boolProp name="HTTPSampler.monitor">false</boolProp>
-      <stringProp name="HTTPSampler.embedded_url_re"/>
-    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/load_cart_section.jmx</stringProp></HTTPSamplerProxy>
-    <hashTree>
-      <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Response Assertion" enabled="true">
-        <collectionProp name="Asserion.test_strings">
-          <stringProp name="210217247">You added ${product_name} to your shopping cart.</stringProp>
-        </collectionProp>
-        <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
-        <boolProp name="Assertion.assume_success">false</boolProp>
-        <intProp name="Assertion.test_type">2</intProp>
-      </ResponseAssertion>
-      <hashTree/>
-      <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Response Assertion" enabled="true">
-        <collectionProp name="Asserion.test_strings">
-          <stringProp name="2057973164">This product is out of stock.</stringProp>
-        </collectionProp>
-        <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
-        <boolProp name="Assertion.assume_success">false</boolProp>
-        <intProp name="Assertion.test_type">6</intProp>
-      </ResponseAssertion>
-      <hashTree/>
-      <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Response Assertion" enabled="true">
-        <collectionProp name="Asserion.test_strings">
-          <stringProp name="-350323027">\"summary_count\":${totalProductsAdded}</stringProp>
-        </collectionProp>
-        <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
-        <boolProp name="Assertion.assume_success">false</boolProp>
-        <intProp name="Assertion.test_type">2</intProp>
-      </ResponseAssertion>
-      <hashTree/>
-    
-    <HeaderManager guiclass="HeaderPanel" testclass="HeaderManager" testname="HTTP Header Manager" enabled="true">
-      <collectionProp name="HeaderManager.headers">
-        <elementProp name="" elementType="Header">
-          <stringProp name="Header.name">X-Requested-With</stringProp>
-          <stringProp name="Header.value">XMLHttpRequest</stringProp>
-        </elementProp>
-      </collectionProp>
-    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/common/http_header_manager_ajax.jmx</stringProp></HeaderManager>
-    <hashTree/>
-  </hashTree>
-  </hashTree>
-  </hashTree>
-
-  
-    <ThroughputController guiclass="ThroughputControllerGui" testclass="ThroughputController" testname="Import Products" enabled="true">
-      <intProp name="ThroughputController.style">1</intProp>
-      <boolProp name="ThroughputController.perThread">false</boolProp>
-      <intProp name="ThroughputController.maxThroughput">1</intProp>
-      <stringProp name="ThroughputController.percentThroughput">${importProductsPercentage}</stringProp>
-    <stringProp name="TestPlan.comments">mpaf/tool/fragments/_system/scenario_controller_tmpl.jmx</stringProp></ThroughputController>
-    <hashTree>
-        <JSR223PreProcessor guiclass="TestBeanGUI" testclass="JSR223PreProcessor" testname="Set Test Label" enabled="true">
-            <stringProp name="script">
-var testLabel = "${testLabel}" ? " (${testLabel})" : "";
-if (testLabel
-    &amp;&amp; sampler.getClass().getName() == 'org.apache.jmeter.protocol.http.sampler.HTTPSamplerProxy'
-) {
-    if (sampler.getName().indexOf(testLabel) == -1) {
-       sampler.setName(sampler.getName() + testLabel);
-    }
-} else if (sampler.getName().indexOf("SetUp - ") == -1) {
-    sampler.setName("SetUp - " + sampler.getName());
-}
-            </stringProp>
-            <stringProp name="scriptLanguage">javascript</stringProp>
-        <stringProp name="TestPlan.comments">mpaf/tool/fragments/_system/setup_label.jmx</stringProp></JSR223PreProcessor>
-        <hashTree/>
-        <BeanShellSampler guiclass="BeanShellSamplerGui" testclass="BeanShellSampler" testname="SetUp - Set Label" enabled="true">
-            <stringProp name="BeanShellSampler.query">
-                vars.put("testLabel", "Import Products");
-            </stringProp>
-            <boolProp name="BeanShellSampler.resetInterpreter">true</boolProp>
-        </BeanShellSampler>
-        <hashTree/>
-    
-        <JSR223PostProcessor guiclass="TestBeanGUI" testclass="JSR223PostProcessor" testname="Get admin form key PostProcessor" enabled="true">
-        <stringProp name="script">
-        function getFormKeyFromResponse()
-        {
-            var url = prev.getUrlAsString(),
-            responseCode =  prev.getResponseCode(),
-            formKey = null;
-            searchPattern = /var FORM_KEY = '(.+)'/;
-            if (responseCode == "200" &amp;&amp; url) {
-                response = prev.getResponseDataAsString();
-                formKey = response  &amp;&amp; response.match(searchPattern) ? response.match(searchPattern)[1] : null;
-            }
-            return formKey;
-        }
-
-        formKey = vars.get("form_key_storage");
-
-	   currentFormKey = getFormKeyFromResponse();
-
-	   if (currentFormKey != null &amp;&amp; currentFormKey != formKey) {
-		  vars.put("form_key_storage", currentFormKey);
-	   }
-        </stringProp>
-        <stringProp name="scriptLanguage">javascript</stringProp>
-        <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin/handle_admin_form_key.jmx</stringProp></JSR223PostProcessor>
-        <hashTree/>
-        <JSR223PreProcessor guiclass="TestBeanGUI" testclass="JSR223PreProcessor" testname="Set admin form key PreProcessor" enabled="true">
-            <stringProp name="script">
-                formKey =  vars.get("form_key_storage");
-                if (formKey
-                    &amp;&amp; sampler.getClass().getName() == 'org.apache.jmeter.protocol.http.sampler.HTTPSamplerProxy'
-                    &amp;&amp; sampler.getMethod() == "POST")
-                    {
-                        arguments = sampler.getArguments();
-                        for (i=0; i&lt;arguments.getArgumentCount(); i++)
-                        {
-                            argument = arguments.getArgument(i);
-                            if (argument.getName() == 'form_key' &amp;&amp; argument.getValue() != formKey) {
-                            log.info("admin form key updated: " + argument.getValue() + " =&gt; " + formKey);
-                            argument.setValue(formKey);
-                        }
-                    }
-                }
-            </stringProp>
-            <stringProp name="scriptLanguage">javascript</stringProp>
-        </JSR223PreProcessor>
+            <stringProp name="-583471546">You saved the product</stringProp>
+            <stringProp name="-1534079309">option title one</stringProp>
+            <stringProp name="-1534074215">option title two</stringProp>
+            <stringProp name="1304788671">${simple_product_2_name}</stringProp>
+            <stringProp name="417284990">${simple_product_1_name}</stringProp>
+          </collectionProp>
+
+          <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
+          <boolProp name="Assertion.assume_success">false</boolProp>
+          <intProp name="Assertion.test_type">2</intProp>
+        </ResponseAssertion>
         <hashTree/>
-    
-    <CookieManager guiclass="CookiePanel" testclass="CookieManager" testname="HTTP Cookie Manager" enabled="true">
-      <collectionProp name="CookieManager.cookies"/>
-      <boolProp name="CookieManager.clearEachIteration">false</boolProp>
-    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/http_cookie_manager_without_clear_each_iteration.jmx</stringProp></CookieManager>
-    <hashTree/>
-  
-    <OnceOnlyController guiclass="OnceOnlyControllerGui" testclass="OnceOnlyController" testname="Once Only Controller" enabled="true">
-  <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/once_only_controller.jmx</stringProp>
-</OnceOnlyController>
-    <hashTree>
-    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="SetUp - Login" enabled="true">
-      <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
-        <collectionProp name="Arguments.arguments"/>
-      </elementProp>
-      <stringProp name="HTTPSampler.domain"/>
-      <stringProp name="HTTPSampler.port"/>
-      <stringProp name="HTTPSampler.connect_timeout"/>
-      <stringProp name="HTTPSampler.response_timeout"/>
-      <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
-      <stringProp name="HTTPSampler.contentEncoding"/>
-      <stringProp name="HTTPSampler.path">${base_path}${admin_path}</stringProp>
-      <stringProp name="HTTPSampler.method">GET</stringProp>
-      <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
-      <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
-      <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
-      <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
-      <boolProp name="HTTPSampler.monitor">false</boolProp>
-      <stringProp name="HTTPSampler.embedded_url_re"/>
-    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_login/admin_login.jmx</stringProp></HTTPSamplerProxy>
-    <hashTree>
-      <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert login form shown" enabled="true">
-        <collectionProp name="Asserion.test_strings">
-          <stringProp name="-1397214398">Welcome</stringProp>
-          <stringProp name="-515240035">&lt;title&gt;Magento Admin&lt;/title&gt;</stringProp>
-        </collectionProp>
-        <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
-        <boolProp name="Assertion.assume_success">false</boolProp>
-        <intProp name="Assertion.test_type">2</intProp>
-      </ResponseAssertion>
-      <hashTree/>
-      <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract form key" enabled="true">
-        <stringProp name="RegexExtractor.useHeaders">false</stringProp>
-        <stringProp name="RegexExtractor.refname">admin_form_key</stringProp>
-        <stringProp name="RegexExtractor.regex">&lt;input name="form_key" type="hidden" value="([^'"]+)" /&gt;</stringProp>
-        <stringProp name="RegexExtractor.template">$1$</stringProp>
-        <stringProp name="RegexExtractor.default"/>
-        <stringProp name="RegexExtractor.match_number">1</stringProp>
-      </RegexExtractor>
-      <hashTree/>
-      <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert form_key extracted" enabled="true">
-        <collectionProp name="Asserion.test_strings">
-          <stringProp name="2845929">^.+$</stringProp>
-        </collectionProp>
-        <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
-        <boolProp name="Assertion.assume_success">false</boolProp>
-        <intProp name="Assertion.test_type">1</intProp>
-        <stringProp name="Assertion.scope">variable</stringProp>
-        <stringProp name="Scope.variable">admin_form_key</stringProp>
-      </ResponseAssertion>
-      <hashTree/>
+      </hashTree>
     </hashTree>
   
-    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="SetUp - Login Submit Form" enabled="true">
-      <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
-        <collectionProp name="Arguments.arguments">
-          <elementProp name="dummy" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value"/>
-            <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">dummy</stringProp>
-          </elementProp>
-          <elementProp name="form_key" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">${admin_form_key}</stringProp>
-            <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">form_key</stringProp>
-          </elementProp>
-          <elementProp name="login[password]" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">${admin_password}</stringProp>
-            <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">login[password]</stringProp>
-          </elementProp>
-          <elementProp name="login[username]" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">${admin_user}</stringProp>
-            <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">login[username]</stringProp>
-          </elementProp>
-        </collectionProp>
-      </elementProp>
-      <stringProp name="HTTPSampler.domain"/>
-      <stringProp name="HTTPSampler.port"/>
-      <stringProp name="HTTPSampler.connect_timeout"/>
-      <stringProp name="HTTPSampler.response_timeout"/>
-      <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
-      <stringProp name="HTTPSampler.contentEncoding"/>
-      <stringProp name="HTTPSampler.path">${base_path}${admin_path}/admin/dashboard/</stringProp>
-      <stringProp name="HTTPSampler.method">POST</stringProp>
-      <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
-      <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
-      <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
-      <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
-      <stringProp name="HTTPSampler.implementation">Java</stringProp>
-      <boolProp name="HTTPSampler.monitor">false</boolProp>
-      <stringProp name="HTTPSampler.embedded_url_re"/>
-      <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_login/admin_login_submit_form.jmx</stringProp>
-    </HTTPSamplerProxy>
-    <hashTree/>
-  </hashTree>
-  
-    <GenericController guiclass="LogicControllerGui" testclass="GenericController" testname="Simple Controller" enabled="true">
+    <GenericController guiclass="LogicControllerGui" testclass="GenericController" testname="Admin Create Configurable Product" enabled="true">
   <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/simple_controller.jmx</stringProp>
 </GenericController>
-    <hashTree>
-    <BeanShellSampler guiclass="BeanShellSamplerGui" testclass="BeanShellSampler" testname="SetUp - Set Arguments" enabled="true">
-      <stringProp name="BeanShellSampler.query">vars.put("entity", "catalog_product");
-String behavior = "${adminImportProductBehavior}";
-vars.put("adminImportBehavior", behavior);
-String filepath = "${files_folder}${adminImportProductFilePath}";
-vars.put("adminImportFilePath", filepath);  </stringProp>
-      <stringProp name="BeanShellSampler.filename"/>
-      <stringProp name="BeanShellSampler.parameters"/>
-      <boolProp name="BeanShellSampler.resetInterpreter">true</boolProp>
-    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/import_products/setup.jmx</stringProp></BeanShellSampler>
-    <hashTree/>
-  
-    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Import Page" enabled="true">
-      <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
-        <collectionProp name="Arguments.arguments"/>
-      </elementProp>
-      <stringProp name="HTTPSampler.domain"/>
-      <stringProp name="HTTPSampler.port"/>
-      <stringProp name="HTTPSampler.connect_timeout"/>
-      <stringProp name="HTTPSampler.response_timeout"/>
-      <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
-      <stringProp name="HTTPSampler.contentEncoding"/>
-      <stringProp name="HTTPSampler.path">${base_path}${admin_path}/admin/import/</stringProp>
-      <stringProp name="HTTPSampler.method">GET</stringProp>
-      <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
-      <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
-      <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
-      <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
-      <boolProp name="HTTPSampler.monitor">false</boolProp>
-      <stringProp name="HTTPSampler.embedded_url_re"/>
-    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/common/import.jmx</stringProp></HTTPSamplerProxy>
-    <hashTree>
-      <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert success" enabled="true">
-        <collectionProp name="Asserion.test_strings">
-          <stringProp name="1723813687">Import Settings</stringProp>
-        </collectionProp>
-        <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
-        <boolProp name="Assertion.assume_success">false</boolProp>
-        <intProp name="Assertion.test_type">2</intProp>
-      </ResponseAssertion>
-      <hashTree/>
-    </hashTree>
-  
-    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Import Validate" enabled="true">
-      <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
-        <collectionProp name="Arguments.arguments">
-          <elementProp name="form_key" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">${admin_form_key}</stringProp>
-            <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">form_key</stringProp>
-            <stringProp name="Argument.desc">false</stringProp>
-          </elementProp>
-          <elementProp name="entity" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">${entity}</stringProp>
-            <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">entity</stringProp>
-          </elementProp>
-          <elementProp name="behavior" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">${adminImportBehavior}</stringProp>
-            <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">behavior</stringProp>
-          </elementProp>
-          <elementProp name="validation_strategy" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">validation-stop-on-errors</stringProp>
-            <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">validation_strategy</stringProp>
-          </elementProp>
-          <elementProp name="allowed_error_count" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">10</stringProp>
-            <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">allowed_error_count</stringProp>
-          </elementProp>
-          <elementProp name="_import_field_separator" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">,</stringProp>
-            <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">_import_field_separator</stringProp>
-          </elementProp>
-          <elementProp name="_import_multiple_value_separator" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">,</stringProp>
-            <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">_import_multiple_value_separator</stringProp>
-          </elementProp>
-        </collectionProp>
-      </elementProp>
-      <stringProp name="HTTPSampler.domain"/>
-      <stringProp name="HTTPSampler.port"/>
-      <stringProp name="HTTPSampler.connect_timeout"/>
-      <stringProp name="HTTPSampler.response_timeout"/>
-      <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
-      <stringProp name="HTTPSampler.contentEncoding"/>
-      <stringProp name="HTTPSampler.path">${base_path}${admin_path}/admin/import/validate</stringProp>
-      <stringProp name="HTTPSampler.method">POST</stringProp>
-      <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
-      <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
-      <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
-      <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
-      <stringProp name="HTTPSampler.implementation">HttpClient4</stringProp>
-      <elementProp name="HTTPsampler.Files" elementType="HTTPFileArgs">
-        <collectionProp name="HTTPFileArgs.files">
-          <elementProp name="${adminImportFilePath}" elementType="HTTPFileArg">
-            <stringProp name="File.path">${adminImportFilePath}</stringProp>
-            <stringProp name="File.paramname">import_file</stringProp>
-            <stringProp name="File.mimetype">application/vnd.ms-excel</stringProp>
-          </elementProp>
-        </collectionProp>
-      </elementProp>
-      <boolProp name="HTTPSampler.monitor">false</boolProp>
-      <stringProp name="HTTPSampler.embedded_url_re"/>
-    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/common/import_validate.jmx</stringProp></HTTPSamplerProxy>
-    <hashTree>
-      <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Response Assertion" enabled="true">
-        <collectionProp name="Asserion.test_strings">
-          <stringProp name="37280142">File is valid! To start import process</stringProp>
-        </collectionProp>
-        <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
-        <boolProp name="Assertion.assume_success">false</boolProp>
-        <intProp name="Assertion.test_type">16</intProp>
-      </ResponseAssertion>
-      <hashTree/>
-    </hashTree>
-  
-    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Import Start" enabled="true">
-      <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
-        <collectionProp name="Arguments.arguments">
-          <elementProp name="form_key" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">${admin_form_key}</stringProp>
-            <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">form_key</stringProp>
-            <stringProp name="Argument.desc">false</stringProp>
-          </elementProp>
-          <elementProp name="entity" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">${entity}</stringProp>
-            <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">entity</stringProp>
-          </elementProp>
-          <elementProp name="behavior" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">${adminImportBehavior}</stringProp>
-            <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">behavior</stringProp>
-          </elementProp>
-          <elementProp name="validation_strategy" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">validation-stop-on-errors</stringProp>
-            <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">validation_strategy</stringProp>
-            <stringProp name="Argument.desc">false</stringProp>
-          </elementProp>
-          <elementProp name="allowed_error_count" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">10</stringProp>
-            <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">allowed_error_count</stringProp>
-            <stringProp name="Argument.desc">false</stringProp>
-          </elementProp>
-          <elementProp name="_import_field_separator" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">,</stringProp>
-            <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">_import_field_separator</stringProp>
-            <stringProp name="Argument.desc">false</stringProp>
-          </elementProp>
-          <elementProp name="_import_multiple_value_separator" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">,</stringProp>
-            <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">_import_multiple_value_separator</stringProp>
-            <stringProp name="Argument.desc">false</stringProp>
-          </elementProp>
-        </collectionProp>
-      </elementProp>
-      <stringProp name="HTTPSampler.domain"/>
-      <stringProp name="HTTPSampler.port"/>
-      <stringProp name="HTTPSampler.connect_timeout"/>
-      <stringProp name="HTTPSampler.response_timeout"/>
-      <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
-      <stringProp name="HTTPSampler.contentEncoding"/>
-      <stringProp name="HTTPSampler.path">${base_path}${admin_path}/admin/import/start</stringProp>
-      <stringProp name="HTTPSampler.method">POST</stringProp>
-      <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
-      <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
-      <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
-      <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
-      <stringProp name="HTTPSampler.implementation">HttpClient4</stringProp>
-      <elementProp name="HTTPsampler.Files" elementType="HTTPFileArgs">
-        <collectionProp name="HTTPFileArgs.files">
-          <elementProp name="${adminImportFilePath}" elementType="HTTPFileArg">
-            <stringProp name="File.path">${adminImportFilePath}</stringProp>
-            <stringProp name="File.paramname">import_file</stringProp>
-            <stringProp name="File.mimetype">application/vnd.ms-excel</stringProp>
-          </elementProp>
-        </collectionProp>
-      </elementProp>
-      <boolProp name="HTTPSampler.monitor">false</boolProp>
-      <stringProp name="HTTPSampler.embedded_url_re"/>
-    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/common/import_save.jmx</stringProp></HTTPSamplerProxy>
-    <hashTree>
-      <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Response Assertion" enabled="true">
-        <collectionProp name="Asserion.test_strings">
-          <stringProp name="-1731221824">Import successfully done</stringProp>
-        </collectionProp>
-        <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
-        <boolProp name="Assertion.assume_success">false</boolProp>
-        <intProp name="Assertion.test_type">16</intProp>
-      </ResponseAssertion>
-      <hashTree/>
-    </hashTree>
-  </hashTree>
-  </hashTree>
-
-  
-    <ThroughputController guiclass="ThroughputControllerGui" testclass="ThroughputController" testname="Import Customers" enabled="true">
-      <intProp name="ThroughputController.style">1</intProp>
-      <boolProp name="ThroughputController.perThread">false</boolProp>
-      <intProp name="ThroughputController.maxThroughput">1</intProp>
-      <stringProp name="ThroughputController.percentThroughput">${importCustomersPercentage}</stringProp>
-    <stringProp name="TestPlan.comments">mpaf/tool/fragments/_system/scenario_controller_tmpl.jmx</stringProp></ThroughputController>
-    <hashTree>
-        <JSR223PreProcessor guiclass="TestBeanGUI" testclass="JSR223PreProcessor" testname="Set Test Label" enabled="true">
-            <stringProp name="script">
-var testLabel = "${testLabel}" ? " (${testLabel})" : "";
-if (testLabel
-    &amp;&amp; sampler.getClass().getName() == 'org.apache.jmeter.protocol.http.sampler.HTTPSamplerProxy'
-) {
-    if (sampler.getName().indexOf(testLabel) == -1) {
-       sampler.setName(sampler.getName() + testLabel);
-    }
-} else if (sampler.getName().indexOf("SetUp - ") == -1) {
-    sampler.setName("SetUp - " + sampler.getName());
-}
-            </stringProp>
-            <stringProp name="scriptLanguage">javascript</stringProp>
-        <stringProp name="TestPlan.comments">mpaf/tool/fragments/_system/setup_label.jmx</stringProp></JSR223PreProcessor>
-        <hashTree/>
-        <BeanShellSampler guiclass="BeanShellSamplerGui" testclass="BeanShellSampler" testname="SetUp - Set Label" enabled="true">
-            <stringProp name="BeanShellSampler.query">
-                vars.put("testLabel", "Import Customers");
-            </stringProp>
-            <boolProp name="BeanShellSampler.resetInterpreter">true</boolProp>
-        </BeanShellSampler>
-        <hashTree/>
-    
-    <BeanShellSampler guiclass="BeanShellSamplerGui" testclass="BeanShellSampler" testname="SetUp - Set Arguments" enabled="true">
-      <stringProp name="BeanShellSampler.query">vars.put("entity", "customer");
-String behavior = "${adminImportCustomerBehavior}";
-vars.put("adminImportBehavior", behavior);
-String filepath = "${files_folder}${adminImportCustomerFilePath}";
-vars.put("adminImportFilePath", filepath);  </stringProp>
-      <stringProp name="BeanShellSampler.filename"/>
-      <stringProp name="BeanShellSampler.parameters"/>
-      <boolProp name="BeanShellSampler.resetInterpreter">true</boolProp>
-    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/import_customers/setup.jmx</stringProp></BeanShellSampler>
-    <hashTree/>
-  
-        <JSR223PostProcessor guiclass="TestBeanGUI" testclass="JSR223PostProcessor" testname="Get admin form key PostProcessor" enabled="true">
-        <stringProp name="script">
-        function getFormKeyFromResponse()
-        {
-            var url = prev.getUrlAsString(),
-            responseCode =  prev.getResponseCode(),
-            formKey = null;
-            searchPattern = /var FORM_KEY = '(.+)'/;
-            if (responseCode == "200" &amp;&amp; url) {
-                response = prev.getResponseDataAsString();
-                formKey = response  &amp;&amp; response.match(searchPattern) ? response.match(searchPattern)[1] : null;
-            }
-            return formKey;
-        }
-
-        formKey = vars.get("form_key_storage");
-
-	   currentFormKey = getFormKeyFromResponse();
-
-	   if (currentFormKey != null &amp;&amp; currentFormKey != formKey) {
-		  vars.put("form_key_storage", currentFormKey);
-	   }
-        </stringProp>
-        <stringProp name="scriptLanguage">javascript</stringProp>
-        <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin/handle_admin_form_key.jmx</stringProp></JSR223PostProcessor>
-        <hashTree/>
-        <JSR223PreProcessor guiclass="TestBeanGUI" testclass="JSR223PreProcessor" testname="Set admin form key PreProcessor" enabled="true">
-            <stringProp name="script">
-                formKey =  vars.get("form_key_storage");
-                if (formKey
-                    &amp;&amp; sampler.getClass().getName() == 'org.apache.jmeter.protocol.http.sampler.HTTPSamplerProxy'
-                    &amp;&amp; sampler.getMethod() == "POST")
-                    {
-                        arguments = sampler.getArguments();
-                        for (i=0; i&lt;arguments.getArgumentCount(); i++)
-                        {
-                            argument = arguments.getArgument(i);
-                            if (argument.getName() == 'form_key' &amp;&amp; argument.getValue() != formKey) {
-                            log.info("admin form key updated: " + argument.getValue() + " =&gt; " + formKey);
-                            argument.setValue(formKey);
-                        }
-                    }
-                }
-            </stringProp>
-            <stringProp name="scriptLanguage">javascript</stringProp>
-        </JSR223PreProcessor>
-        <hashTree/>
-    
-    <CookieManager guiclass="CookiePanel" testclass="CookieManager" testname="HTTP Cookie Manager" enabled="true">
-      <collectionProp name="CookieManager.cookies"/>
-      <boolProp name="CookieManager.clearEachIteration">false</boolProp>
-    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/http_cookie_manager_without_clear_each_iteration.jmx</stringProp></CookieManager>
-    <hashTree/>
-  
-    <OnceOnlyController guiclass="OnceOnlyControllerGui" testclass="OnceOnlyController" testname="Once Only Controller" enabled="true">
-  <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/once_only_controller.jmx</stringProp>
-</OnceOnlyController>
-    <hashTree>
-    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="SetUp - Login" enabled="true">
-      <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
-        <collectionProp name="Arguments.arguments"/>
-      </elementProp>
-      <stringProp name="HTTPSampler.domain"/>
-      <stringProp name="HTTPSampler.port"/>
-      <stringProp name="HTTPSampler.connect_timeout"/>
-      <stringProp name="HTTPSampler.response_timeout"/>
-      <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
-      <stringProp name="HTTPSampler.contentEncoding"/>
-      <stringProp name="HTTPSampler.path">${base_path}${admin_path}</stringProp>
-      <stringProp name="HTTPSampler.method">GET</stringProp>
-      <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
-      <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
-      <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
-      <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
-      <boolProp name="HTTPSampler.monitor">false</boolProp>
-      <stringProp name="HTTPSampler.embedded_url_re"/>
-    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_login/admin_login.jmx</stringProp></HTTPSamplerProxy>
-    <hashTree>
-      <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert login form shown" enabled="true">
-        <collectionProp name="Asserion.test_strings">
-          <stringProp name="-1397214398">Welcome</stringProp>
-          <stringProp name="-515240035">&lt;title&gt;Magento Admin&lt;/title&gt;</stringProp>
-        </collectionProp>
-        <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
-        <boolProp name="Assertion.assume_success">false</boolProp>
-        <intProp name="Assertion.test_type">2</intProp>
-      </ResponseAssertion>
-      <hashTree/>
-      <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract form key" enabled="true">
-        <stringProp name="RegexExtractor.useHeaders">false</stringProp>
-        <stringProp name="RegexExtractor.refname">admin_form_key</stringProp>
-        <stringProp name="RegexExtractor.regex">&lt;input name="form_key" type="hidden" value="([^'"]+)" /&gt;</stringProp>
-        <stringProp name="RegexExtractor.template">$1$</stringProp>
-        <stringProp name="RegexExtractor.default"/>
-        <stringProp name="RegexExtractor.match_number">1</stringProp>
-      </RegexExtractor>
-      <hashTree/>
-      <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert form_key extracted" enabled="true">
-        <collectionProp name="Asserion.test_strings">
-          <stringProp name="2845929">^.+$</stringProp>
-        </collectionProp>
-        <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
-        <boolProp name="Assertion.assume_success">false</boolProp>
-        <intProp name="Assertion.test_type">1</intProp>
-        <stringProp name="Assertion.scope">variable</stringProp>
-        <stringProp name="Scope.variable">admin_form_key</stringProp>
-      </ResponseAssertion>
-      <hashTree/>
-    </hashTree>
-  
-    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="SetUp - Login Submit Form" enabled="true">
+    <hashTree>
+    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Catalog Product" enabled="true">
       <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
-        <collectionProp name="Arguments.arguments">
-          <elementProp name="dummy" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value"/>
-            <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">dummy</stringProp>
-          </elementProp>
-          <elementProp name="form_key" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">${admin_form_key}</stringProp>
-            <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">form_key</stringProp>
-          </elementProp>
-          <elementProp name="login[password]" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">${admin_password}</stringProp>
-            <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">login[password]</stringProp>
-          </elementProp>
-          <elementProp name="login[username]" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">${admin_user}</stringProp>
-            <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">login[username]</stringProp>
-          </elementProp>
-        </collectionProp>
+        <collectionProp name="Arguments.arguments"/>
       </elementProp>
       <stringProp name="HTTPSampler.domain"/>
       <stringProp name="HTTPSampler.port"/>
@@ -31259,25 +23045,28 @@ vars.put("adminImportFilePath", filepath);  </stringProp>
       <stringProp name="HTTPSampler.response_timeout"/>
       <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
       <stringProp name="HTTPSampler.contentEncoding"/>
-      <stringProp name="HTTPSampler.path">${base_path}${admin_path}/admin/dashboard/</stringProp>
-      <stringProp name="HTTPSampler.method">POST</stringProp>
+      <stringProp name="HTTPSampler.path">${base_path}${admin_path}/catalog/product/</stringProp>
+      <stringProp name="HTTPSampler.method">GET</stringProp>
       <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
       <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
       <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
       <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
-      <stringProp name="HTTPSampler.implementation">Java</stringProp>
       <boolProp name="HTTPSampler.monitor">false</boolProp>
       <stringProp name="HTTPSampler.embedded_url_re"/>
-      <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_login/admin_login_submit_form.jmx</stringProp>
-    </HTTPSamplerProxy>
-    <hashTree/>
-  </hashTree>
-  
-    <GenericController guiclass="LogicControllerGui" testclass="GenericController" testname="Simple Controller" enabled="true">
-  <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/simple_controller.jmx</stringProp>
-</GenericController>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_create_product/open_catalog_grid.jmx</stringProp></HTTPSamplerProxy>
     <hashTree>
-    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Import Page" enabled="true">
+      <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Response Assertion" enabled="true">
+        <collectionProp name="Asserion.test_strings">
+          <stringProp name="1509986340">records found</stringProp>
+        </collectionProp>
+        <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
+        <boolProp name="Assertion.assume_success">false</boolProp>
+        <intProp name="Assertion.test_type">2</intProp>
+      </ResponseAssertion>
+      <hashTree/>
+    </hashTree>
+  
+    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="New Configurable Product" enabled="true">
       <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
         <collectionProp name="Arguments.arguments"/>
       </elementProp>
@@ -31287,7 +23076,7 @@ vars.put("adminImportFilePath", filepath);  </stringProp>
       <stringProp name="HTTPSampler.response_timeout"/>
       <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
       <stringProp name="HTTPSampler.contentEncoding"/>
-      <stringProp name="HTTPSampler.path">${base_path}${admin_path}/admin/import/</stringProp>
+      <stringProp name="HTTPSampler.path">${base_path}${admin_path}/catalog/product/new/set/${attribute_set_id}/type/configurable/</stringProp>
       <stringProp name="HTTPSampler.method">GET</stringProp>
       <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
       <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
@@ -31295,11 +23084,11 @@ vars.put("adminImportFilePath", filepath);  </stringProp>
       <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
       <boolProp name="HTTPSampler.monitor">false</boolProp>
       <stringProp name="HTTPSampler.embedded_url_re"/>
-    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/common/import.jmx</stringProp></HTTPSamplerProxy>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_create_product/new_configurable.jmx</stringProp></HTTPSamplerProxy>
     <hashTree>
-      <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert success" enabled="true">
+      <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Response Assertion" enabled="true">
         <collectionProp name="Asserion.test_strings">
-          <stringProp name="1723813687">Import Settings</stringProp>
+          <stringProp name="-144461265">New Product</stringProp>
         </collectionProp>
         <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
         <boolProp name="Assertion.assume_success">false</boolProp>
@@ -31308,368 +23097,506 @@ vars.put("adminImportFilePath", filepath);  </stringProp>
       <hashTree/>
     </hashTree>
   
-    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Import Validate" enabled="true">
+    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="New Configurable Product Validate" enabled="true">
       <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
         <collectionProp name="Arguments.arguments">
+          <elementProp name="ajax" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">true</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">ajax</stringProp>
+            <stringProp name="Argument.desc">false</stringProp>
+          </elementProp>
+          <elementProp name="isAjax" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">true</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">isAjax</stringProp>
+            <stringProp name="Argument.desc">false</stringProp>
+          </elementProp>
+          <elementProp name="affect_configurable_product_attributes" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">1</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">affect_configurable_product_attributes</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
+          </elementProp>
           <elementProp name="form_key" elementType="HTTPArgument">
             <boolProp name="HTTPArgument.always_encode">true</boolProp>
             <stringProp name="Argument.value">${admin_form_key}</stringProp>
             <stringProp name="Argument.metadata">=</stringProp>
             <boolProp name="HTTPArgument.use_equals">true</boolProp>
             <stringProp name="Argument.name">form_key</stringProp>
-            <stringProp name="Argument.desc">false</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
           </elementProp>
-          <elementProp name="entity" elementType="HTTPArgument">
+          <elementProp name="new-variations-attribute-set-id" elementType="HTTPArgument">
             <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">${entity}</stringProp>
+            <stringProp name="Argument.value">${attribute_set_id}</stringProp>
             <stringProp name="Argument.metadata">=</stringProp>
             <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">entity</stringProp>
+            <stringProp name="Argument.name">new-variations-attribute-set-id</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
           </elementProp>
-          <elementProp name="behavior" elementType="HTTPArgument">
+          <elementProp name="product[affect_product_custom_options]" elementType="HTTPArgument">
             <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">${adminImportBehavior}</stringProp>
+            <stringProp name="Argument.value">1</stringProp>
             <stringProp name="Argument.metadata">=</stringProp>
             <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">behavior</stringProp>
+            <stringProp name="Argument.name">product[affect_product_custom_options]</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
           </elementProp>
-          <elementProp name="validation_strategy" elementType="HTTPArgument">
+          <elementProp name="product[attribute_set_id]" elementType="HTTPArgument">
             <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">validation-stop-on-errors</stringProp>
+            <stringProp name="Argument.value">${attribute_set_id}</stringProp>
             <stringProp name="Argument.metadata">=</stringProp>
             <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">validation_strategy</stringProp>
+            <stringProp name="Argument.name">product[attribute_set_id]</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
           </elementProp>
-          <elementProp name="allowed_error_count" elementType="HTTPArgument">
+          <elementProp name="product[category_ids][0]" elementType="HTTPArgument">
             <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">10</stringProp>
+            <stringProp name="Argument.value">4</stringProp>
             <stringProp name="Argument.metadata">=</stringProp>
             <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">allowed_error_count</stringProp>
+            <stringProp name="Argument.name">product[category_ids][0]</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
           </elementProp>
-          <elementProp name="_import_field_separator" elementType="HTTPArgument">
+          <elementProp name="product[custom_layout_update]" elementType="HTTPArgument">
             <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">,</stringProp>
+            <stringProp name="Argument.value"/>
             <stringProp name="Argument.metadata">=</stringProp>
             <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">_import_field_separator</stringProp>
+            <stringProp name="Argument.name">product[custom_layout_update]</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
           </elementProp>
-          <elementProp name="_import_multiple_value_separator" elementType="HTTPArgument">
+          <elementProp name="product[description]" elementType="HTTPArgument">
             <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">,</stringProp>
+            <stringProp name="Argument.value"/>
             <stringProp name="Argument.metadata">=</stringProp>
             <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">_import_multiple_value_separator</stringProp>
+            <stringProp name="Argument.name">product[description]</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
           </elementProp>
-        </collectionProp>
-      </elementProp>
-      <stringProp name="HTTPSampler.domain"/>
-      <stringProp name="HTTPSampler.port"/>
-      <stringProp name="HTTPSampler.connect_timeout"/>
-      <stringProp name="HTTPSampler.response_timeout"/>
-      <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
-      <stringProp name="HTTPSampler.contentEncoding"/>
-      <stringProp name="HTTPSampler.path">${base_path}${admin_path}/admin/import/validate</stringProp>
-      <stringProp name="HTTPSampler.method">POST</stringProp>
-      <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
-      <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
-      <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
-      <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
-      <stringProp name="HTTPSampler.implementation">HttpClient4</stringProp>
-      <elementProp name="HTTPsampler.Files" elementType="HTTPFileArgs">
-        <collectionProp name="HTTPFileArgs.files">
-          <elementProp name="${adminImportFilePath}" elementType="HTTPFileArg">
-            <stringProp name="File.path">${adminImportFilePath}</stringProp>
-            <stringProp name="File.paramname">import_file</stringProp>
-            <stringProp name="File.mimetype">application/vnd.ms-excel</stringProp>
+          <elementProp name="product[gift_message_available]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">0</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">product[gift_message_available]</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
           </elementProp>
-        </collectionProp>
-      </elementProp>
-      <boolProp name="HTTPSampler.monitor">false</boolProp>
-      <stringProp name="HTTPSampler.embedded_url_re"/>
-    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/common/import_validate.jmx</stringProp></HTTPSamplerProxy>
-    <hashTree>
-      <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Response Assertion" enabled="true">
-        <collectionProp name="Asserion.test_strings">
-          <stringProp name="37280142">File is valid! To start import process</stringProp>
-        </collectionProp>
-        <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
-        <boolProp name="Assertion.assume_success">false</boolProp>
-        <intProp name="Assertion.test_type">16</intProp>
-      </ResponseAssertion>
-      <hashTree/>
-    </hashTree>
-  
-    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Import Start" enabled="true">
-      <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
-        <collectionProp name="Arguments.arguments">
-          <elementProp name="form_key" elementType="HTTPArgument">
+          <elementProp name="product[gift_wrapping_available]" elementType="HTTPArgument">
             <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">${admin_form_key}</stringProp>
+            <stringProp name="Argument.value">1</stringProp>
             <stringProp name="Argument.metadata">=</stringProp>
             <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">form_key</stringProp>
-            <stringProp name="Argument.desc">false</stringProp>
+            <stringProp name="Argument.name">product[gift_wrapping_available]</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
           </elementProp>
-          <elementProp name="entity" elementType="HTTPArgument">
+          <elementProp name="product[gift_wrapping_price]" elementType="HTTPArgument">
             <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">${entity}</stringProp>
+            <stringProp name="Argument.value"/>
             <stringProp name="Argument.metadata">=</stringProp>
             <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">entity</stringProp>
+            <stringProp name="Argument.name">product[gift_wrapping_price]</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
           </elementProp>
-          <elementProp name="behavior" elementType="HTTPArgument">
+          <elementProp name="product[image]" elementType="HTTPArgument">
             <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">${adminImportBehavior}</stringProp>
+            <stringProp name="Argument.value"/>
             <stringProp name="Argument.metadata">=</stringProp>
             <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">behavior</stringProp>
+            <stringProp name="Argument.name">product[image]</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
           </elementProp>
-          <elementProp name="validation_strategy" elementType="HTTPArgument">
+          <elementProp name="product[is_returnable]" elementType="HTTPArgument">
             <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">validation-stop-on-errors</stringProp>
+            <stringProp name="Argument.value">2</stringProp>
             <stringProp name="Argument.metadata">=</stringProp>
             <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">validation_strategy</stringProp>
-            <stringProp name="Argument.desc">false</stringProp>
+            <stringProp name="Argument.name">product[is_returnable]</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
           </elementProp>
-          <elementProp name="allowed_error_count" elementType="HTTPArgument">
+          <elementProp name="product[meta_description]" elementType="HTTPArgument">
             <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">10</stringProp>
+            <stringProp name="Argument.value">${configurable_sku} - Meta Description</stringProp>
             <stringProp name="Argument.metadata">=</stringProp>
             <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">allowed_error_count</stringProp>
-            <stringProp name="Argument.desc">false</stringProp>
+            <stringProp name="Argument.name">product[meta_description]</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
           </elementProp>
-          <elementProp name="_import_field_separator" elementType="HTTPArgument">
+          <elementProp name="product[meta_keyword]" elementType="HTTPArgument">
             <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">,</stringProp>
+            <stringProp name="Argument.value">${configurable_sku} - Meta Keyword</stringProp>
             <stringProp name="Argument.metadata">=</stringProp>
             <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">_import_field_separator</stringProp>
-            <stringProp name="Argument.desc">false</stringProp>
+            <stringProp name="Argument.name">product[meta_keyword]</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
           </elementProp>
-          <elementProp name="_import_multiple_value_separator" elementType="HTTPArgument">
+          <elementProp name="product[meta_title]" elementType="HTTPArgument">
             <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">,</stringProp>
+            <stringProp name="Argument.value">${configurable_sku} - Meta Title</stringProp>
             <stringProp name="Argument.metadata">=</stringProp>
             <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">_import_multiple_value_separator</stringProp>
-            <stringProp name="Argument.desc">false</stringProp>
+            <stringProp name="Argument.name">product[meta_title]</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
           </elementProp>
-        </collectionProp>
-      </elementProp>
-      <stringProp name="HTTPSampler.domain"/>
-      <stringProp name="HTTPSampler.port"/>
-      <stringProp name="HTTPSampler.connect_timeout"/>
-      <stringProp name="HTTPSampler.response_timeout"/>
-      <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
-      <stringProp name="HTTPSampler.contentEncoding"/>
-      <stringProp name="HTTPSampler.path">${base_path}${admin_path}/admin/import/start</stringProp>
-      <stringProp name="HTTPSampler.method">POST</stringProp>
-      <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
-      <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
-      <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
-      <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
-      <stringProp name="HTTPSampler.implementation">HttpClient4</stringProp>
-      <elementProp name="HTTPsampler.Files" elementType="HTTPFileArgs">
-        <collectionProp name="HTTPFileArgs.files">
-          <elementProp name="${adminImportFilePath}" elementType="HTTPFileArg">
-            <stringProp name="File.path">${adminImportFilePath}</stringProp>
-            <stringProp name="File.paramname">import_file</stringProp>
-            <stringProp name="File.mimetype">application/vnd.ms-excel</stringProp>
+          <elementProp name="product[name]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">${configurable_sku}</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">product[name]</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
           </elementProp>
-        </collectionProp>
-      </elementProp>
-      <boolProp name="HTTPSampler.monitor">false</boolProp>
-      <stringProp name="HTTPSampler.embedded_url_re"/>
-    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/common/import_save.jmx</stringProp></HTTPSamplerProxy>
-    <hashTree>
-      <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Response Assertion" enabled="true">
-        <collectionProp name="Asserion.test_strings">
-          <stringProp name="-1731221824">Import successfully done</stringProp>
-        </collectionProp>
-        <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
-        <boolProp name="Assertion.assume_success">false</boolProp>
-        <intProp name="Assertion.test_type">16</intProp>
-      </ResponseAssertion>
-      <hashTree/>
-    </hashTree>
-  </hashTree>
-  </hashTree>
-
-  
-    <ThroughputController guiclass="ThroughputControllerGui" testclass="ThroughputController" testname="Export Products" enabled="true">
-      <intProp name="ThroughputController.style">1</intProp>
-      <boolProp name="ThroughputController.perThread">false</boolProp>
-      <intProp name="ThroughputController.maxThroughput">1</intProp>
-      <stringProp name="ThroughputController.percentThroughput">${exportProductsPercentage}</stringProp>
-    <stringProp name="TestPlan.comments">mpaf/tool/fragments/_system/scenario_controller_tmpl.jmx</stringProp></ThroughputController>
-    <hashTree>
-        <JSR223PreProcessor guiclass="TestBeanGUI" testclass="JSR223PreProcessor" testname="Set Test Label" enabled="true">
-            <stringProp name="script">
-var testLabel = "${testLabel}" ? " (${testLabel})" : "";
-if (testLabel
-    &amp;&amp; sampler.getClass().getName() == 'org.apache.jmeter.protocol.http.sampler.HTTPSamplerProxy'
-) {
-    if (sampler.getName().indexOf(testLabel) == -1) {
-       sampler.setName(sampler.getName() + testLabel);
-    }
-} else if (sampler.getName().indexOf("SetUp - ") == -1) {
-    sampler.setName("SetUp - " + sampler.getName());
-}
-            </stringProp>
-            <stringProp name="scriptLanguage">javascript</stringProp>
-        <stringProp name="TestPlan.comments">mpaf/tool/fragments/_system/setup_label.jmx</stringProp></JSR223PreProcessor>
-        <hashTree/>
-        <BeanShellSampler guiclass="BeanShellSamplerGui" testclass="BeanShellSampler" testname="SetUp - Set Label" enabled="true">
-            <stringProp name="BeanShellSampler.query">
-                vars.put("testLabel", "Export Products");
-            </stringProp>
-            <boolProp name="BeanShellSampler.resetInterpreter">true</boolProp>
-        </BeanShellSampler>
-        <hashTree/>
-    
-        <JSR223PostProcessor guiclass="TestBeanGUI" testclass="JSR223PostProcessor" testname="Get admin form key PostProcessor" enabled="true">
-        <stringProp name="script">
-        function getFormKeyFromResponse()
-        {
-            var url = prev.getUrlAsString(),
-            responseCode =  prev.getResponseCode(),
-            formKey = null;
-            searchPattern = /var FORM_KEY = '(.+)'/;
-            if (responseCode == "200" &amp;&amp; url) {
-                response = prev.getResponseDataAsString();
-                formKey = response  &amp;&amp; response.match(searchPattern) ? response.match(searchPattern)[1] : null;
-            }
-            return formKey;
-        }
-
-        formKey = vars.get("form_key_storage");
-
-	   currentFormKey = getFormKeyFromResponse();
-
-	   if (currentFormKey != null &amp;&amp; currentFormKey != formKey) {
-		  vars.put("form_key_storage", currentFormKey);
-	   }
-        </stringProp>
-        <stringProp name="scriptLanguage">javascript</stringProp>
-        <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin/handle_admin_form_key.jmx</stringProp></JSR223PostProcessor>
-        <hashTree/>
-        <JSR223PreProcessor guiclass="TestBeanGUI" testclass="JSR223PreProcessor" testname="Set admin form key PreProcessor" enabled="true">
-            <stringProp name="script">
-                formKey =  vars.get("form_key_storage");
-                if (formKey
-                    &amp;&amp; sampler.getClass().getName() == 'org.apache.jmeter.protocol.http.sampler.HTTPSamplerProxy'
-                    &amp;&amp; sampler.getMethod() == "POST")
-                    {
-                        arguments = sampler.getArguments();
-                        for (i=0; i&lt;arguments.getArgumentCount(); i++)
-                        {
-                            argument = arguments.getArgument(i);
-                            if (argument.getName() == 'form_key' &amp;&amp; argument.getValue() != formKey) {
-                            log.info("admin form key updated: " + argument.getValue() + " =&gt; " + formKey);
-                            argument.setValue(formKey);
-                        }
-                    }
-                }
-            </stringProp>
-            <stringProp name="scriptLanguage">javascript</stringProp>
-        </JSR223PreProcessor>
-        <hashTree/>
-    
-    <CookieManager guiclass="CookiePanel" testclass="CookieManager" testname="HTTP Cookie Manager" enabled="true">
-      <collectionProp name="CookieManager.cookies"/>
-      <boolProp name="CookieManager.clearEachIteration">false</boolProp>
-    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/http_cookie_manager_without_clear_each_iteration.jmx</stringProp></CookieManager>
-    <hashTree/>
-  
-    <OnceOnlyController guiclass="OnceOnlyControllerGui" testclass="OnceOnlyController" testname="Once Only Controller" enabled="true">
-  <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/once_only_controller.jmx</stringProp>
-</OnceOnlyController>
-    <hashTree>
-    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="SetUp - Login" enabled="true">
-      <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
-        <collectionProp name="Arguments.arguments"/>
-      </elementProp>
-      <stringProp name="HTTPSampler.domain"/>
-      <stringProp name="HTTPSampler.port"/>
-      <stringProp name="HTTPSampler.connect_timeout"/>
-      <stringProp name="HTTPSampler.response_timeout"/>
-      <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
-      <stringProp name="HTTPSampler.contentEncoding"/>
-      <stringProp name="HTTPSampler.path">${base_path}${admin_path}</stringProp>
-      <stringProp name="HTTPSampler.method">GET</stringProp>
-      <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
-      <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
-      <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
-      <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
-      <boolProp name="HTTPSampler.monitor">false</boolProp>
-      <stringProp name="HTTPSampler.embedded_url_re"/>
-    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_login/admin_login.jmx</stringProp></HTTPSamplerProxy>
-    <hashTree>
-      <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert login form shown" enabled="true">
-        <collectionProp name="Asserion.test_strings">
-          <stringProp name="-1397214398">Welcome</stringProp>
-          <stringProp name="-515240035">&lt;title&gt;Magento Admin&lt;/title&gt;</stringProp>
-        </collectionProp>
-        <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
-        <boolProp name="Assertion.assume_success">false</boolProp>
-        <intProp name="Assertion.test_type">2</intProp>
-      </ResponseAssertion>
-      <hashTree/>
-      <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract form key" enabled="true">
-        <stringProp name="RegexExtractor.useHeaders">false</stringProp>
-        <stringProp name="RegexExtractor.refname">admin_form_key</stringProp>
-        <stringProp name="RegexExtractor.regex">&lt;input name="form_key" type="hidden" value="([^'"]+)" /&gt;</stringProp>
-        <stringProp name="RegexExtractor.template">$1$</stringProp>
-        <stringProp name="RegexExtractor.default"/>
-        <stringProp name="RegexExtractor.match_number">1</stringProp>
-      </RegexExtractor>
-      <hashTree/>
-      <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert form_key extracted" enabled="true">
-        <collectionProp name="Asserion.test_strings">
-          <stringProp name="2845929">^.+$</stringProp>
-        </collectionProp>
-        <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
-        <boolProp name="Assertion.assume_success">false</boolProp>
-        <intProp name="Assertion.test_type">1</intProp>
-        <stringProp name="Assertion.scope">variable</stringProp>
-        <stringProp name="Scope.variable">admin_form_key</stringProp>
-      </ResponseAssertion>
-      <hashTree/>
-    </hashTree>
-  
-    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="SetUp - Login Submit Form" enabled="true">
-      <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
-        <collectionProp name="Arguments.arguments">
-          <elementProp name="dummy" elementType="HTTPArgument">
+          <elementProp name="product[options_container]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">container2</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">product[options_container]</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
+          </elementProp>
+          <elementProp name="product[price]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">${price_new}</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">product[price]</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
+          </elementProp>
+          <elementProp name="product[product_has_weight]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">1</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">product[product_has_weight]</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
+          </elementProp>
+          <elementProp name="product[quantity_and_stock_status][is_in_stock]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">1</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">product[quantity_and_stock_status][is_in_stock]</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
+          </elementProp>
+          <elementProp name="product[quantity_and_stock_status][qty]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">1000</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">product[quantity_and_stock_status][qty]</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
+          </elementProp>
+          <elementProp name="product[short_description]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value"/>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">product[short_description]</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
+          </elementProp>
+          <elementProp name="product[sku]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">${configurable_sku}</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">product[sku]</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
+          </elementProp>
+          <elementProp name="product[small_image]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value"/>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">product[small_image]</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
+          </elementProp>
+          <elementProp name="product[special_price]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">${special_price_new}</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">product[special_price]</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
+          </elementProp>
+          <elementProp name="product[status]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">1</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">product[status]</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
+          </elementProp>
+          <elementProp name="product[stock_data][backorders]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">0</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">product[stock_data][backorders]</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
+          </elementProp>
+          <elementProp name="product[stock_data][deferred_stock_update]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">1</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">product[stock_data][deferred_stock_update]</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
+          </elementProp>
+          <elementProp name="product[stock_data][enable_qty_increments]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">0</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">product[stock_data][enable_qty_increments]</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
+          </elementProp>
+          <elementProp name="product[stock_data][is_decimal_divided]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">0</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">product[stock_data][is_decimal_divided]</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
+          </elementProp>
+          <elementProp name="product[stock_data][is_qty_decimal]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">0</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">product[stock_data][is_qty_decimal]</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
+          </elementProp>
+          <elementProp name="product[stock_data][manage_stock]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">1</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">product[stock_data][manage_stock]</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
+          </elementProp>
+          <elementProp name="product[stock_data][max_sale_qty]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">10000</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">product[stock_data][max_sale_qty]</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
+          </elementProp>
+          <elementProp name="product[stock_data][min_qty]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">0</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">product[stock_data][min_qty]</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
+          </elementProp>
+          <elementProp name="product[stock_data][min_sale_qty]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">1</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">product[stock_data][min_sale_qty]</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
+          </elementProp>
+          <elementProp name="product[stock_data][notify_stock_qty]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">1</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">product[stock_data][notify_stock_qty]</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
+          </elementProp>
+          <elementProp name="product[stock_data][qty_increments]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">1</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">product[stock_data][qty_increments]</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
+          </elementProp>
+          <elementProp name="product[stock_data][use_config_backorders]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">1</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">product[stock_data][use_config_backorders]</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
+          </elementProp>
+          <elementProp name="product[stock_data][use_config_deferred_stock_update]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">1</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">product[stock_data][use_config_deferred_stock_update]</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
+          </elementProp>
+          <elementProp name="product[stock_data][use_config_enable_qty_increments]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">1</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">product[stock_data][use_config_enable_qty_increments]</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
+          </elementProp>
+          <elementProp name="product[stock_data][use_config_manage_stock]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">1</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">product[stock_data][use_config_manage_stock]</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
+          </elementProp>
+          <elementProp name="product[stock_data][use_config_max_sale_qty]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">1</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">product[stock_data][use_config_max_sale_qty]</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
+          </elementProp>
+          <elementProp name="product[stock_data][use_config_min_qty]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">1</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">product[stock_data][use_config_min_qty]</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
+          </elementProp>
+          <elementProp name="product[stock_data][use_config_min_sale_qty]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">1</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">product[stock_data][use_config_min_sale_qty]</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
+          </elementProp>
+          <elementProp name="product[stock_data][use_config_notify_stock_qty]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">1</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">product[stock_data][use_config_notify_stock_qty]</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
+          </elementProp>
+          <elementProp name="product[stock_data][use_config_qty_increments]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">1</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">product[stock_data][use_config_qty_increments]</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
+          </elementProp>
+          <elementProp name="product[tax_class_id]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">2</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">product[tax_class_id]</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
+          </elementProp>
+          <elementProp name="product[thumbnail]" elementType="HTTPArgument">
             <boolProp name="HTTPArgument.always_encode">true</boolProp>
             <stringProp name="Argument.value"/>
             <stringProp name="Argument.metadata">=</stringProp>
             <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">dummy</stringProp>
+            <stringProp name="Argument.name">product[thumbnail]</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
           </elementProp>
-          <elementProp name="form_key" elementType="HTTPArgument">
+          <elementProp name="product[url_key]" elementType="HTTPArgument">
             <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">${admin_form_key}</stringProp>
+            <stringProp name="Argument.value"/>
             <stringProp name="Argument.metadata">=</stringProp>
             <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">form_key</stringProp>
+            <stringProp name="Argument.name">product[url_key]</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
           </elementProp>
-          <elementProp name="login[password]" elementType="HTTPArgument">
+          <elementProp name="product[use_config_gift_message_available]" elementType="HTTPArgument">
             <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">${admin_password}</stringProp>
+            <stringProp name="Argument.value">1</stringProp>
             <stringProp name="Argument.metadata">=</stringProp>
             <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">login[password]</stringProp>
+            <stringProp name="Argument.name">product[use_config_gift_message_available]</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
           </elementProp>
-          <elementProp name="login[username]" elementType="HTTPArgument">
+          <elementProp name="product[use_config_gift_wrapping_available]" elementType="HTTPArgument">
             <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">${admin_user}</stringProp>
+            <stringProp name="Argument.value">1</stringProp>
             <stringProp name="Argument.metadata">=</stringProp>
             <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">login[username]</stringProp>
+            <stringProp name="Argument.name">product[use_config_gift_wrapping_available]</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
+          </elementProp>
+          <elementProp name="product[use_config_is_returnable]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">1</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">product[use_config_is_returnable]</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
+          </elementProp>
+          <elementProp name="product[visibility]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">4</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">product[visibility]</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
+          </elementProp>
+          <elementProp name="product[website_ids][1]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">1</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">product[website_ids][1]</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
+          </elementProp>
+          <elementProp name="links[related][0][id]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">${related_product_id}</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">links[related][0][id]</stringProp>
+          </elementProp>
+          <elementProp name="links[related][0][position]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">1</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">links[related][0][position]</stringProp>
+          </elementProp>
+          <elementProp name="links[upsell][0][id]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">${related_product_id}</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">links[upsell][0][id]</stringProp>
+          </elementProp>
+          <elementProp name="links[upsell][0][position]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">1</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">links[upsell][0][position]</stringProp>
+          </elementProp>
+          <elementProp name="links[crosssell][0][id]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">${related_product_id}</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">links[crosssell][0][id]</stringProp>
+          </elementProp>
+          <elementProp name="links[crosssell][0][position]" elementType="HTTPArgument">
+            <boolProp name="HTTPArgument.always_encode">true</boolProp>
+            <stringProp name="Argument.value">1</stringProp>
+            <stringProp name="Argument.metadata">=</stringProp>
+            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">links[crosssell][0][position]</stringProp>
           </elementProp>
         </collectionProp>
       </elementProp>
@@ -31679,610 +23606,7787 @@ if (testLabel
       <stringProp name="HTTPSampler.response_timeout"/>
       <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
       <stringProp name="HTTPSampler.contentEncoding"/>
-      <stringProp name="HTTPSampler.path">${base_path}${admin_path}/admin/dashboard/</stringProp>
+      <stringProp name="HTTPSampler.path">${base_path}${admin_path}/catalog/product/validate/set/${attribute_set_id}/</stringProp>
       <stringProp name="HTTPSampler.method">POST</stringProp>
       <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
       <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
       <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
       <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
-      <stringProp name="HTTPSampler.implementation">Java</stringProp>
-      <boolProp name="HTTPSampler.monitor">false</boolProp>
-      <stringProp name="HTTPSampler.embedded_url_re"/>
-      <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_login/admin_login_submit_form.jmx</stringProp>
-    </HTTPSamplerProxy>
-    <hashTree/>
-  </hashTree>
-  
-    <GenericController guiclass="LogicControllerGui" testclass="GenericController" testname="Simple Controller" enabled="true">
-  <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/simple_controller.jmx</stringProp>
-</GenericController>
-    <hashTree>
-    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Export Page" enabled="true">
-      <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
-        <collectionProp name="Arguments.arguments"/>
-      </elementProp>
-      <stringProp name="HTTPSampler.domain"/>
-      <stringProp name="HTTPSampler.port"/>
-      <stringProp name="HTTPSampler.connect_timeout"/>
-      <stringProp name="HTTPSampler.response_timeout"/>
-      <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
-      <stringProp name="HTTPSampler.contentEncoding"/>
-      <stringProp name="HTTPSampler.path">${base_path}${admin_path}/admin/export/</stringProp>
-      <stringProp name="HTTPSampler.method">GET</stringProp>
-      <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
-      <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
-      <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
-      <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
       <boolProp name="HTTPSampler.monitor">false</boolProp>
       <stringProp name="HTTPSampler.embedded_url_re"/>
-    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/common/export.jmx</stringProp></HTTPSamplerProxy>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_create_product/configurable_validate.jmx</stringProp></HTTPSamplerProxy>
     <hashTree>
-      <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert success" enabled="true">
+      <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Response Assertion" enabled="true">
         <collectionProp name="Asserion.test_strings">
-          <stringProp name="1723813687">Export Settings</stringProp>
+          <stringProp name="1853918323">{"error":false}</stringProp>
         </collectionProp>
         <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
         <boolProp name="Assertion.assume_success">false</boolProp>
         <intProp name="Assertion.test_type">2</intProp>
       </ResponseAssertion>
       <hashTree/>
+    
+        <JSR223PreProcessor guiclass="TestBeanGUI" testclass="JSR223PreProcessor" testname="Prepare Configurable Data" enabled="true">
+            <stringProp name="scriptLanguage">javascript</stringProp>
+            <stringProp name="parameters"/>
+            <stringProp name="filename"/>
+            <stringProp name="cacheKey"/>
+            <stringProp name="script">
+attributes = vars.getObject("product_attributes");
+
+for (i in attributes) {
+    var attribute = attributes[i];
+    sampler.addArgument("attribute_codes[" + i + "]", attribute.code);
+    sampler.addArgument("attributes[" + i + "]", attribute.id);
+    sampler.addArgument("product[" + attribute.code + "]", attribute.options[0].value);
+    addConfigurableAttributeData(attribute);
+}
+
+addConfigurableMatrix(attributes);
+
+function addConfigurableAttributeData(attribute) {
+    var attributeId = attribute.id;
+
+    sampler.addArgument("product[configurable_attributes_data][" + attributeId + "][attribute_id]", attributeId);
+    sampler.addArgument("product[configurable_attributes_data][" + attributeId + "][code]", attribute.code);
+    sampler.addArgument("product[configurable_attributes_data][" + attributeId + "][label]", attribute.label);
+    sampler.addArgument("product[configurable_attributes_data][" + attributeId + "][position]", 0);
+    attribute.options.forEach(function (option, index) {
+        sampler.addArgument("product[configurable_attributes_data][" + attributeId + "][values][" + option.value + "][include]", index);
+        sampler.addArgument("product[configurable_attributes_data][" + attributeId + "][values][" + option.value + "][value_index]", option.value);
+    });
+}
+
+/**
+ * Build 4 simple products for Configurable
+ */
+function addConfigurableMatrix(attributes) {
+
+    var attribute1 = attributes[0],
+        attribute2 = attributes[1],
+        productIndex = 1,
+        products = [];
+    var variationNames = [];
+    attribute1.options.forEach(function (option1) {
+        attribute2.options.forEach(function (option2) {
+            var productAttributes = {},
+                namePart = option1.label + "+" + option2.label,
+                variationKey = option1.value + "-" + option2.value;
+            productAttributes[attribute1.code] = option1.value;
+            productAttributes[attribute2.code] = option2.value;
+
+            variationNames.push(namePart + " - " + vars.get("configurable_sku"));
+            var product = {
+                "id": null,
+                "name": namePart + " - " + vars.get("configurable_sku"),
+                "sku": namePart + " - " + vars.get("configurable_sku"),
+                "status": 1,
+                "price": "100",
+                "price_currency": "$",
+                "price_string": "$100",
+                "weight": "6",
+                "qty": "50",
+                "variationKey": variationKey,
+                "configurable_attribute": JSON.stringify(productAttributes),
+                "thumbnail_image": "",
+                "media_gallery": {"images": {}},
+                "image": [],
+                "was_changed": true,
+                "canEdit": 1,
+                "newProduct": 1,
+                "record_id": productIndex
+            };
+            productIndex++;
+            products.push(product);
+        });
+    });
+
+    sampler.addArgument("configurable-matrix-serialized", JSON.stringify(products));
+    vars.putObject("configurable_variations_assertion", variationNames);
+}
+            </stringProp>
+        <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_create_product/configurable_prepare_data.jmx</stringProp></JSR223PreProcessor>
+        <hashTree/>
     </hashTree>
   
-    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Export Products" enabled="true">
+    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="New Configurable Product Save" enabled="true">
       <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
         <collectionProp name="Arguments.arguments">
-          <elementProp name="form_key" elementType="HTTPArgument">
+          <elementProp name="ajax" elementType="HTTPArgument">
             <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.name">form_key</stringProp>
-            <stringProp name="Argument.value">${admin_form_key}</stringProp>
+            <stringProp name="Argument.value">true</stringProp>
             <stringProp name="Argument.metadata">=</stringProp>
             <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">ajax</stringProp>
+            <stringProp name="Argument.desc">false</stringProp>
           </elementProp>
-          <elementProp name="attribute_code" elementType="HTTPArgument">
+          <elementProp name="isAjax" elementType="HTTPArgument">
             <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.name">attribute_code</stringProp>
-            <stringProp name="Argument.value"/>
+            <stringProp name="Argument.value">true</stringProp>
             <stringProp name="Argument.metadata">=</stringProp>
             <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">isAjax</stringProp>
+            <stringProp name="Argument.desc">false</stringProp>
           </elementProp>
-          <elementProp name="export_filter[allow_message][]" elementType="HTTPArgument">
+          <elementProp name="affect_configurable_product_attributes" elementType="HTTPArgument">
             <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.name">export_filter[allow_message][]</stringProp>
-            <stringProp name="Argument.value">,</stringProp>
+            <stringProp name="Argument.value">1</stringProp>
             <stringProp name="Argument.metadata">=</stringProp>
             <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">affect_configurable_product_attributes</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
           </elementProp>
-          <elementProp name="export_filter[allow_open_amount]" elementType="HTTPArgument">
+          <elementProp name="form_key" elementType="HTTPArgument">
             <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.name">export_filter[allow_open_amount]</stringProp>
-            <stringProp name="Argument.value"/>
+            <stringProp name="Argument.value">${admin_form_key}</stringProp>
             <stringProp name="Argument.metadata">=</stringProp>
             <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">form_key</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
           </elementProp>
-          <elementProp name="export_filter[category_ids]" elementType="HTTPArgument">
+          <elementProp name="new-variations-attribute-set-id" elementType="HTTPArgument">
             <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.name">export_filter[category_ids]</stringProp>
-            <stringProp name="Argument.value">24,25,26,27,28,29,30</stringProp>
+            <stringProp name="Argument.value">${attribute_set_id}</stringProp>
             <stringProp name="Argument.metadata">=</stringProp>
             <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">new-variations-attribute-set-id</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
           </elementProp>
-          <elementProp name="export_filter[configurable_variations]" elementType="HTTPArgument">
+          <elementProp name="product[affect_product_custom_options]" elementType="HTTPArgument">
             <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.name">export_filter[configurable_variations]</stringProp>
-            <stringProp name="Argument.value"/>
+            <stringProp name="Argument.value">1</stringProp>
             <stringProp name="Argument.metadata">=</stringProp>
             <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">product[affect_product_custom_options]</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
           </elementProp>
-          <elementProp name="export_filter[cost][]" elementType="HTTPArgument">
+          <elementProp name="product[attribute_set_id]" elementType="HTTPArgument">
             <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.name">export_filter[cost][]</stringProp>
-            <stringProp name="Argument.value">,</stringProp>
+            <stringProp name="Argument.value">${attribute_set_id}</stringProp>
             <stringProp name="Argument.metadata">=</stringProp>
             <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">product[attribute_set_id]</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
           </elementProp>
-          <elementProp name="export_filter[country_of_manufacture]" elementType="HTTPArgument">
+          <elementProp name="product[category_ids][0]" elementType="HTTPArgument">
             <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.name">export_filter[country_of_manufacture]</stringProp>
-            <stringProp name="Argument.value"/>
+            <stringProp name="Argument.value">4</stringProp>
             <stringProp name="Argument.metadata">=</stringProp>
             <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">product[category_ids][0]</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
           </elementProp>
-          <elementProp name="export_filter[created_at]" elementType="HTTPArgument">
+          <elementProp name="product[custom_layout_update]" elementType="HTTPArgument">
             <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.name">export_filter[created_at]</stringProp>
             <stringProp name="Argument.value"/>
             <stringProp name="Argument.metadata">=</stringProp>
             <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">product[custom_layout_update]</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
           </elementProp>
-          <elementProp name="export_filter[custom_design]" elementType="HTTPArgument">
+          <elementProp name="product[description]" elementType="HTTPArgument">
             <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.name">export_filter[custom_design]</stringProp>
             <stringProp name="Argument.value"/>
             <stringProp name="Argument.metadata">=</stringProp>
             <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">product[description]</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
           </elementProp>
-          <elementProp name="export_filter[custom_design_from][]" elementType="HTTPArgument">
+          <elementProp name="product[gift_message_available]" elementType="HTTPArgument">
             <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.name">export_filter[custom_design_from][]</stringProp>
-            <stringProp name="Argument.value">,</stringProp>
+            <stringProp name="Argument.value">0</stringProp>
             <stringProp name="Argument.metadata">=</stringProp>
             <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">product[gift_message_available]</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
           </elementProp>
-          <elementProp name="export_filter[custom_design_to][]" elementType="HTTPArgument">
+          <elementProp name="product[gift_wrapping_available]" elementType="HTTPArgument">
             <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.name">export_filter[custom_design_to][]</stringProp>
-            <stringProp name="Argument.value">,</stringProp>
+            <stringProp name="Argument.value">1</stringProp>
             <stringProp name="Argument.metadata">=</stringProp>
             <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">product[gift_wrapping_available]</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
           </elementProp>
-          <elementProp name="export_filter[custom_layout_update]" elementType="HTTPArgument">
+          <elementProp name="product[gift_wrapping_price]" elementType="HTTPArgument">
             <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.name">export_filter[custom_layout_update]</stringProp>
             <stringProp name="Argument.value"/>
             <stringProp name="Argument.metadata">=</stringProp>
             <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">product[gift_wrapping_price]</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
           </elementProp>
-          <elementProp name="export_filter[description]" elementType="HTTPArgument">
+          <elementProp name="product[image]" elementType="HTTPArgument">
             <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.name">export_filter[description]</stringProp>
             <stringProp name="Argument.value"/>
             <stringProp name="Argument.metadata">=</stringProp>
             <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">product[image]</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
           </elementProp>
-          <elementProp name="export_filter[email_template]" elementType="HTTPArgument">
+          <elementProp name="product[is_returnable]" elementType="HTTPArgument">
             <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.name">export_filter[email_template]</stringProp>
-            <stringProp name="Argument.value"/>
+            <stringProp name="Argument.value">2</stringProp>
             <stringProp name="Argument.metadata">=</stringProp>
             <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">product[is_returnable]</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
           </elementProp>
-          <elementProp name="export_filter[gallery]" elementType="HTTPArgument">
+          <elementProp name="product[meta_description]" elementType="HTTPArgument">
             <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.name">export_filter[gallery]</stringProp>
-            <stringProp name="Argument.value"/>
+            <stringProp name="Argument.value">${configurable_sku} - Meta Description</stringProp>
             <stringProp name="Argument.metadata">=</stringProp>
             <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">product[meta_description]</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
           </elementProp>
-          <elementProp name="export_filter[gift_message_available]" elementType="HTTPArgument">
+          <elementProp name="product[meta_keyword]" elementType="HTTPArgument">
             <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.name">export_filter[gift_message_available]</stringProp>
-            <stringProp name="Argument.value"/>
+            <stringProp name="Argument.value">${configurable_sku} - Meta Keyword</stringProp>
             <stringProp name="Argument.metadata">=</stringProp>
             <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">product[meta_keyword]</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
           </elementProp>
-          <elementProp name="export_filter[gift_wrapping_available]" elementType="HTTPArgument">
+          <elementProp name="product[meta_title]" elementType="HTTPArgument">
             <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.name">export_filter[gift_wrapping_available]</stringProp>
-            <stringProp name="Argument.value"/>
+            <stringProp name="Argument.value">${configurable_sku} - Meta Title</stringProp>
             <stringProp name="Argument.metadata">=</stringProp>
             <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">product[meta_title]</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
           </elementProp>
-          <elementProp name="export_filter[gift_wrapping_price][]" elementType="HTTPArgument">
+          <elementProp name="product[name]" elementType="HTTPArgument">
             <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.name">export_filter[gift_wrapping_price][]</stringProp>
-            <stringProp name="Argument.value">,</stringProp>
+            <stringProp name="Argument.value">${configurable_sku}</stringProp>
             <stringProp name="Argument.metadata">=</stringProp>
             <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">product[name]</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
           </elementProp>
-          <elementProp name="export_filter[group_price][]" elementType="HTTPArgument">
+          <elementProp name="product[options_container]" elementType="HTTPArgument">
             <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.name">export_filter[group_price][]</stringProp>
-            <stringProp name="Argument.value">,</stringProp>
+            <stringProp name="Argument.value">container2</stringProp>
             <stringProp name="Argument.metadata">=</stringProp>
             <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">product[options_container]</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
           </elementProp>
-          <elementProp name="export_filter[has_options]" elementType="HTTPArgument">
+          <elementProp name="product[price]" elementType="HTTPArgument">
             <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.name">export_filter[has_options]</stringProp>
-            <stringProp name="Argument.value"/>
+            <stringProp name="Argument.value">${price_new}</stringProp>
             <stringProp name="Argument.metadata">=</stringProp>
             <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">product[price]</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
           </elementProp>
-          <elementProp name="export_filter[image]" elementType="HTTPArgument">
+          <elementProp name="product[product_has_weight]" elementType="HTTPArgument">
             <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.name">export_filter[image]</stringProp>
-            <stringProp name="Argument.value"/>
+            <stringProp name="Argument.value">1</stringProp>
             <stringProp name="Argument.metadata">=</stringProp>
             <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">product[product_has_weight]</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
           </elementProp>
-          <elementProp name="export_filter[image_label]" elementType="HTTPArgument">
+          <elementProp name="product[quantity_and_stock_status][is_in_stock]" elementType="HTTPArgument">
             <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.name">export_filter[image_label]</stringProp>
-            <stringProp name="Argument.value"/>
+            <stringProp name="Argument.value">1</stringProp>
             <stringProp name="Argument.metadata">=</stringProp>
             <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">product[quantity_and_stock_status][is_in_stock]</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
           </elementProp>
-          <elementProp name="export_filter[is_redeemable][]" elementType="HTTPArgument">
+          <elementProp name="product[quantity_and_stock_status][qty]" elementType="HTTPArgument">
             <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.name">export_filter[is_redeemable][]</stringProp>
-            <stringProp name="Argument.value">,</stringProp>
+            <stringProp name="Argument.value">1000</stringProp>
             <stringProp name="Argument.metadata">=</stringProp>
             <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">product[quantity_and_stock_status][qty]</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
           </elementProp>
-          <elementProp name="export_filter[is_returnable]" elementType="HTTPArgument">
+          <elementProp name="product[short_description]" elementType="HTTPArgument">
             <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.name">export_filter[is_returnable]</stringProp>
             <stringProp name="Argument.value"/>
             <stringProp name="Argument.metadata">=</stringProp>
             <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">product[short_description]</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
           </elementProp>
-          <elementProp name="export_filter[lifetime][]" elementType="HTTPArgument">
+          <elementProp name="product[sku]" elementType="HTTPArgument">
             <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.name">export_filter[lifetime][]</stringProp>
-            <stringProp name="Argument.value">,</stringProp>
+            <stringProp name="Argument.value">${configurable_sku}</stringProp>
             <stringProp name="Argument.metadata">=</stringProp>
             <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">product[sku]</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
           </elementProp>
-          <elementProp name="export_filter[links_exist][]" elementType="HTTPArgument">
+          <elementProp name="product[small_image]" elementType="HTTPArgument">
             <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.name">export_filter[links_exist][]</stringProp>
-            <stringProp name="Argument.value">,</stringProp>
+            <stringProp name="Argument.value"/>
             <stringProp name="Argument.metadata">=</stringProp>
             <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">product[small_image]</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
           </elementProp>
-          <elementProp name="export_filter[links_purchased_separately][]" elementType="HTTPArgument">
+          <elementProp name="product[special_price]" elementType="HTTPArgument">
             <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.name">export_filter[links_purchased_separately][]</stringProp>
-            <stringProp name="Argument.value">,</stringProp>
+            <stringProp name="Argument.value">${special_price_new}</stringProp>
             <stringProp name="Argument.metadata">=</stringProp>
             <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">product[special_price]</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
           </elementProp>
-          <elementProp name="export_filter[links_title]" elementType="HTTPArgument">
+          <elementProp name="product[status]" elementType="HTTPArgument">
             <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.name">export_filter[links_title]</stringProp>
-            <stringProp name="Argument.value"/>
+            <stringProp name="Argument.value">1</stringProp>
             <stringProp name="Argument.metadata">=</stringProp>
             <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">product[status]</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
           </elementProp>
-          <elementProp name="export_filter[media_gallery]" elementType="HTTPArgument">
+          <elementProp name="product[stock_data][backorders]" elementType="HTTPArgument">
             <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.name">export_filter[media_gallery]</stringProp>
-            <stringProp name="Argument.value"/>
+            <stringProp name="Argument.value">0</stringProp>
             <stringProp name="Argument.metadata">=</stringProp>
             <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">product[stock_data][backorders]</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
           </elementProp>
-          <elementProp name="export_filter[meta_description]" elementType="HTTPArgument">
+          <elementProp name="product[stock_data][deferred_stock_update]" elementType="HTTPArgument">
             <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.name">export_filter[meta_description]</stringProp>
-            <stringProp name="Argument.value"/>
+            <stringProp name="Argument.value">1</stringProp>
             <stringProp name="Argument.metadata">=</stringProp>
             <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">product[stock_data][deferred_stock_update]</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
           </elementProp>
-          <elementProp name="export_filter[meta_keyword]" elementType="HTTPArgument">
+          <elementProp name="product[stock_data][enable_qty_increments]" elementType="HTTPArgument">
             <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.name">export_filter[meta_keyword]</stringProp>
-            <stringProp name="Argument.value"/>
+            <stringProp name="Argument.value">0</stringProp>
             <stringProp name="Argument.metadata">=</stringProp>
             <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">product[stock_data][enable_qty_increments]</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
           </elementProp>
-          <elementProp name="export_filter[meta_title]" elementType="HTTPArgument">
+          <elementProp name="product[stock_data][is_decimal_divided]" elementType="HTTPArgument">
             <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.name">export_filter[meta_title]</stringProp>
-            <stringProp name="Argument.value"/>
+            <stringProp name="Argument.value">0</stringProp>
             <stringProp name="Argument.metadata">=</stringProp>
             <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">product[stock_data][is_decimal_divided]</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
           </elementProp>
-          <elementProp name="export_filter[minimal_price][]" elementType="HTTPArgument">
+          <elementProp name="product[stock_data][is_qty_decimal]" elementType="HTTPArgument">
             <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.name">export_filter[minimal_price][]</stringProp>
-            <stringProp name="Argument.value">,</stringProp>
+            <stringProp name="Argument.value">0</stringProp>
             <stringProp name="Argument.metadata">=</stringProp>
             <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">product[stock_data][is_qty_decimal]</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
           </elementProp>
-          <elementProp name="export_filter[msrp][]" elementType="HTTPArgument">
+          <elementProp name="product[stock_data][manage_stock]" elementType="HTTPArgument">
             <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.name">export_filter[msrp][]</stringProp>
-            <stringProp name="Argument.value">,</stringProp>
+            <stringProp name="Argument.value">1</stringProp>
             <stringProp name="Argument.metadata">=</stringProp>
             <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">product[stock_data][manage_stock]</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
           </elementProp>
-          <elementProp name="export_filter[msrp_display_actual_price_type]" elementType="HTTPArgument">
+          <elementProp name="product[stock_data][max_sale_qty]" elementType="HTTPArgument">
             <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.name">export_filter[msrp_display_actual_price_type]</stringProp>
-            <stringProp name="Argument.value"/>
+            <stringProp name="Argument.value">10000</stringProp>
             <stringProp name="Argument.metadata">=</stringProp>
             <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">product[stock_data][max_sale_qty]</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
           </elementProp>
-          <elementProp name="export_filter[name]" elementType="HTTPArgument">
+          <elementProp name="product[stock_data][min_qty]" elementType="HTTPArgument">
             <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.name">export_filter[name]</stringProp>
-            <stringProp name="Argument.value"/>
+            <stringProp name="Argument.value">0</stringProp>
             <stringProp name="Argument.metadata">=</stringProp>
             <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">product[stock_data][min_qty]</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
           </elementProp>
-          <elementProp name="export_filter[news_from_date][]" elementType="HTTPArgument">
+          <elementProp name="product[stock_data][min_sale_qty]" elementType="HTTPArgument">
             <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.name">export_filter[news_from_date][]</stringProp>
-            <stringProp name="Argument.value">,</stringProp>
+            <stringProp name="Argument.value">1</stringProp>
             <stringProp name="Argument.metadata">=</stringProp>
             <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">product[stock_data][min_sale_qty]</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
           </elementProp>
-          <elementProp name="export_filter[news_to_date][]" elementType="HTTPArgument">
+          <elementProp name="product[stock_data][notify_stock_qty]" elementType="HTTPArgument">
             <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.name">export_filter[news_to_date][]</stringProp>
-            <stringProp name="Argument.value">,</stringProp>
+            <stringProp name="Argument.value">1</stringProp>
             <stringProp name="Argument.metadata">=</stringProp>
             <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">product[stock_data][notify_stock_qty]</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
           </elementProp>
-          <elementProp name="export_filter[old_id][]" elementType="HTTPArgument">
+          <elementProp name="product[stock_data][qty_increments]" elementType="HTTPArgument">
             <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.name">export_filter[old_id][]</stringProp>
-            <stringProp name="Argument.value">,</stringProp>
+            <stringProp name="Argument.value">1</stringProp>
             <stringProp name="Argument.metadata">=</stringProp>
             <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">product[stock_data][qty_increments]</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
           </elementProp>
-          <elementProp name="export_filter[open_amount_max][]" elementType="HTTPArgument">
+          <elementProp name="product[stock_data][use_config_backorders]" elementType="HTTPArgument">
             <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.name">export_filter[open_amount_max][]</stringProp>
-            <stringProp name="Argument.value">,</stringProp>
+            <stringProp name="Argument.value">1</stringProp>
             <stringProp name="Argument.metadata">=</stringProp>
             <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">product[stock_data][use_config_backorders]</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
           </elementProp>
-          <elementProp name="export_filter[open_amount_min][]" elementType="HTTPArgument">
+          <elementProp name="product[stock_data][use_config_deferred_stock_update]" elementType="HTTPArgument">
             <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.name">export_filter[open_amount_min][]</stringProp>
-            <stringProp name="Argument.value">,</stringProp>
+            <stringProp name="Argument.value">1</stringProp>
             <stringProp name="Argument.metadata">=</stringProp>
             <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">product[stock_data][use_config_deferred_stock_update]</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
           </elementProp>
-          <elementProp name="export_filter[options_container]" elementType="HTTPArgument">
+          <elementProp name="product[stock_data][use_config_enable_qty_increments]" elementType="HTTPArgument">
             <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.name">export_filter[options_container]</stringProp>
-            <stringProp name="Argument.value"/>
+            <stringProp name="Argument.value">1</stringProp>
             <stringProp name="Argument.metadata">=</stringProp>
             <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">product[stock_data][use_config_enable_qty_increments]</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
           </elementProp>
-          <elementProp name="export_filter[page_layout]" elementType="HTTPArgument">
+          <elementProp name="product[stock_data][use_config_manage_stock]" elementType="HTTPArgument">
             <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.name">export_filter[page_layout]</stringProp>
-            <stringProp name="Argument.value"/>
+            <stringProp name="Argument.value">1</stringProp>
             <stringProp name="Argument.metadata">=</stringProp>
             <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">product[stock_data][use_config_manage_stock]</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
           </elementProp>
-          <elementProp name="export_filter[price][]" elementType="HTTPArgument">
+          <elementProp name="product[stock_data][use_config_max_sale_qty]" elementType="HTTPArgument">
             <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.name">export_filter[price][]</stringProp>
-            <stringProp name="Argument.value">,</stringProp>
+            <stringProp name="Argument.value">1</stringProp>
             <stringProp name="Argument.metadata">=</stringProp>
             <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">product[stock_data][use_config_max_sale_qty]</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
           </elementProp>
-          <elementProp name="export_filter[price_type][]" elementType="HTTPArgument">
+          <elementProp name="product[stock_data][use_config_min_qty]" elementType="HTTPArgument">
             <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.name">export_filter[price_type][]</stringProp>
-            <stringProp name="Argument.value">,</stringProp>
+            <stringProp name="Argument.value">1</stringProp>
             <stringProp name="Argument.metadata">=</stringProp>
             <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">product[stock_data][use_config_min_qty]</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
           </elementProp>
-          <elementProp name="export_filter[price_view]" elementType="HTTPArgument">
+          <elementProp name="product[stock_data][use_config_min_sale_qty]" elementType="HTTPArgument">
             <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.name">export_filter[price_view]</stringProp>
-            <stringProp name="Argument.value"/>
+            <stringProp name="Argument.value">1</stringProp>
             <stringProp name="Argument.metadata">=</stringProp>
             <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">product[stock_data][use_config_min_sale_qty]</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
           </elementProp>
-          <elementProp name="export_filter[quantity_and_stock_status]" elementType="HTTPArgument">
+          <elementProp name="product[stock_data][use_config_notify_stock_qty]" elementType="HTTPArgument">
             <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.name">export_filter[quantity_and_stock_status]</stringProp>
-            <stringProp name="Argument.value"/>
+            <stringProp name="Argument.value">1</stringProp>
             <stringProp name="Argument.metadata">=</stringProp>
             <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">product[stock_data][use_config_notify_stock_qty]</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
           </elementProp>
-          <elementProp name="export_filter[related_tgtr_position_behavior][]" elementType="HTTPArgument">
+          <elementProp name="product[stock_data][use_config_qty_increments]" elementType="HTTPArgument">
             <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.name">export_filter[related_tgtr_position_behavior][]</stringProp>
-            <stringProp name="Argument.value">,</stringProp>
+            <stringProp name="Argument.value">1</stringProp>
             <stringProp name="Argument.metadata">=</stringProp>
             <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">product[stock_data][use_config_qty_increments]</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
           </elementProp>
-          <elementProp name="export_filter[related_tgtr_position_limit][]" elementType="HTTPArgument">
+          <elementProp name="product[tax_class_id]" elementType="HTTPArgument">
             <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.name">export_filter[related_tgtr_position_limit][]</stringProp>
-            <stringProp name="Argument.value">,</stringProp>
+            <stringProp name="Argument.value">2</stringProp>
             <stringProp name="Argument.metadata">=</stringProp>
             <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">product[tax_class_id]</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
           </elementProp>
-          <elementProp name="export_filter[required_options]" elementType="HTTPArgument">
+          <elementProp name="product[thumbnail]" elementType="HTTPArgument">
             <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.name">export_filter[required_options]</stringProp>
             <stringProp name="Argument.value"/>
             <stringProp name="Argument.metadata">=</stringProp>
             <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">product[thumbnail]</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
           </elementProp>
-          <elementProp name="export_filter[samples_title]" elementType="HTTPArgument">
+          <elementProp name="product[url_key]" elementType="HTTPArgument">
             <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.name">export_filter[samples_title]</stringProp>
             <stringProp name="Argument.value"/>
             <stringProp name="Argument.metadata">=</stringProp>
             <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">product[url_key]</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
           </elementProp>
-          <elementProp name="export_filter[shipment_type][]" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.name">export_filter[shipment_type][]</stringProp>
-            <stringProp name="Argument.value">,</stringProp>
-            <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-          </elementProp>
-          <elementProp name="export_filter[short_description]" elementType="HTTPArgument">
+          <elementProp name="product[use_config_gift_message_available]" elementType="HTTPArgument">
             <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.name">export_filter[short_description]</stringProp>
-            <stringProp name="Argument.value"/>
+            <stringProp name="Argument.value">1</stringProp>
             <stringProp name="Argument.metadata">=</stringProp>
             <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">product[use_config_gift_message_available]</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
           </elementProp>
-          <elementProp name="export_filter[sku]" elementType="HTTPArgument">
+          <elementProp name="product[use_config_gift_wrapping_available]" elementType="HTTPArgument">
             <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.name">export_filter[sku]</stringProp>
-            <stringProp name="Argument.value"/>
+            <stringProp name="Argument.value">1</stringProp>
             <stringProp name="Argument.metadata">=</stringProp>
             <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">product[use_config_gift_wrapping_available]</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
           </elementProp>
-          <elementProp name="export_filter[sku_type][]" elementType="HTTPArgument">
+          <elementProp name="product[use_config_is_returnable]" elementType="HTTPArgument">
             <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.name">export_filter[sku_type][]</stringProp>
-            <stringProp name="Argument.value">,</stringProp>
+            <stringProp name="Argument.value">1</stringProp>
             <stringProp name="Argument.metadata">=</stringProp>
             <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">product[use_config_is_returnable]</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
           </elementProp>
-          <elementProp name="export_filter[small_image]" elementType="HTTPArgument">
+          <elementProp name="product[visibility]" elementType="HTTPArgument">
             <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.name">export_filter[small_image]</stringProp>
-            <stringProp name="Argument.value"/>
+            <stringProp name="Argument.value">4</stringProp>
             <stringProp name="Argument.metadata">=</stringProp>
             <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">product[visibility]</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
           </elementProp>
-          <elementProp name="export_filter[small_image_label]" elementType="HTTPArgument">
+          <elementProp name="product[website_ids][1]" elementType="HTTPArgument">
             <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.name">export_filter[small_image_label]</stringProp>
-            <stringProp name="Argument.value"/>
+            <stringProp name="Argument.value">1</stringProp>
             <stringProp name="Argument.metadata">=</stringProp>
             <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">product[website_ids][1]</stringProp>
+            <stringProp name="Argument.desc">true</stringProp>
           </elementProp>
-          <elementProp name="export_filter[special_from_date][]" elementType="HTTPArgument">
+          <elementProp name="links[related][0][id]" elementType="HTTPArgument">
             <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.name">export_filter[special_from_date][]</stringProp>
-            <stringProp name="Argument.value">,</stringProp>
+            <stringProp name="Argument.value">${related_product_id}</stringProp>
             <stringProp name="Argument.metadata">=</stringProp>
             <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">links[related][0][id]</stringProp>
           </elementProp>
-          <elementProp name="export_filter[special_price][]" elementType="HTTPArgument">
+          <elementProp name="links[related][0][position]" elementType="HTTPArgument">
             <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.name">export_filter[special_price][]</stringProp>
-            <stringProp name="Argument.value">,</stringProp>
+            <stringProp name="Argument.value">1</stringProp>
             <stringProp name="Argument.metadata">=</stringProp>
             <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">links[related][0][position]</stringProp>
           </elementProp>
-          <elementProp name="export_filter[special_to_date][]" elementType="HTTPArgument">
+          <elementProp name="links[upsell][0][id]" elementType="HTTPArgument">
             <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.name">export_filter[special_to_date][]</stringProp>
-            <stringProp name="Argument.value">,</stringProp>
+            <stringProp name="Argument.value">${related_product_id}</stringProp>
             <stringProp name="Argument.metadata">=</stringProp>
             <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">links[upsell][0][id]</stringProp>
           </elementProp>
-          <elementProp name="export_filter[status]" elementType="HTTPArgument">
+          <elementProp name="links[upsell][0][position]" elementType="HTTPArgument">
             <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.name">export_filter[status]</stringProp>
-            <stringProp name="Argument.value"/>
+            <stringProp name="Argument.value">1</stringProp>
             <stringProp name="Argument.metadata">=</stringProp>
             <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">links[upsell][0][position]</stringProp>
           </elementProp>
-          <elementProp name="export_filter[tax_class_id]" elementType="HTTPArgument">
+          <elementProp name="links[crosssell][0][id]" elementType="HTTPArgument">
             <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.name">export_filter[tax_class_id]</stringProp>
-            <stringProp name="Argument.value"/>
+            <stringProp name="Argument.value">${related_product_id}</stringProp>
             <stringProp name="Argument.metadata">=</stringProp>
             <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">links[crosssell][0][id]</stringProp>
           </elementProp>
-          <elementProp name="export_filter[thumbnail]" elementType="HTTPArgument">
+          <elementProp name="links[crosssell][0][position]" elementType="HTTPArgument">
             <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.name">export_filter[thumbnail]</stringProp>
-            <stringProp name="Argument.value"/>
+            <stringProp name="Argument.value">1</stringProp>
             <stringProp name="Argument.metadata">=</stringProp>
             <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">links[crosssell][0][position]</stringProp>
           </elementProp>
-          <elementProp name="export_filter[thumbnail_label]" elementType="HTTPArgument">
+        </collectionProp>
+      </elementProp>
+      <stringProp name="HTTPSampler.domain"/>
+      <stringProp name="HTTPSampler.port"/>
+      <stringProp name="HTTPSampler.connect_timeout"/>
+      <stringProp name="HTTPSampler.response_timeout"/>
+      <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
+      <stringProp name="HTTPSampler.contentEncoding"/>
+      <stringProp name="HTTPSampler.path">${base_path}${admin_path}/catalog/product/save/set/${attribute_set_id}/type/configurable/back/edit/active_tab/product-details/</stringProp>
+      <stringProp name="HTTPSampler.method">POST</stringProp>
+      <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
+      <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
+      <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
+      <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
+      <boolProp name="HTTPSampler.monitor">false</boolProp>
+      <stringProp name="HTTPSampler.embedded_url_re"/>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_create_product/configurable_save.jmx</stringProp></HTTPSamplerProxy>
+    <hashTree>
+      <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Response Assertion" enabled="true">
+        <collectionProp name="Asserion.test_strings">
+          <stringProp name="-583471546">You saved the product</stringProp>
+        </collectionProp>
+        <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
+        <boolProp name="Assertion.assume_success">false</boolProp>
+        <intProp name="Assertion.test_type">2</intProp>
+      </ResponseAssertion>
+      <hashTree/>
+      <JSR223Assertion guiclass="TestBeanGUI" testclass="JSR223Assertion" testname="Assert Variation" enabled="true">
+        <stringProp name="scriptLanguage">javascript</stringProp>
+        <stringProp name="parameters"/>
+        <stringProp name="filename"/>
+        <stringProp name="cacheKey"/>
+        <stringProp name="script">
+var configurableVariations = vars.getObject("configurable_variations_assertion"),
+response = SampleResult.getResponseDataAsString();
+
+configurableVariations.forEach(function (variation) {
+    if (response.indexOf(variation) == -1) {
+        AssertionResult.setFailureMessage("Cannot find variation \"" + variation + "\"");
+        AssertionResult.setFailure(true);
+    }
+});
+</stringProp>
+      </JSR223Assertion>
+      <hashTree/>
+    
+        <JSR223PreProcessor guiclass="TestBeanGUI" testclass="JSR223PreProcessor" testname="Prepare Configurable Data" enabled="true">
+            <stringProp name="scriptLanguage">javascript</stringProp>
+            <stringProp name="parameters"/>
+            <stringProp name="filename"/>
+            <stringProp name="cacheKey"/>
+            <stringProp name="script">
+attributes = vars.getObject("product_attributes");
+
+for (i in attributes) {
+    var attribute = attributes[i];
+    sampler.addArgument("attribute_codes[" + i + "]", attribute.code);
+    sampler.addArgument("attributes[" + i + "]", attribute.id);
+    sampler.addArgument("product[" + attribute.code + "]", attribute.options[0].value);
+    addConfigurableAttributeData(attribute);
+}
+
+addConfigurableMatrix(attributes);
+
+function addConfigurableAttributeData(attribute) {
+    var attributeId = attribute.id;
+
+    sampler.addArgument("product[configurable_attributes_data][" + attributeId + "][attribute_id]", attributeId);
+    sampler.addArgument("product[configurable_attributes_data][" + attributeId + "][code]", attribute.code);
+    sampler.addArgument("product[configurable_attributes_data][" + attributeId + "][label]", attribute.label);
+    sampler.addArgument("product[configurable_attributes_data][" + attributeId + "][position]", 0);
+    attribute.options.forEach(function (option, index) {
+        sampler.addArgument("product[configurable_attributes_data][" + attributeId + "][values][" + option.value + "][include]", index);
+        sampler.addArgument("product[configurable_attributes_data][" + attributeId + "][values][" + option.value + "][value_index]", option.value);
+    });
+}
+
+/**
+ * Build 4 simple products for Configurable
+ */
+function addConfigurableMatrix(attributes) {
+
+    var attribute1 = attributes[0],
+        attribute2 = attributes[1],
+        productIndex = 1,
+        products = [];
+    var variationNames = [];
+    attribute1.options.forEach(function (option1) {
+        attribute2.options.forEach(function (option2) {
+            var productAttributes = {},
+                namePart = option1.label + "+" + option2.label,
+                variationKey = option1.value + "-" + option2.value;
+            productAttributes[attribute1.code] = option1.value;
+            productAttributes[attribute2.code] = option2.value;
+
+            variationNames.push(namePart + " - " + vars.get("configurable_sku"));
+            var product = {
+                "id": null,
+                "name": namePart + " - " + vars.get("configurable_sku"),
+                "sku": namePart + " - " + vars.get("configurable_sku"),
+                "status": 1,
+                "price": "100",
+                "price_currency": "$",
+                "price_string": "$100",
+                "weight": "6",
+                "qty": "50",
+                "variationKey": variationKey,
+                "configurable_attribute": JSON.stringify(productAttributes),
+                "thumbnail_image": "",
+                "media_gallery": {"images": {}},
+                "image": [],
+                "was_changed": true,
+                "canEdit": 1,
+                "newProduct": 1,
+                "record_id": productIndex
+            };
+            productIndex++;
+            products.push(product);
+        });
+    });
+
+    sampler.addArgument("configurable-matrix-serialized", JSON.stringify(products));
+    vars.putObject("configurable_variations_assertion", variationNames);
+}
+            </stringProp>
+        <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_create_product/configurable_prepare_data.jmx</stringProp></JSR223PreProcessor>
+        <hashTree/>
+    </hashTree>
+  </hashTree>
+  
+    <TestFragmentController guiclass="TestFragmentControllerGui" testclass="TestFragmentController" testname="Admin Create Downloadable Product" enabled="true">
+  <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_create_product/create_downloadable_product.jmx</stringProp>
+</TestFragmentController>
+    <hashTree>
+      <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Catalog Product" enabled="true">
+        <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
+          <collectionProp name="Arguments.arguments"/>
+        </elementProp>
+        <stringProp name="HTTPSampler.domain"/>
+        <stringProp name="HTTPSampler.port"/>
+        <stringProp name="HTTPSampler.connect_timeout"/>
+        <stringProp name="HTTPSampler.response_timeout"/>
+        <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
+        <stringProp name="HTTPSampler.contentEncoding"/>
+        <stringProp name="HTTPSampler.path">${base_path}${admin_path}/catalog/product/</stringProp>
+        <stringProp name="HTTPSampler.method">GET</stringProp>
+        <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
+        <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
+        <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
+        <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
+        <boolProp name="HTTPSampler.monitor">false</boolProp>
+        <stringProp name="HTTPSampler.embedded_url_re"/>
+      </HTTPSamplerProxy>
+      <hashTree>
+        <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Response Assertion" enabled="true">
+          <collectionProp name="Asserion.test_strings">
+            <stringProp name="1509986340">records found</stringProp>
+          </collectionProp>
+          <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
+          <boolProp name="Assertion.assume_success">false</boolProp>
+          <intProp name="Assertion.test_type">2</intProp>
+        </ResponseAssertion>
+        <hashTree/>
+      </hashTree>
+      <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="New Downloadable Product" enabled="true">
+        <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
+          <collectionProp name="Arguments.arguments"/>
+        </elementProp>
+        <stringProp name="HTTPSampler.domain"/>
+        <stringProp name="HTTPSampler.port"/>
+        <stringProp name="HTTPSampler.connect_timeout"/>
+        <stringProp name="HTTPSampler.response_timeout"/>
+        <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
+        <stringProp name="HTTPSampler.contentEncoding"/>
+        <stringProp name="HTTPSampler.path">${base_path}${admin_path}/catalog/product/new/set/4/type/downloadable/</stringProp>
+        <stringProp name="HTTPSampler.method">GET</stringProp>
+        <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
+        <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
+        <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
+        <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
+        <boolProp name="HTTPSampler.monitor">false</boolProp>
+        <stringProp name="HTTPSampler.embedded_url_re"/>
+      </HTTPSamplerProxy>
+      <hashTree>
+        <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Response Assertion" enabled="true">
+          <collectionProp name="Asserion.test_strings">
+            <stringProp name="-144461265">New Product</stringProp>
+          </collectionProp>
+          <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
+          <boolProp name="Assertion.assume_success">false</boolProp>
+          <intProp name="Assertion.test_type">2</intProp>
+        </ResponseAssertion>
+        <hashTree/>
+      </hashTree>
+      <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="New Downloadable Upload Original File" enabled="true">
+        <elementProp name="HTTPsampler.Files" elementType="HTTPFileArgs">
+          <collectionProp name="HTTPFileArgs.files">
+            <elementProp name="${files_folder}downloadable_original.txt" elementType="HTTPFileArg">
+              <stringProp name="File.path">${files_folder}downloadable_original.txt</stringProp>
+              <stringProp name="File.paramname">links</stringProp>
+              <stringProp name="File.mimetype">text/plain</stringProp>
+            </elementProp>
+          </collectionProp>
+        </elementProp>
+        <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
+          <collectionProp name="Arguments.arguments">
+            <elementProp name="form_key" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">${admin_form_key}</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">form_key</stringProp>
+              <stringProp name="Argument.desc">false</stringProp>
+            </elementProp>
+          </collectionProp>
+        </elementProp>
+        <stringProp name="HTTPSampler.domain"/>
+        <stringProp name="HTTPSampler.port"/>
+        <stringProp name="HTTPSampler.connect_timeout"/>
+        <stringProp name="HTTPSampler.response_timeout"/>
+        <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
+        <stringProp name="HTTPSampler.contentEncoding"/>
+        <stringProp name="HTTPSampler.path">${base_path}${admin_path}/admin/downloadable_file/upload/type/links/?isAjax=true</stringProp>
+        <stringProp name="HTTPSampler.method">POST</stringProp>
+        <boolProp name="HTTPSampler.follow_redirects">false</boolProp>
+        <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
+        <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
+        <boolProp name="HTTPSampler.DO_MULTIPART_POST">true</boolProp>
+        <boolProp name="HTTPSampler.monitor">false</boolProp>
+        <stringProp name="HTTPSampler.embedded_url_re"/>
+      </HTTPSamplerProxy>
+      <hashTree>
+        <com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor guiclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.gui.JSONPathExtractorGui" testclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor" testname="Extract original file" enabled="true">
+          <stringProp name="VAR">original_file</stringProp>
+          <stringProp name="JSONPATH">$.file</stringProp>
+          <stringProp name="DEFAULT"/>
+          <stringProp name="VARIABLE"/>
+          <stringProp name="SUBJECT">BODY</stringProp>
+        </com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor>
+        <hashTree/>
+      </hashTree>
+      <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="New Downloadable Upload Sample File" enabled="true">
+        <elementProp name="HTTPsampler.Files" elementType="HTTPFileArgs">
+          <collectionProp name="HTTPFileArgs.files">
+            <elementProp name="${files_folder}downloadable_sample.txt" elementType="HTTPFileArg">
+              <stringProp name="File.path">${files_folder}downloadable_sample.txt</stringProp>
+              <stringProp name="File.paramname">samples</stringProp>
+              <stringProp name="File.mimetype">text/plain</stringProp>
+            </elementProp>
+          </collectionProp>
+        </elementProp>
+        <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
+          <collectionProp name="Arguments.arguments">
+            <elementProp name="form_key" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">${admin_form_key}</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">form_key</stringProp>
+              <stringProp name="Argument.desc">false</stringProp>
+            </elementProp>
+          </collectionProp>
+        </elementProp>
+        <stringProp name="HTTPSampler.domain"/>
+        <stringProp name="HTTPSampler.port"/>
+        <stringProp name="HTTPSampler.connect_timeout"/>
+        <stringProp name="HTTPSampler.response_timeout"/>
+        <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
+        <stringProp name="HTTPSampler.contentEncoding"/>
+        <stringProp name="HTTPSampler.path">${base_path}${admin_path}/admin/downloadable_file/upload/type/samples/?isAjax=true</stringProp>
+        <stringProp name="HTTPSampler.method">POST</stringProp>
+        <boolProp name="HTTPSampler.follow_redirects">false</boolProp>
+        <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
+        <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
+        <boolProp name="HTTPSampler.DO_MULTIPART_POST">true</boolProp>
+        <boolProp name="HTTPSampler.monitor">false</boolProp>
+        <stringProp name="HTTPSampler.embedded_url_re"/>
+      </HTTPSamplerProxy>
+      <hashTree>
+        <com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor guiclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.gui.JSONPathExtractorGui" testclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor" testname="Extract sample file" enabled="true">
+          <stringProp name="VAR">sample_file</stringProp>
+          <stringProp name="JSONPATH">$.file</stringProp>
+          <stringProp name="DEFAULT"/>
+          <stringProp name="VARIABLE"/>
+          <stringProp name="SUBJECT">BODY</stringProp>
+        </com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor>
+        <hashTree/>
+      </hashTree>
+      <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="New Downloadable Product Validate" enabled="true">
+        <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
+          <collectionProp name="Arguments.arguments">
+            <elementProp name="ajax" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">true</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">ajax</stringProp>
+              <stringProp name="Argument.desc">false</stringProp>
+            </elementProp>
+            <elementProp name="isAjax" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">true</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">isAjax</stringProp>
+              <stringProp name="Argument.desc">false</stringProp>
+            </elementProp>
+            <elementProp name="form_key" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">${admin_form_key}</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">form_key</stringProp>
+              <stringProp name="Argument.desc">false</stringProp>
+            </elementProp>
+            <elementProp name="product[name]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">Downloadable Product ${__time(YMDHMS)}-${__threadNum}-${__Random(1,1000000)}</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[name]</stringProp>
+              <stringProp name="Argument.desc">false</stringProp>
+            </elementProp>
+            <elementProp name="product[sku]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">SKU ${__time(YMDHMS)}-${__threadNum}-${__Random(1,1000000)}</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[sku]</stringProp>
+              <stringProp name="Argument.desc">false</stringProp>
+            </elementProp>
+            <elementProp name="product[price]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">123</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[price]</stringProp>
+            </elementProp>
+            <elementProp name="product[tax_class_id]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">2</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[tax_class_id]</stringProp>
+            </elementProp>
+            <elementProp name="product[quantity_and_stock_status][qty]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">111</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[quantity_and_stock_status][qty]</stringProp>
+            </elementProp>
+            <elementProp name="product[quantity_and_stock_status][is_in_stock]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">1</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[quantity_and_stock_status][is_in_stock]</stringProp>
+            </elementProp>
+            <elementProp name="product[weight]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">1.0000</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[weight]</stringProp>
+            </elementProp>
+            <elementProp name="product[category_ids][]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">2</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[category_ids][]</stringProp>
+            </elementProp>
+            <elementProp name="product[description]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">&lt;p&gt;Full downloadable product description ${__time(YMDHMS)}-${__threadNum}-${__Random(1,1000000)}&lt;/p&gt;</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[description]</stringProp>
+            </elementProp>
+            <elementProp name="product[short_description]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">&lt;p&gt;Short downloadable product description ${__time(YMDHMS)}-${__threadNum}-${__Random(1,1000000)}&lt;/p&gt;</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[short_description]</stringProp>
+            </elementProp>
+            <elementProp name="product[status]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">1</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[status]</stringProp>
+            </elementProp>
+            <elementProp name="product[image]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value"/>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[image]</stringProp>
+            </elementProp>
+            <elementProp name="product[small_image]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value"/>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[small_image]</stringProp>
+            </elementProp>
+            <elementProp name="product[thumbnail]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value"/>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[thumbnail]</stringProp>
+            </elementProp>
+            <elementProp name="product[url_key]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">downloadable-product-${__time(YMDHMS)}-${__threadNum}-${__Random(1,1000000)}</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[url_key]</stringProp>
+            </elementProp>
+            <elementProp name="product[meta_title]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">Downloadable Product ${__time(YMDHMS)}-${__threadNum}-${__Random(1,1000000)} Meta Title</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[meta_title]</stringProp>
+            </elementProp>
+            <elementProp name="product[meta_keyword]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">Downloadable Product ${__time(YMDHMS)}-${__threadNum}-${__Random(1,1000000)} Meta Keyword</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[meta_keyword]</stringProp>
+            </elementProp>
+            <elementProp name="product[meta_description]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">Downloadable Product ${__time(YMDHMS)}-${__threadNum}-${__Random(1,1000000)} Meta Description</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[meta_description]</stringProp>
+            </elementProp>
+            <elementProp name="product[website_ids][]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">1</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[website_ids][]</stringProp>
+            </elementProp>
+            <elementProp name="product[special_price]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">99</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[special_price]</stringProp>
+            </elementProp>
+            <elementProp name="product[stock_data][notify_stock_qty]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">1</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[stock_data][notify_stock_qty]</stringProp>
+            </elementProp>
+            <elementProp name="product[special_from_date]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value"/>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[special_from_date]</stringProp>
+            </elementProp>
+            <elementProp name="product[special_to_date]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value"/>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[special_to_date]</stringProp>
+            </elementProp>
+            <elementProp name="product[cost]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value"/>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[cost]</stringProp>
+            </elementProp>
+            <elementProp name="product[tier_price][0][website_id]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">0</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[tier_price][0][website_id]</stringProp>
+            </elementProp>
+            <elementProp name="product[tier_price][0][cust_group]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">32000</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[tier_price][0][cust_group]</stringProp>
+            </elementProp>
+            <elementProp name="product[tier_price][0][price_qty]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">100</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[tier_price][0][price_qty]</stringProp>
+            </elementProp>
+            <elementProp name="product[tier_price][0][price]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">90</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[tier_price][0][price]</stringProp>
+            </elementProp>
+            <elementProp name="product[tier_price][0][delete]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value"/>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[tier_price][0][delete]</stringProp>
+            </elementProp>
+            <elementProp name="product[tier_price][1][website_id]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">0</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[tier_price][1][website_id]</stringProp>
+            </elementProp>
+            <elementProp name="product[tier_price][1][cust_group]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">1</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[tier_price][1][cust_group]</stringProp>
+            </elementProp>
+            <elementProp name="product[tier_price][1][price_qty]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">101</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[tier_price][1][price_qty]</stringProp>
+            </elementProp>
+            <elementProp name="product[tier_price][1][price]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">99</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[tier_price][1][price]</stringProp>
+            </elementProp>
+            <elementProp name="product[tier_price][1][delete]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value"/>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[tier_price][1][delete]</stringProp>
+            </elementProp>
+            <elementProp name="product[stock_data][use_config_manage_stock]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">1</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[stock_data][use_config_manage_stock]</stringProp>
+            </elementProp>
+            <elementProp name="product[stock_data][original_inventory_qty]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">100500</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[stock_data][original_inventory_qty]</stringProp>
+            </elementProp>
+            <elementProp name="product[stock_data][qty]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">100500</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[stock_data][qty]</stringProp>
+            </elementProp>
+            <elementProp name="product[stock_data][min_qty]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">0</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[stock_data][min_qty]</stringProp>
+            </elementProp>
+            <elementProp name="product[stock_data][use_config_min_qty]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">1</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[stock_data][use_config_min_qty]</stringProp>
+            </elementProp>
+            <elementProp name="product[stock_data][min_sale_qty]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">1</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[stock_data][min_sale_qty]</stringProp>
+            </elementProp>
+            <elementProp name="product[stock_data][use_config_min_sale_qty]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">1</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[stock_data][use_config_min_sale_qty]</stringProp>
+            </elementProp>
+            <elementProp name="product[stock_data][max_sale_qty]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">10000</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[stock_data][max_sale_qty]</stringProp>
+            </elementProp>
+            <elementProp name="product[stock_data][use_config_max_sale_qty]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">1</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[stock_data][use_config_max_sale_qty]</stringProp>
+            </elementProp>
+            <elementProp name="product[stock_data][is_qty_decimal]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">0</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[stock_data][is_qty_decimal]</stringProp>
+            </elementProp>
+            <elementProp name="product[stock_data][is_decimal_divided]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">0</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[stock_data][is_decimal_divided]</stringProp>
+            </elementProp>
+            <elementProp name="product[stock_data][backorders]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">0</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[stock_data][backorders]</stringProp>
+            </elementProp>
+            <elementProp name="product[stock_data][use_config_backorders]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">1</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[stock_data][use_config_backorders]</stringProp>
+            </elementProp>
+            <elementProp name="product[stock_data][use_config_notify_stock_qty]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">1</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[stock_data][use_config_notify_stock_qty]</stringProp>
+            </elementProp>
+            <elementProp name="product[stock_data][enable_qty_increments]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">0</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[stock_data][enable_qty_increments]</stringProp>
+            </elementProp>
+            <elementProp name="product[stock_data][qty_increments]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">0</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[stock_data][qty_increments]</stringProp>
+            </elementProp>
+            <elementProp name="product[stock_data][use_config_qty_increments]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">1</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[stock_data][use_config_qty_increments]</stringProp>
+            </elementProp>
+            <elementProp name="product[stock_data][is_in_stock]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">1</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[stock_data][is_in_stock]</stringProp>
+            </elementProp>
+            <elementProp name="product[custom_design]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value"/>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[custom_design]</stringProp>
+            </elementProp>
+            <elementProp name="product[custom_design_from]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value"/>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[custom_design_from]</stringProp>
+            </elementProp>
+            <elementProp name="product[custom_design_to]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value"/>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[custom_design_to]</stringProp>
+            </elementProp>
+            <elementProp name="product[custom_layout_update]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value"/>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[custom_layout_update]</stringProp>
+            </elementProp>
+            <elementProp name="product[page_layout]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value"/>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[page_layout]</stringProp>
+            </elementProp>
+            <elementProp name="product[options_container]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">container2</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[options_container]</stringProp>
+            </elementProp>
+            <elementProp name="is_downloadable" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">on</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">is_downloadable</stringProp>
+            </elementProp>
+            <elementProp name="product[links_title]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">Links</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[links_title]</stringProp>
+            </elementProp>
+            <elementProp name="product[links_purchased_separately]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">0</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[links_purchased_separately]</stringProp>
+            </elementProp>
+            <elementProp name="downloadable[link][0][file][0][file]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">${original_file}</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">downloadable[link][0][file][0][file]</stringProp>
+              <stringProp name="Argument.desc">false</stringProp>
+            </elementProp>
+            <elementProp name="downloadable[link][0][file][0][name]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">downloadable_original.txt</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">downloadable[link][0][file][0][name]</stringProp>
+              <stringProp name="Argument.desc">false</stringProp>
+            </elementProp>
+            <elementProp name="downloadable[link][0][file][0][size]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">13</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">downloadable[link][0][file][0][size]</stringProp>
+              <stringProp name="Argument.desc">false</stringProp>
+            </elementProp>
+            <elementProp name="downloadable[link][0][file][0][status]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">new</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">downloadable[link][0][file][0][status]</stringProp>
+              <stringProp name="Argument.desc">false</stringProp>
+            </elementProp>
+            <elementProp name="downloadable[link][0][is_shareable]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">1</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">downloadable[link][0][is_shareable]</stringProp>
+            </elementProp>
+            <elementProp name="downloadable[link][0][is_unlimited]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">0</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">downloadable[link][0][is_unlimited]</stringProp>
+            </elementProp>
+            <elementProp name="downloadable[link][0][link_url]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value"/>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">downloadable[link][0][link_url]</stringProp>
+            </elementProp>
+            <elementProp name="downloadable[link][0][number_of_downloads]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">0</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">downloadable[link][0][number_of_downloads]</stringProp>
+              <stringProp name="Argument.desc">true</stringProp>
+            </elementProp>
+            <elementProp name="downloadable[link][0][price]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">120</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">downloadable[link][0][price]</stringProp>
+              <stringProp name="Argument.desc">true</stringProp>
+            </elementProp>
+            <elementProp name="downloadable[link][0][record_id]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">0</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">downloadable[link][0][record_id]</stringProp>
+              <stringProp name="Argument.desc">true</stringProp>
+            </elementProp>
+            <elementProp name="downloadable[link][0][sample][type]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">file</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">downloadable[link][0][sample][type]</stringProp>
+            </elementProp>
+            <elementProp name="downloadable[link][0][sample][url]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value"/>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">downloadable[link][0][sample][url]</stringProp>
+            </elementProp>
+            <elementProp name="downloadable[link][0][sort_order]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">1</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">downloadable[link][0][sort_order]</stringProp>
+            </elementProp>
+            <elementProp name="downloadable[link][0][title]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">Original Link</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">downloadable[link][0][title]</stringProp>
+            </elementProp>
+            <elementProp name="downloadable[link][0][type]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">file</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">downloadable[link][0][type]</stringProp>
+            </elementProp>
+            <elementProp name="downloadable[sample][0][file][0][file]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">${sample_file}</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">downloadable[sample][0][file][0][file]</stringProp>
+              <stringProp name="Argument.desc">true</stringProp>
+            </elementProp>
+            <elementProp name="downloadable[sample][0][file][0][name]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">downloadable_sample.txt</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">downloadable[sample][0][file][0][name]</stringProp>
+              <stringProp name="Argument.desc">true</stringProp>
+            </elementProp>
+            <elementProp name="downloadable[sample][0][file][0][size]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">14</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">downloadable[sample][0][file][0][size]</stringProp>
+              <stringProp name="Argument.desc">true</stringProp>
+            </elementProp>
+            <elementProp name="downloadable[sample][0][file][0][status]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">new</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">downloadable[sample][0][file][0][status]</stringProp>
+              <stringProp name="Argument.desc">true</stringProp>
+            </elementProp>
+            <elementProp name="downloadable[sample][0][record_id]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">0</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">downloadable[sample][0][record_id]</stringProp>
+              <stringProp name="Argument.desc">true</stringProp>
+            </elementProp>
+            <elementProp name="downloadable[sample][0][sample_url]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value"/>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">downloadable[sample][0][sample_url]</stringProp>
+              <stringProp name="Argument.desc">true</stringProp>
+            </elementProp>
+            <elementProp name="downloadable[sample][0][sort_order]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">1</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">downloadable[sample][0][sort_order]</stringProp>
+              <stringProp name="Argument.desc">true</stringProp>
+            </elementProp>
+            <elementProp name="downloadable[sample][0][title]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">Sample Link</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">downloadable[sample][0][title]</stringProp>
+              <stringProp name="Argument.desc">true</stringProp>
+            </elementProp>
+            <elementProp name="downloadable[sample][0][type]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">file</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">downloadable[sample][0][type]</stringProp>
+              <stringProp name="Argument.desc">true</stringProp>
+            </elementProp>
+            <elementProp name="affect_configurable_product_attributes" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">1</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">affect_configurable_product_attributes</stringProp>
+              <stringProp name="Argument.desc">false</stringProp>
+            </elementProp>
+            <elementProp name="new-variations-attribute-set-id" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">4</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">new-variations-attribute-set-id</stringProp>
+              <stringProp name="Argument.desc">false</stringProp>
+            </elementProp>
+            <elementProp name="product[configurable_variation]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value"/>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[configurable_variation]</stringProp>
+              <stringProp name="Argument.desc">false</stringProp>
+            </elementProp>
+            <elementProp name="links[related][0][id]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">${related_product_id}</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">links[related][0][id]</stringProp>
+            </elementProp>
+            <elementProp name="links[related][0][position]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">1</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">links[related][0][position]</stringProp>
+            </elementProp>
+            <elementProp name="links[upsell][0][id]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">${related_product_id}</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">links[upsell][0][id]</stringProp>
+            </elementProp>
+            <elementProp name="links[upsell][0][position]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">1</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">links[upsell][0][position]</stringProp>
+            </elementProp>
+            <elementProp name="links[crosssell][0][id]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">${related_product_id}</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">links[crosssell][0][id]</stringProp>
+            </elementProp>
+            <elementProp name="links[crosssell][0][position]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">1</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">links[crosssell][0][position]</stringProp>
+            </elementProp>
+          </collectionProp>
+        </elementProp>
+        <stringProp name="HTTPSampler.domain"/>
+        <stringProp name="HTTPSampler.port"/>
+        <stringProp name="HTTPSampler.connect_timeout"/>
+        <stringProp name="HTTPSampler.response_timeout"/>
+        <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
+        <stringProp name="HTTPSampler.contentEncoding"/>
+        <stringProp name="HTTPSampler.path">${base_path}${admin_path}/catalog/product/validate/set/4/type/downloadable/</stringProp>
+        <stringProp name="HTTPSampler.method">POST</stringProp>
+        <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
+        <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
+        <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
+        <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
+        <boolProp name="HTTPSampler.monitor">false</boolProp>
+        <stringProp name="HTTPSampler.embedded_url_re"/>
+      </HTTPSamplerProxy>
+      <hashTree>
+        <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Response Assertion" enabled="true">
+          <collectionProp name="Asserion.test_strings">
+            <stringProp name="1853918323">{"error":false}</stringProp>
+          </collectionProp>
+          <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
+          <boolProp name="Assertion.assume_success">false</boolProp>
+          <intProp name="Assertion.test_type">2</intProp>
+        </ResponseAssertion>
+        <hashTree/>
+      </hashTree>
+      <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="New Downloadable Product Save" enabled="true">
+        <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
+          <collectionProp name="Arguments.arguments">
+            <elementProp name="ajax" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">true</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">ajax</stringProp>
+              <stringProp name="Argument.desc">false</stringProp>
+            </elementProp>
+            <elementProp name="isAjax" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">true</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">isAjax</stringProp>
+              <stringProp name="Argument.desc">false</stringProp>
+            </elementProp>
+            <elementProp name="form_key" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">${admin_form_key}</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">form_key</stringProp>
+              <stringProp name="Argument.desc">false</stringProp>
+            </elementProp>
+            <elementProp name="product[name]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">Downloadable Product ${__time(YMDHMS)}-${__threadNum}-${__Random(1,1000000)}</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[name]</stringProp>
+              <stringProp name="Argument.desc">false</stringProp>
+            </elementProp>
+            <elementProp name="product[sku]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">SKU ${__time(YMDHMS)}-${__threadNum}-${__Random(1,1000000)}</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[sku]</stringProp>
+              <stringProp name="Argument.desc">false</stringProp>
+            </elementProp>
+            <elementProp name="product[price]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">123</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[price]</stringProp>
+            </elementProp>
+            <elementProp name="product[tax_class_id]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">2</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[tax_class_id]</stringProp>
+            </elementProp>
+            <elementProp name="product[quantity_and_stock_status][qty]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">111</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[quantity_and_stock_status][qty]</stringProp>
+            </elementProp>
+            <elementProp name="product[quantity_and_stock_status][is_in_stock]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">1</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[quantity_and_stock_status][is_in_stock]</stringProp>
+            </elementProp>
+            <elementProp name="product[weight]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">1.0000</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[weight]</stringProp>
+            </elementProp>
+            <elementProp name="product[category_ids][]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">2</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[category_ids][]</stringProp>
+            </elementProp>
+            <elementProp name="product[description]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">&lt;p&gt;Full downloadable product description ${__time(YMDHMS)}-${__threadNum}-${__Random(1,1000000)}&lt;/p&gt;</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[description]</stringProp>
+            </elementProp>
+            <elementProp name="product[short_description]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">&lt;p&gt;Short downloadable product description ${__time(YMDHMS)}-${__threadNum}-${__Random(1,1000000)}&lt;/p&gt;</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[short_description]</stringProp>
+              <stringProp name="Argument.desc">false</stringProp>
+            </elementProp>
+            <elementProp name="product[status]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">1</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[status]</stringProp>
+            </elementProp>
+            <elementProp name="product[image]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value"/>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[image]</stringProp>
+            </elementProp>
+            <elementProp name="product[small_image]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value"/>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[small_image]</stringProp>
+            </elementProp>
+            <elementProp name="product[thumbnail]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value"/>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[thumbnail]</stringProp>
+            </elementProp>
+            <elementProp name="product[url_key]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">downloadable-product-${__time(YMDHMS)}-${__threadNum}-${__Random(1,1000000)}</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[url_key]</stringProp>
+            </elementProp>
+            <elementProp name="product[meta_title]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">Downloadable Product ${__time(YMDHMS)}-${__threadNum}-${__Random(1,1000000)} Meta Title</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[meta_title]</stringProp>
+            </elementProp>
+            <elementProp name="product[meta_keyword]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">Downloadable Product ${__time(YMDHMS)}-${__threadNum}-${__Random(1,1000000)} Meta Keyword</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[meta_keyword]</stringProp>
+            </elementProp>
+            <elementProp name="product[meta_description]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">Downloadable Product ${__time(YMDHMS)}-${__threadNum}-${__Random(1,1000000)} Meta Description</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[meta_description]</stringProp>
+            </elementProp>
+            <elementProp name="product[website_ids][]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">1</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[website_ids][]</stringProp>
+            </elementProp>
+            <elementProp name="product[special_price]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">99</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[special_price]</stringProp>
+            </elementProp>
+            <elementProp name="product[special_from_date]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value"/>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[special_from_date]</stringProp>
+            </elementProp>
+            <elementProp name="product[special_to_date]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value"/>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[special_to_date]</stringProp>
+            </elementProp>
+            <elementProp name="product[cost]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value"/>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[cost]</stringProp>
+            </elementProp>
+            <elementProp name="product[tier_price][0][website_id]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">0</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[tier_price][0][website_id]</stringProp>
+            </elementProp>
+            <elementProp name="product[tier_price][0][cust_group]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">32000</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[tier_price][0][cust_group]</stringProp>
+            </elementProp>
+            <elementProp name="product[tier_price][0][price_qty]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">100</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[tier_price][0][price_qty]</stringProp>
+            </elementProp>
+            <elementProp name="product[tier_price][0][price]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">90</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[tier_price][0][price]</stringProp>
+            </elementProp>
+            <elementProp name="product[tier_price][0][delete]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value"/>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[tier_price][0][delete]</stringProp>
+            </elementProp>
+            <elementProp name="product[tier_price][1][website_id]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">0</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[tier_price][1][website_id]</stringProp>
+            </elementProp>
+            <elementProp name="product[tier_price][1][cust_group]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">1</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[tier_price][1][cust_group]</stringProp>
+            </elementProp>
+            <elementProp name="product[tier_price][1][price_qty]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">101</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[tier_price][1][price_qty]</stringProp>
+            </elementProp>
+            <elementProp name="product[tier_price][1][price]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">99</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[tier_price][1][price]</stringProp>
+            </elementProp>
+            <elementProp name="product[tier_price][1][delete]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value"/>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[tier_price][1][delete]</stringProp>
+            </elementProp>
+            <elementProp name="product[stock_data][use_config_manage_stock]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">1</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[stock_data][use_config_manage_stock]</stringProp>
+            </elementProp>
+            <elementProp name="product[stock_data][original_inventory_qty]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">100500</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[stock_data][original_inventory_qty]</stringProp>
+            </elementProp>
+            <elementProp name="product[stock_data][qty]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">100500</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[stock_data][qty]</stringProp>
+            </elementProp>
+            <elementProp name="product[stock_data][min_qty]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">0</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[stock_data][min_qty]</stringProp>
+            </elementProp>
+            <elementProp name="product[stock_data][use_config_min_qty]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">1</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[stock_data][use_config_min_qty]</stringProp>
+            </elementProp>
+            <elementProp name="product[stock_data][min_sale_qty]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">1</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[stock_data][min_sale_qty]</stringProp>
+            </elementProp>
+            <elementProp name="product[stock_data][use_config_min_sale_qty]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">1</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[stock_data][use_config_min_sale_qty]</stringProp>
+            </elementProp>
+            <elementProp name="product[stock_data][max_sale_qty]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">10000</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[stock_data][max_sale_qty]</stringProp>
+            </elementProp>
+            <elementProp name="product[stock_data][use_config_max_sale_qty]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">1</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[stock_data][use_config_max_sale_qty]</stringProp>
+            </elementProp>
+            <elementProp name="product[stock_data][is_qty_decimal]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">0</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[stock_data][is_qty_decimal]</stringProp>
+            </elementProp>
+            <elementProp name="product[stock_data][is_decimal_divided]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">0</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[stock_data][is_decimal_divided]</stringProp>
+            </elementProp>
+            <elementProp name="product[stock_data][backorders]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">0</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[stock_data][backorders]</stringProp>
+            </elementProp>
+            <elementProp name="product[stock_data][use_config_backorders]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">1</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[stock_data][use_config_backorders]</stringProp>
+            </elementProp>
+            <elementProp name="product[stock_data][notify_stock_qty]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">1</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[stock_data][notify_stock_qty]</stringProp>
+            </elementProp>
+            <elementProp name="product[stock_data][use_config_notify_stock_qty]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">1</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[stock_data][use_config_notify_stock_qty]</stringProp>
+            </elementProp>
+            <elementProp name="product[stock_data][enable_qty_increments]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">0</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[stock_data][enable_qty_increments]</stringProp>
+            </elementProp>
+            <elementProp name="product[stock_data][qty_increments]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">0</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[stock_data][qty_increments]</stringProp>
+            </elementProp>
+            <elementProp name="product[stock_data][use_config_qty_increments]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">1</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[stock_data][use_config_qty_increments]</stringProp>
+            </elementProp>
+            <elementProp name="product[stock_data][is_in_stock]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">1</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[stock_data][is_in_stock]</stringProp>
+            </elementProp>
+            <elementProp name="product[custom_design]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value"/>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[custom_design]</stringProp>
+            </elementProp>
+            <elementProp name="product[custom_design_from]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value"/>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[custom_design_from]</stringProp>
+            </elementProp>
+            <elementProp name="product[custom_design_to]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value"/>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[custom_design_to]</stringProp>
+            </elementProp>
+            <elementProp name="product[custom_layout_update]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value"/>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[custom_layout_update]</stringProp>
+            </elementProp>
+            <elementProp name="product[page_layout]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value"/>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[page_layout]</stringProp>
+            </elementProp>
+            <elementProp name="product[options_container]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">container2</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[options_container]</stringProp>
+            </elementProp>
+            <elementProp name="downloadable[link][0][file][0][file]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">${original_file}</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">downloadable[link][0][file][0][file]</stringProp>
+              <stringProp name="Argument.desc">false</stringProp>
+            </elementProp>
+            <elementProp name="downloadable[link][0][file][0][name]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">downloadable_original.txt</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">downloadable[link][0][file][0][name]</stringProp>
+              <stringProp name="Argument.desc">false</stringProp>
+            </elementProp>
+            <elementProp name="downloadable[link][0][file][0][size]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">13</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">downloadable[link][0][file][0][size]</stringProp>
+              <stringProp name="Argument.desc">false</stringProp>
+            </elementProp>
+            <elementProp name="downloadable[link][0][file][0][status]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">new</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">downloadable[link][0][file][0][status]</stringProp>
+              <stringProp name="Argument.desc">false</stringProp>
+            </elementProp>
+            <elementProp name="downloadable[link][0][is_shareable]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">1</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">downloadable[link][0][is_shareable]</stringProp>
+              <stringProp name="Argument.desc">true</stringProp>
+            </elementProp>
+            <elementProp name="downloadable[link][0][is_unlimited]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">0</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">downloadable[link][0][is_unlimited]</stringProp>
+              <stringProp name="Argument.desc">true</stringProp>
+            </elementProp>
+            <elementProp name="downloadable[link][0][link_url]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value"/>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">downloadable[link][0][link_url]</stringProp>
+              <stringProp name="Argument.desc">true</stringProp>
+            </elementProp>
+            <elementProp name="downloadable[link][0][number_of_downloads]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">0</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">downloadable[link][0][number_of_downloads]</stringProp>
+              <stringProp name="Argument.desc">false</stringProp>
+            </elementProp>
+            <elementProp name="downloadable[link][0][price]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">120</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">downloadable[link][0][price]</stringProp>
+              <stringProp name="Argument.desc">false</stringProp>
+            </elementProp>
+            <elementProp name="downloadable[link][0][record_id]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">0</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">downloadable[link][0][record_id]</stringProp>
+              <stringProp name="Argument.desc">false</stringProp>
+            </elementProp>
+            <elementProp name="downloadable[link][0][sample][type]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">file</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">downloadable[link][0][sample][type]</stringProp>
+              <stringProp name="Argument.desc">true</stringProp>
+            </elementProp>
+            <elementProp name="downloadable[link][0][sample][url]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value"/>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">downloadable[link][0][sample][url]</stringProp>
+              <stringProp name="Argument.desc">true</stringProp>
+            </elementProp>
+            <elementProp name="downloadable[link][0][sort_order]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">1</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">downloadable[link][0][sort_order]</stringProp>
+              <stringProp name="Argument.desc">true</stringProp>
+            </elementProp>
+            <elementProp name="downloadable[link][0][title]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">Original Link</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">downloadable[link][0][title]</stringProp>
+              <stringProp name="Argument.desc">true</stringProp>
+            </elementProp>
+            <elementProp name="downloadable[link][0][type]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">file</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">downloadable[link][0][type]</stringProp>
+              <stringProp name="Argument.desc">true</stringProp>
+            </elementProp>
+            <elementProp name="downloadable[sample][0][file][0][file]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">${sample_file}</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">downloadable[sample][0][file][0][file]</stringProp>
+              <stringProp name="Argument.desc">true</stringProp>
+            </elementProp>
+            <elementProp name="downloadable[sample][0][file][0][name]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">downloadable_sample.txt</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">downloadable[sample][0][file][0][name]</stringProp>
+              <stringProp name="Argument.desc">true</stringProp>
+            </elementProp>
+            <elementProp name="downloadable[sample][0][file][0][size]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">14</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">downloadable[sample][0][file][0][size]</stringProp>
+              <stringProp name="Argument.desc">true</stringProp>
+            </elementProp>
+            <elementProp name="downloadable[sample][0][file][0][status]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">new</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">downloadable[sample][0][file][0][status]</stringProp>
+              <stringProp name="Argument.desc">true</stringProp>
+            </elementProp>
+            <elementProp name="downloadable[sample][0][record_id]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">0</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">downloadable[sample][0][record_id]</stringProp>
+              <stringProp name="Argument.desc">true</stringProp>
+            </elementProp>
+            <elementProp name="downloadable[sample][0][sample_url]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value"/>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">downloadable[sample][0][sample_url]</stringProp>
+              <stringProp name="Argument.desc">true</stringProp>
+            </elementProp>
+            <elementProp name="downloadable[sample][0][sort_order]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">1</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">downloadable[sample][0][sort_order]</stringProp>
+              <stringProp name="Argument.desc">true</stringProp>
+            </elementProp>
+            <elementProp name="downloadable[sample][0][title]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">Sample Link</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">downloadable[sample][0][title]</stringProp>
+              <stringProp name="Argument.desc">true</stringProp>
+            </elementProp>
+            <elementProp name="downloadable[sample][0][type]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">file</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">downloadable[sample][0][type]</stringProp>
+              <stringProp name="Argument.desc">true</stringProp>
+            </elementProp>
+            <elementProp name="affect_configurable_product_attributes" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">1</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">affect_configurable_product_attributes</stringProp>
+              <stringProp name="Argument.desc">false</stringProp>
+            </elementProp>
+            <elementProp name="new-variations-attribute-set-id" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">4</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">new-variations-attribute-set-id</stringProp>
+              <stringProp name="Argument.desc">false</stringProp>
+            </elementProp>
+            <elementProp name="product[configurable_variation]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value"/>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[configurable_variation]</stringProp>
+              <stringProp name="Argument.desc">false</stringProp>
+            </elementProp>
+            <elementProp name="links[related][0][id]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">${related_product_id}</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">links[related][0][id]</stringProp>
+            </elementProp>
+            <elementProp name="links[related][0][position]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">1</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">links[related][0][position]</stringProp>
+            </elementProp>
+            <elementProp name="links[upsell][0][id]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">${related_product_id}</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">links[upsell][0][id]</stringProp>
+            </elementProp>
+            <elementProp name="links[upsell][0][position]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">1</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">links[upsell][0][position]</stringProp>
+            </elementProp>
+            <elementProp name="links[crosssell][0][id]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">${related_product_id}</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">links[crosssell][0][id]</stringProp>
+            </elementProp>
+            <elementProp name="links[crosssell][0][position]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">1</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">links[crosssell][0][position]</stringProp>
+            </elementProp>
+          </collectionProp>
+        </elementProp>
+        <stringProp name="HTTPSampler.domain"/>
+        <stringProp name="HTTPSampler.port"/>
+        <stringProp name="HTTPSampler.connect_timeout"/>
+        <stringProp name="HTTPSampler.response_timeout"/>
+        <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
+        <stringProp name="HTTPSampler.contentEncoding"/>
+        <stringProp name="HTTPSampler.path">${base_path}${admin_path}/catalog/product/save/set/4/type/downloadable/back/edit/active_tab/product-details/</stringProp>
+        <stringProp name="HTTPSampler.method">POST</stringProp>
+        <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
+        <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
+        <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
+        <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
+        <boolProp name="HTTPSampler.monitor">false</boolProp>
+        <stringProp name="HTTPSampler.embedded_url_re"/>
+      </HTTPSamplerProxy>
+      <hashTree>
+        <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Response Assertion" enabled="true">
+          <collectionProp name="Asserion.test_strings">
+            <stringProp name="-583471546">You saved the product</stringProp>
+          </collectionProp>
+          <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
+          <boolProp name="Assertion.assume_success">false</boolProp>
+          <intProp name="Assertion.test_type">2</intProp>
+        </ResponseAssertion>
+        <hashTree/>
+        <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Response Assertion" enabled="true">
+          <collectionProp name="Asserion.test_strings">
+            <stringProp name="-1600986843">violation</stringProp>
+          </collectionProp>
+          <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
+          <boolProp name="Assertion.assume_success">false</boolProp>
+          <intProp name="Assertion.test_type">6</intProp>
+        </ResponseAssertion>
+        <hashTree/>
+      </hashTree>
+    </hashTree>
+  
+    <TestFragmentController guiclass="TestFragmentControllerGui" testclass="TestFragmentController" testname="Admin Create Simple Product" enabled="true">
+  <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_create_product/create_simple_product.jmx</stringProp>
+</TestFragmentController>
+    <hashTree>
+      <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Catalog Product" enabled="true">
+        <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
+          <collectionProp name="Arguments.arguments"/>
+        </elementProp>
+        <stringProp name="HTTPSampler.domain"/>
+        <stringProp name="HTTPSampler.port"/>
+        <stringProp name="HTTPSampler.connect_timeout"/>
+        <stringProp name="HTTPSampler.response_timeout"/>
+        <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
+        <stringProp name="HTTPSampler.contentEncoding"/>
+        <stringProp name="HTTPSampler.path">${base_path}${admin_path}/catalog/product/</stringProp>
+        <stringProp name="HTTPSampler.method">GET</stringProp>
+        <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
+        <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
+        <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
+        <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
+        <boolProp name="HTTPSampler.monitor">false</boolProp>
+        <stringProp name="HTTPSampler.embedded_url_re"/>
+      </HTTPSamplerProxy>
+      <hashTree>
+        <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Response Assertion" enabled="true">
+          <collectionProp name="Asserion.test_strings">
+            <stringProp name="1509986340">records found</stringProp>
+          </collectionProp>
+          <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
+          <boolProp name="Assertion.assume_success">false</boolProp>
+          <intProp name="Assertion.test_type">2</intProp>
+        </ResponseAssertion>
+        <hashTree/>
+      </hashTree>
+      <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="New Simple Product" enabled="true">
+        <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
+          <collectionProp name="Arguments.arguments"/>
+        </elementProp>
+        <stringProp name="HTTPSampler.domain"/>
+        <stringProp name="HTTPSampler.port"/>
+        <stringProp name="HTTPSampler.connect_timeout"/>
+        <stringProp name="HTTPSampler.response_timeout"/>
+        <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
+        <stringProp name="HTTPSampler.contentEncoding"/>
+        <stringProp name="HTTPSampler.path">${base_path}${admin_path}/catalog/product/new/set/4/type/simple/</stringProp>
+        <stringProp name="HTTPSampler.method">GET</stringProp>
+        <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
+        <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
+        <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
+        <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
+        <boolProp name="HTTPSampler.monitor">false</boolProp>
+        <stringProp name="HTTPSampler.embedded_url_re"/>
+      </HTTPSamplerProxy>
+      <hashTree>
+        <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Response Assertion" enabled="true">
+          <collectionProp name="Asserion.test_strings">
+            <stringProp name="-144461265">New Product</stringProp>
+          </collectionProp>
+          <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
+          <boolProp name="Assertion.assume_success">false</boolProp>
+          <intProp name="Assertion.test_type">2</intProp>
+        </ResponseAssertion>
+        <hashTree/>
+      </hashTree>
+      <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="New Simple Product Validate" enabled="true">
+        <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
+          <collectionProp name="Arguments.arguments">
+            <elementProp name="ajax" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">true</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">ajax</stringProp>
+              <stringProp name="Argument.desc">false</stringProp>
+            </elementProp>
+            <elementProp name="isAjax" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">true</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">isAjax</stringProp>
+              <stringProp name="Argument.desc">false</stringProp>
+            </elementProp>
+            <elementProp name="form_key" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">${admin_form_key}</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">form_key</stringProp>
+              <stringProp name="Argument.desc">false</stringProp>
+            </elementProp>
+            <elementProp name="product[name]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">Simple Product ${__time(YMDHMS)}-${__threadNum}-${__Random(1,1000000)}</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[name]</stringProp>
+              <stringProp name="Argument.desc">false</stringProp>
+            </elementProp>
+            <elementProp name="product[sku]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">SKU ${__time(YMDHMS)}-${__threadNum}-${__Random(1,1000000)}</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[sku]</stringProp>
+              <stringProp name="Argument.desc">false</stringProp>
+            </elementProp>
+            <elementProp name="product[price]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">123</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[price]</stringProp>
+            </elementProp>
+            <elementProp name="product[tax_class_id]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">2</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[tax_class_id]</stringProp>
+            </elementProp>
+            <elementProp name="product[quantity_and_stock_status][qty]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">111</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[quantity_and_stock_status][qty]</stringProp>
+            </elementProp>
+            <elementProp name="product[quantity_and_stock_status][is_in_stock]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">1</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[quantity_and_stock_status][is_in_stock]</stringProp>
+            </elementProp>
+            <elementProp name="product[weight]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">1.0000</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[weight]</stringProp>
+            </elementProp>
+            <elementProp name="product[product_has_weight]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">1</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[product_has_weight]</stringProp>
+              <stringProp name="Argument.desc">true</stringProp>
+            </elementProp>
+            <elementProp name="product[category_ids][]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">2</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[category_ids][]</stringProp>
+            </elementProp>
+            <elementProp name="product[description]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">&lt;p&gt;Full simple product description ${__time(YMDHMS)}-${__threadNum}-${__Random(1,1000000)}&lt;/p&gt;</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[description]</stringProp>
+            </elementProp>
+            <elementProp name="product[short_description]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">&lt;p&gt;Short simple product description ${__time(YMDHMS)}-${__threadNum}-${__Random(1,1000000)}&lt;/p&gt;</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[short_description]</stringProp>
+            </elementProp>
+            <elementProp name="product[status]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">1</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[status]</stringProp>
+            </elementProp>
+            <elementProp name="product[image]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value"/>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[image]</stringProp>
+            </elementProp>
+            <elementProp name="product[small_image]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value"/>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[small_image]</stringProp>
+            </elementProp>
+            <elementProp name="product[thumbnail]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value"/>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[thumbnail]</stringProp>
+            </elementProp>
+            <elementProp name="product[url_key]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">simple-product-${__time(YMDHMS)}-${__threadNum}-${__Random(1,1000000)}</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[url_key]</stringProp>
+            </elementProp>
+            <elementProp name="product[meta_title]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">Simple Product ${__time(YMDHMS)}-${__threadNum}-${__Random(1,1000000)} Meta Title</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[meta_title]</stringProp>
+            </elementProp>
+            <elementProp name="product[meta_keyword]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">Simple Product ${__time(YMDHMS)}-${__threadNum}-${__Random(1,1000000)} Meta Keyword</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[meta_keyword]</stringProp>
+            </elementProp>
+            <elementProp name="product[meta_description]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">Simple Product ${__time(YMDHMS)}-${__threadNum}-${__Random(1,1000000)} Meta Description</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[meta_description]</stringProp>
+            </elementProp>
+            <elementProp name="product[website_ids][]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">1</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[website_ids][]</stringProp>
+            </elementProp>
+            <elementProp name="product[special_price]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">99</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[special_price]</stringProp>
+            </elementProp>
+            <elementProp name="product[stock_data][notify_stock_qty]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">1</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[stock_data][notify_stock_qty]</stringProp>
+            </elementProp>
+            <elementProp name="product[special_from_date]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value"/>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[special_from_date]</stringProp>
+            </elementProp>
+            <elementProp name="product[special_to_date]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value"/>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[special_to_date]</stringProp>
+            </elementProp>
+            <elementProp name="product[cost]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value"/>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[cost]</stringProp>
+            </elementProp>
+            <elementProp name="product[tier_price][0][website_id]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">0</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[tier_price][0][website_id]</stringProp>
+            </elementProp>
+            <elementProp name="product[tier_price][0][cust_group]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">32000</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[tier_price][0][cust_group]</stringProp>
+            </elementProp>
+            <elementProp name="product[tier_price][0][price_qty]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">100</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[tier_price][0][price_qty]</stringProp>
+            </elementProp>
+            <elementProp name="product[tier_price][0][price]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">90</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[tier_price][0][price]</stringProp>
+            </elementProp>
+            <elementProp name="product[tier_price][0][delete]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value"/>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[tier_price][0][delete]</stringProp>
+            </elementProp>
+            <elementProp name="product[tier_price][1][website_id]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">0</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[tier_price][1][website_id]</stringProp>
+            </elementProp>
+            <elementProp name="product[tier_price][1][cust_group]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">1</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[tier_price][1][cust_group]</stringProp>
+            </elementProp>
+            <elementProp name="product[tier_price][1][price_qty]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">101</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[tier_price][1][price_qty]</stringProp>
+            </elementProp>
+            <elementProp name="product[tier_price][1][price]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">99</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[tier_price][1][price]</stringProp>
+            </elementProp>
+            <elementProp name="product[tier_price][1][delete]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value"/>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[tier_price][1][delete]</stringProp>
+            </elementProp>
+            <elementProp name="product[stock_data][use_config_manage_stock]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">1</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[stock_data][use_config_manage_stock]</stringProp>
+            </elementProp>
+            <elementProp name="product[stock_data][original_inventory_qty]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">100500</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[stock_data][original_inventory_qty]</stringProp>
+            </elementProp>
+            <elementProp name="product[stock_data][qty]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">100500</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[stock_data][qty]</stringProp>
+            </elementProp>
+            <elementProp name="product[stock_data][min_qty]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">0</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[stock_data][min_qty]</stringProp>
+            </elementProp>
+            <elementProp name="product[stock_data][use_config_min_qty]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">1</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[stock_data][use_config_min_qty]</stringProp>
+            </elementProp>
+            <elementProp name="product[stock_data][min_sale_qty]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">1</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[stock_data][min_sale_qty]</stringProp>
+            </elementProp>
+            <elementProp name="product[stock_data][use_config_min_sale_qty]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">1</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[stock_data][use_config_min_sale_qty]</stringProp>
+            </elementProp>
+            <elementProp name="product[stock_data][max_sale_qty]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">10000</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[stock_data][max_sale_qty]</stringProp>
+            </elementProp>
+            <elementProp name="product[stock_data][use_config_max_sale_qty]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">1</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[stock_data][use_config_max_sale_qty]</stringProp>
+            </elementProp>
+            <elementProp name="product[stock_data][is_qty_decimal]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">0</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[stock_data][is_qty_decimal]</stringProp>
+            </elementProp>
+            <elementProp name="product[stock_data][is_decimal_divided]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">0</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[stock_data][is_decimal_divided]</stringProp>
+            </elementProp>
+            <elementProp name="product[stock_data][backorders]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">0</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[stock_data][backorders]</stringProp>
+            </elementProp>
+            <elementProp name="product[stock_data][use_config_backorders]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">1</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[stock_data][use_config_backorders]</stringProp>
+            </elementProp>
+            <elementProp name="product[stock_data][use_config_notify_stock_qty]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">1</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[stock_data][use_config_notify_stock_qty]</stringProp>
+            </elementProp>
+            <elementProp name="product[stock_data][enable_qty_increments]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">0</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[stock_data][enable_qty_increments]</stringProp>
+            </elementProp>
+            <elementProp name="product[stock_data][qty_increments]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">0</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[stock_data][qty_increments]</stringProp>
+            </elementProp>
+            <elementProp name="product[stock_data][use_config_qty_increments]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">1</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[stock_data][use_config_qty_increments]</stringProp>
+            </elementProp>
+            <elementProp name="product[stock_data][is_in_stock]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">1</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[stock_data][is_in_stock]</stringProp>
+            </elementProp>
+            <elementProp name="product[custom_design]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value"/>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[custom_design]</stringProp>
+            </elementProp>
+            <elementProp name="product[custom_design_from]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value"/>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[custom_design_from]</stringProp>
+            </elementProp>
+            <elementProp name="product[custom_design_to]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value"/>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[custom_design_to]</stringProp>
+            </elementProp>
+            <elementProp name="product[custom_layout_update]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value"/>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[custom_layout_update]</stringProp>
+            </elementProp>
+            <elementProp name="product[page_layout]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value"/>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[page_layout]</stringProp>
+            </elementProp>
+            <elementProp name="product[options_container]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">container2</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[options_container]</stringProp>
+            </elementProp>
+            <elementProp name="product[options][1][is_delete]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value"/>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[options][1][is_delete]</stringProp>
+              <stringProp name="Argument.desc">false</stringProp>
+            </elementProp>
+            <elementProp name="product[options][1][is_require]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">1</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[options][1][is_require]</stringProp>
+              <stringProp name="Argument.desc">false</stringProp>
+            </elementProp>
+            <elementProp name="product[options][1][previous_group]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">select</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[options][1][previous_group]</stringProp>
+              <stringProp name="Argument.desc">false</stringProp>
+            </elementProp>
+            <elementProp name="product[options][1][previous_type]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">drop_down</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[options][1][previous_type]</stringProp>
+              <stringProp name="Argument.desc">false</stringProp>
+            </elementProp>
+            <elementProp name="product[options][1][sort_order]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">0</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[options][1][sort_order]</stringProp>
+              <stringProp name="Argument.desc">false</stringProp>
+            </elementProp>
+            <elementProp name="product[options][1][title]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">Product Option Title One</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[options][1][title]</stringProp>
+              <stringProp name="Argument.desc">false</stringProp>
+            </elementProp>
+            <elementProp name="product[options][1][type]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">drop_down</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[options][1][type]</stringProp>
+              <stringProp name="Argument.desc">false</stringProp>
+            </elementProp>
+            <elementProp name="product[options][1][values][1][is_delete]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value"/>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[options][1][values][1][is_delete]</stringProp>
+              <stringProp name="Argument.desc">false</stringProp>
+            </elementProp>
+            <elementProp name="product[options][1][values][1][price]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">200</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[options][1][values][1][price]</stringProp>
+              <stringProp name="Argument.desc">false</stringProp>
+            </elementProp>
+            <elementProp name="product[options][1][values][1][price_type]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">fixed</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[options][1][values][1][price_type]</stringProp>
+              <stringProp name="Argument.desc">false</stringProp>
+            </elementProp>
+            <elementProp name="product[options][1][values][1][sku]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">sku-one</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[options][1][values][1][sku]</stringProp>
+              <stringProp name="Argument.desc">false</stringProp>
+            </elementProp>
+            <elementProp name="product[options][1][values][1][sort_order]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">0</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[options][1][values][1][sort_order]</stringProp>
+              <stringProp name="Argument.desc">false</stringProp>
+            </elementProp>
+            <elementProp name="product[options][1][values][1][title]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">Row Title</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[options][1][values][1][title]</stringProp>
+              <stringProp name="Argument.desc">false</stringProp>
+            </elementProp>
+            <elementProp name="product[options][2][is_delete]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value"/>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[options][2][is_delete]</stringProp>
+              <stringProp name="Argument.desc">false</stringProp>
+            </elementProp>
+            <elementProp name="product[options][2][is_require]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">1</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[options][2][is_require]</stringProp>
+              <stringProp name="Argument.desc">false</stringProp>
+            </elementProp>
+            <elementProp name="product[options][2][max_characters]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">250</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[options][2][max_characters]</stringProp>
+              <stringProp name="Argument.desc">false</stringProp>
+            </elementProp>
+            <elementProp name="product[options][2][previous_group]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">text</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[options][2][previous_group]</stringProp>
+              <stringProp name="Argument.desc">false</stringProp>
+            </elementProp>
+            <elementProp name="product[options][2][previous_type]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">field</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[options][2][previous_type]</stringProp>
+              <stringProp name="Argument.desc">false</stringProp>
+            </elementProp>
+            <elementProp name="product[options][2][price]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">500</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[options][2][price]</stringProp>
+              <stringProp name="Argument.desc">false</stringProp>
+            </elementProp>
+            <elementProp name="product[options][2][price_type]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">fixed</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[options][2][price_type]</stringProp>
+              <stringProp name="Argument.desc">false</stringProp>
+            </elementProp>
+            <elementProp name="product[options][2][sku]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">sku-two</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[options][2][sku]</stringProp>
+              <stringProp name="Argument.desc">false</stringProp>
+            </elementProp>
+            <elementProp name="product[options][2][sort_order]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">1</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[options][2][sort_order]</stringProp>
+              <stringProp name="Argument.desc">false</stringProp>
+            </elementProp>
+            <elementProp name="product[options][2][title]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">Field Title</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[options][2][title]</stringProp>
+              <stringProp name="Argument.desc">false</stringProp>
+            </elementProp>
+            <elementProp name="product[options][2][type]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">field</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[options][2][type]</stringProp>
+              <stringProp name="Argument.desc">false</stringProp>
+            </elementProp>
+            <elementProp name="affect_configurable_product_attributes" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">1</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">affect_configurable_product_attributes</stringProp>
+              <stringProp name="Argument.desc">true</stringProp>
+            </elementProp>
+            <elementProp name="new-variations-attribute-set-id" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">4</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">new-variations-attribute-set-id</stringProp>
+              <stringProp name="Argument.desc">true</stringProp>
+            </elementProp>
+            <elementProp name="product[configurable_variation]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value"/>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[configurable_variation]</stringProp>
+              <stringProp name="Argument.desc">true</stringProp>
+            </elementProp>
+            <elementProp name="links[related][0][id]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">${related_product_id}</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">links[related][0][id]</stringProp>
+            </elementProp>
+            <elementProp name="links[related][0][position]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">1</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">links[related][0][position]</stringProp>
+            </elementProp>
+            <elementProp name="links[upsell][0][id]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">${related_product_id}</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">links[upsell][0][id]</stringProp>
+            </elementProp>
+            <elementProp name="links[upsell][0][position]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">1</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">links[upsell][0][position]</stringProp>
+            </elementProp>
+            <elementProp name="links[crosssell][0][id]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">${related_product_id}</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">links[crosssell][0][id]</stringProp>
+            </elementProp>
+            <elementProp name="links[crosssell][0][position]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">1</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">links[crosssell][0][position]</stringProp>
+            </elementProp>
+          </collectionProp>
+        </elementProp>
+        <stringProp name="HTTPSampler.domain"/>
+        <stringProp name="HTTPSampler.port"/>
+        <stringProp name="HTTPSampler.connect_timeout"/>
+        <stringProp name="HTTPSampler.response_timeout"/>
+        <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
+        <stringProp name="HTTPSampler.contentEncoding"/>
+        <stringProp name="HTTPSampler.path">${base_path}${admin_path}/catalog/product/validate/set/4/</stringProp>
+        <stringProp name="HTTPSampler.method">POST</stringProp>
+        <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
+        <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
+        <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
+        <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
+        <boolProp name="HTTPSampler.monitor">false</boolProp>
+        <stringProp name="HTTPSampler.embedded_url_re"/>
+      </HTTPSamplerProxy>
+      <hashTree>
+        <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Response Assertion" enabled="true">
+          <collectionProp name="Asserion.test_strings">
+            <stringProp name="1853918323">{"error":false}</stringProp>
+          </collectionProp>
+          <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
+          <boolProp name="Assertion.assume_success">false</boolProp>
+          <intProp name="Assertion.test_type">2</intProp>
+        </ResponseAssertion>
+        <hashTree/>
+      </hashTree>
+      <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="New Simple Product Save" enabled="true">
+        <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
+          <collectionProp name="Arguments.arguments">
+            <elementProp name="ajax" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">true</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">ajax</stringProp>
+              <stringProp name="Argument.desc">false</stringProp>
+            </elementProp>
+            <elementProp name="isAjax" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">true</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">isAjax</stringProp>
+              <stringProp name="Argument.desc">false</stringProp>
+            </elementProp>
+            <elementProp name="form_key" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">${admin_form_key}</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">form_key</stringProp>
+              <stringProp name="Argument.desc">false</stringProp>
+            </elementProp>
+            <elementProp name="product[name]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">Simple Product ${__time(YMDHMS)}-${__threadNum}-${__Random(1,1000000)}</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[name]</stringProp>
+              <stringProp name="Argument.desc">false</stringProp>
+            </elementProp>
+            <elementProp name="product[sku]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">SKU ${__time(YMDHMS)}-${__threadNum}-${__Random(1,1000000)}</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[sku]</stringProp>
+              <stringProp name="Argument.desc">false</stringProp>
+            </elementProp>
+            <elementProp name="product[price]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">123</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[price]</stringProp>
+            </elementProp>
+            <elementProp name="product[tax_class_id]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">2</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[tax_class_id]</stringProp>
+            </elementProp>
+            <elementProp name="product[quantity_and_stock_status][qty]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">111</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[quantity_and_stock_status][qty]</stringProp>
+            </elementProp>
+            <elementProp name="product[quantity_and_stock_status][is_in_stock]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">1</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[quantity_and_stock_status][is_in_stock]</stringProp>
+            </elementProp>
+            <elementProp name="product[weight]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">1.0000</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[weight]</stringProp>
+            </elementProp>
+            <elementProp name="product[product_has_weight]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">1</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[product_has_weight]</stringProp>
+              <stringProp name="Argument.desc">true</stringProp>
+            </elementProp>
+            <elementProp name="product[category_ids][]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">2</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[category_ids][]</stringProp>
+            </elementProp>
+            <elementProp name="product[description]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">&lt;p&gt;Full simple product Description ${__time(YMDHMS)}-${__threadNum}-${__Random(1,1000000)}&lt;/p&gt;</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[description]</stringProp>
+            </elementProp>
+            <elementProp name="product[short_description]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">&lt;p&gt;Short simple product description ${__time(YMDHMS)}-${__threadNum}-${__Random(1,1000000)}&lt;/p&gt;</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[short_description]</stringProp>
+            </elementProp>
+            <elementProp name="product[status]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">1</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[status]</stringProp>
+            </elementProp>
+            <elementProp name="product[image]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value"/>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[image]</stringProp>
+            </elementProp>
+            <elementProp name="product[small_image]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value"/>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[small_image]</stringProp>
+            </elementProp>
+            <elementProp name="product[thumbnail]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value"/>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[thumbnail]</stringProp>
+            </elementProp>
+            <elementProp name="product[url_key]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">simple-product-${__time(YMDHMS)}-${__threadNum}-${__Random(1,1000000)}</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[url_key]</stringProp>
+            </elementProp>
+            <elementProp name="product[meta_title]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">Simple Product ${__time(YMDHMS)}-${__threadNum}-${__Random(1,1000000)} Meta Title</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[meta_title]</stringProp>
+            </elementProp>
+            <elementProp name="product[meta_keyword]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">Simple Product ${__time(YMDHMS)}-${__threadNum}-${__Random(1,1000000)} Meta Keyword</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[meta_keyword]</stringProp>
+            </elementProp>
+            <elementProp name="product[meta_description]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">Simple Product ${__time(YMDHMS)}-${__threadNum}-${__Random(1,1000000)} Meta Description</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[meta_description]</stringProp>
+            </elementProp>
+            <elementProp name="product[website_ids][]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">1</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[website_ids][]</stringProp>
+            </elementProp>
+            <elementProp name="product[special_price]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">99</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[special_price]</stringProp>
+            </elementProp>
+            <elementProp name="product[special_from_date]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value"/>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[special_from_date]</stringProp>
+            </elementProp>
+            <elementProp name="product[special_to_date]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value"/>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[special_to_date]</stringProp>
+            </elementProp>
+            <elementProp name="product[cost]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value"/>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[cost]</stringProp>
+            </elementProp>
+            <elementProp name="product[tier_price][0][website_id]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">0</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[tier_price][0][website_id]</stringProp>
+            </elementProp>
+            <elementProp name="product[tier_price][0][cust_group]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">32000</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[tier_price][0][cust_group]</stringProp>
+            </elementProp>
+            <elementProp name="product[tier_price][0][price_qty]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">100</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[tier_price][0][price_qty]</stringProp>
+            </elementProp>
+            <elementProp name="product[tier_price][0][price]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">90</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[tier_price][0][price]</stringProp>
+            </elementProp>
+            <elementProp name="product[tier_price][0][delete]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value"/>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[tier_price][0][delete]</stringProp>
+            </elementProp>
+            <elementProp name="product[tier_price][1][website_id]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">0</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[tier_price][1][website_id]</stringProp>
+            </elementProp>
+            <elementProp name="product[tier_price][1][cust_group]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">1</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[tier_price][1][cust_group]</stringProp>
+            </elementProp>
+            <elementProp name="product[tier_price][1][price_qty]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">101</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[tier_price][1][price_qty]</stringProp>
+            </elementProp>
+            <elementProp name="product[tier_price][1][price]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">99</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[tier_price][1][price]</stringProp>
+            </elementProp>
+            <elementProp name="product[tier_price][1][delete]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value"/>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[tier_price][1][delete]</stringProp>
+            </elementProp>
+            <elementProp name="product[stock_data][use_config_manage_stock]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">1</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[stock_data][use_config_manage_stock]</stringProp>
+            </elementProp>
+            <elementProp name="product[stock_data][original_inventory_qty]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">100500</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[stock_data][original_inventory_qty]</stringProp>
+            </elementProp>
+            <elementProp name="product[stock_data][qty]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">100500</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[stock_data][qty]</stringProp>
+            </elementProp>
+            <elementProp name="product[stock_data][min_qty]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">0</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[stock_data][min_qty]</stringProp>
+            </elementProp>
+            <elementProp name="product[stock_data][use_config_min_qty]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">1</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[stock_data][use_config_min_qty]</stringProp>
+            </elementProp>
+            <elementProp name="product[stock_data][min_sale_qty]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">1</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[stock_data][min_sale_qty]</stringProp>
+            </elementProp>
+            <elementProp name="product[stock_data][use_config_min_sale_qty]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">1</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[stock_data][use_config_min_sale_qty]</stringProp>
+            </elementProp>
+            <elementProp name="product[stock_data][max_sale_qty]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">10000</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[stock_data][max_sale_qty]</stringProp>
+            </elementProp>
+            <elementProp name="product[stock_data][use_config_max_sale_qty]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">1</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[stock_data][use_config_max_sale_qty]</stringProp>
+            </elementProp>
+            <elementProp name="product[stock_data][is_qty_decimal]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">0</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[stock_data][is_qty_decimal]</stringProp>
+            </elementProp>
+            <elementProp name="product[stock_data][is_decimal_divided]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">0</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[stock_data][is_decimal_divided]</stringProp>
+            </elementProp>
+            <elementProp name="product[stock_data][backorders]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">0</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[stock_data][backorders]</stringProp>
+            </elementProp>
+            <elementProp name="product[stock_data][use_config_backorders]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">1</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[stock_data][use_config_backorders]</stringProp>
+            </elementProp>
+            <elementProp name="product[stock_data][notify_stock_qty]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">1</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[stock_data][notify_stock_qty]</stringProp>
+            </elementProp>
+            <elementProp name="product[stock_data][use_config_notify_stock_qty]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">1</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[stock_data][use_config_notify_stock_qty]</stringProp>
+            </elementProp>
+            <elementProp name="product[stock_data][enable_qty_increments]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">0</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[stock_data][enable_qty_increments]</stringProp>
+            </elementProp>
+            <elementProp name="product[stock_data][qty_increments]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">0</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[stock_data][qty_increments]</stringProp>
+            </elementProp>
+            <elementProp name="product[stock_data][use_config_qty_increments]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">1</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[stock_data][use_config_qty_increments]</stringProp>
+            </elementProp>
+            <elementProp name="product[stock_data][is_in_stock]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">1</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[stock_data][is_in_stock]</stringProp>
+            </elementProp>
+            <elementProp name="product[custom_design]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value"/>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[custom_design]</stringProp>
+            </elementProp>
+            <elementProp name="product[custom_design_from]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value"/>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[custom_design_from]</stringProp>
+            </elementProp>
+            <elementProp name="product[custom_design_to]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value"/>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[custom_design_to]</stringProp>
+            </elementProp>
+            <elementProp name="product[custom_layout_update]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value"/>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[custom_layout_update]</stringProp>
+            </elementProp>
+            <elementProp name="product[page_layout]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value"/>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[page_layout]</stringProp>
+            </elementProp>
+            <elementProp name="product[options_container]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">container2</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[options_container]</stringProp>
+            </elementProp>
+            <elementProp name="product[options][1][is_delete]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value"/>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[options][1][is_delete]</stringProp>
+              <stringProp name="Argument.desc">true</stringProp>
+            </elementProp>
+            <elementProp name="product[options][1][is_require]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">1</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[options][1][is_require]</stringProp>
+            </elementProp>
+            <elementProp name="product[options][1][previous_group]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">select</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[options][1][previous_group]</stringProp>
+              <stringProp name="Argument.desc">false</stringProp>
+            </elementProp>
+            <elementProp name="product[options][1][previous_type]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">drop_down</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[options][1][previous_type]</stringProp>
+              <stringProp name="Argument.desc">false</stringProp>
+            </elementProp>
+            <elementProp name="product[options][1][sort_order]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">0</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[options][1][sort_order]</stringProp>
+              <stringProp name="Argument.desc">false</stringProp>
+            </elementProp>
+            <elementProp name="product[options][1][title]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">Product Option Title One</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[options][1][title]</stringProp>
+            </elementProp>
+            <elementProp name="product[options][1][type]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">drop_down</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[options][1][type]</stringProp>
+            </elementProp>
+            <elementProp name="product[options][1][values][1][is_delete]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value"/>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[options][1][values][1][is_delete]</stringProp>
+              <stringProp name="Argument.desc">false</stringProp>
+            </elementProp>
+            <elementProp name="product[options][1][values][1][price]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">200</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[options][1][values][1][price]</stringProp>
+            </elementProp>
+            <elementProp name="product[options][1][values][1][price_type]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">fixed</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[options][1][values][1][price_type]</stringProp>
+            </elementProp>
+            <elementProp name="product[options][1][values][1][sku]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">sku-one</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[options][1][values][1][sku]</stringProp>
+            </elementProp>
+            <elementProp name="product[options][1][values][1][sort_order]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">0</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[options][1][values][1][sort_order]</stringProp>
+            </elementProp>
+            <elementProp name="product[options][1][values][1][title]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">Row Title</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[options][1][values][1][title]</stringProp>
+            </elementProp>
+            <elementProp name="product[options][2][is_delete]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value"/>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[options][2][is_delete]</stringProp>
+              <stringProp name="Argument.desc">false</stringProp>
+            </elementProp>
+            <elementProp name="product[options][2][is_require]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">1</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[options][2][is_require]</stringProp>
+            </elementProp>
+            <elementProp name="product[options][2][max_characters]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">250</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[options][2][max_characters]</stringProp>
+            </elementProp>
+            <elementProp name="product[options][2][previous_group]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">text</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[options][2][previous_group]</stringProp>
+            </elementProp>
+            <elementProp name="product[options][2][previous_type]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">field</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[options][2][previous_type]</stringProp>
+            </elementProp>
+            <elementProp name="product[options][2][price]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">500</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[options][2][price]</stringProp>
+            </elementProp>
+            <elementProp name="product[options][2][price_type]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">fixed</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[options][2][price_type]</stringProp>
+            </elementProp>
+            <elementProp name="product[options][2][sku]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">sku-two</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[options][2][sku]</stringProp>
+            </elementProp>
+            <elementProp name="product[options][2][sort_order]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">1</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[options][2][sort_order]</stringProp>
+            </elementProp>
+            <elementProp name="product[options][2][title]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">Field Title</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[options][2][title]</stringProp>
+            </elementProp>
+            <elementProp name="product[options][2][type]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">field</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[options][2][type]</stringProp>
+            </elementProp>
+            <elementProp name="affect_configurable_product_attributes" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">1</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">affect_configurable_product_attributes</stringProp>
+              <stringProp name="Argument.desc">true</stringProp>
+            </elementProp>
+            <elementProp name="new-variations-attribute-set-id" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">4</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">new-variations-attribute-set-id</stringProp>
+              <stringProp name="Argument.desc">true</stringProp>
+            </elementProp>
+            <elementProp name="product[configurable_variation]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value"/>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">product[configurable_variation]</stringProp>
+              <stringProp name="Argument.desc">true</stringProp>
+            </elementProp>
+            <elementProp name="links[related][0][id]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">${related_product_id}</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">links[related][0][id]</stringProp>
+            </elementProp>
+            <elementProp name="links[related][0][position]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">1</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">links[related][0][position]</stringProp>
+            </elementProp>
+            <elementProp name="links[upsell][0][id]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">${related_product_id}</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">links[upsell][0][id]</stringProp>
+            </elementProp>
+            <elementProp name="links[upsell][0][position]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">1</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">links[upsell][0][position]</stringProp>
+            </elementProp>
+            <elementProp name="links[crosssell][0][id]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">${related_product_id}</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">links[crosssell][0][id]</stringProp>
+            </elementProp>
+            <elementProp name="links[crosssell][0][position]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">1</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">links[crosssell][0][position]</stringProp>
+            </elementProp>
+          </collectionProp>
+        </elementProp>
+        <stringProp name="HTTPSampler.domain"/>
+        <stringProp name="HTTPSampler.port"/>
+        <stringProp name="HTTPSampler.connect_timeout"/>
+        <stringProp name="HTTPSampler.response_timeout"/>
+        <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
+        <stringProp name="HTTPSampler.contentEncoding"/>
+        <stringProp name="HTTPSampler.path">${base_path}${admin_path}/catalog/product/save/set/4/type/simple/back/edit/active_tab/product-details/</stringProp>
+        <stringProp name="HTTPSampler.method">POST</stringProp>
+        <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
+        <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
+        <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
+        <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
+        <boolProp name="HTTPSampler.monitor">false</boolProp>
+        <stringProp name="HTTPSampler.embedded_url_re"/>
+      </HTTPSamplerProxy>
+      <hashTree>
+        <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Response Assertion" enabled="true">
+          <collectionProp name="Asserion.test_strings">
+            <stringProp name="-583471546">You saved the product</stringProp>
+          </collectionProp>
+          <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
+          <boolProp name="Assertion.assume_success">false</boolProp>
+          <intProp name="Assertion.test_type">2</intProp>
+        </ResponseAssertion>
+        <hashTree/>
+        <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Response Assertion" enabled="true">
+          <collectionProp name="Asserion.test_strings">
+            <stringProp name="-1600986843">violation</stringProp>
+          </collectionProp>
+          <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
+          <boolProp name="Assertion.assume_success">false</boolProp>
+          <intProp name="Assertion.test_type">6</intProp>
+        </ResponseAssertion>
+        <hashTree/>
+      </hashTree>
+    </hashTree>
+  </hashTree>
+  
+    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Logout" enabled="true">
+      <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
+        <collectionProp name="Arguments.arguments"/>
+      </elementProp>
+      <stringProp name="HTTPSampler.domain"/>
+      <stringProp name="HTTPSampler.port"/>
+      <stringProp name="HTTPSampler.connect_timeout"/>
+      <stringProp name="HTTPSampler.response_timeout"/>
+      <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
+      <stringProp name="HTTPSampler.contentEncoding"/>
+      <stringProp name="HTTPSampler.path">${base_path}${admin_path}/admin/auth/logout/</stringProp>
+      <stringProp name="HTTPSampler.method">GET</stringProp>
+      <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
+      <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
+      <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
+      <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
+      <boolProp name="HTTPSampler.monitor">false</boolProp>
+      <stringProp name="HTTPSampler.embedded_url_re"/>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/setup/admin_logout.jmx</stringProp></HTTPSamplerProxy>
+    <hashTree>
+    
+    <BeanShellPostProcessor guiclass="TestBeanGUI" testclass="BeanShellPostProcessor" testname="Return Admin to Pool" enabled="true">
+        <boolProp name="resetInterpreter">false</boolProp>
+        <stringProp name="parameters"/>
+        <stringProp name="filename"/>
+        <stringProp name="script">
+adminUserList = props.get("adminUserList");
+adminUserList.add(vars.get("admin_user"));
+        </stringProp>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/common/return_admin_email_to_pool.jmx</stringProp></BeanShellPostProcessor>
+    <hashTree/>
+  </hashTree>
+  </hashTree>
+
+  
+    <ThroughputController guiclass="ThroughputControllerGui" testclass="ThroughputController" testname="Admin Edit Product" enabled="true">
+      <intProp name="ThroughputController.style">1</intProp>
+      <boolProp name="ThroughputController.perThread">false</boolProp>
+      <intProp name="ThroughputController.maxThroughput">1</intProp>
+      <stringProp name="ThroughputController.percentThroughput">${adminProductEditingPercentage}</stringProp>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/_system/scenario_controller_tmpl.jmx</stringProp></ThroughputController>
+    <hashTree>
+        <JSR223PreProcessor guiclass="TestBeanGUI" testclass="JSR223PreProcessor" testname="Set Test Label" enabled="true">
+            <stringProp name="script">
+var testLabel = "${testLabel}" ? " (${testLabel})" : "";
+if (testLabel
+    &amp;&amp; sampler.getClass().getName() == 'org.apache.jmeter.protocol.http.sampler.HTTPSamplerProxy'
+) {
+    if (sampler.getName().indexOf(testLabel) == -1) {
+       sampler.setName(sampler.getName() + testLabel);
+    }
+} else if (sampler.getName().indexOf("SetUp - ") == -1) {
+    sampler.setName("SetUp - " + sampler.getName());
+}
+            </stringProp>
+            <stringProp name="scriptLanguage">javascript</stringProp>
+        <stringProp name="TestPlan.comments">mpaf/tool/fragments/_system/setup_label.jmx</stringProp></JSR223PreProcessor>
+        <hashTree/>
+        <BeanShellSampler guiclass="BeanShellSamplerGui" testclass="BeanShellSampler" testname="SetUp - Set Label" enabled="true">
+            <stringProp name="BeanShellSampler.query">
+                vars.put("testLabel", "Admin Edit Product");
+            </stringProp>
+            <boolProp name="BeanShellSampler.resetInterpreter">true</boolProp>
+        </BeanShellSampler>
+        <hashTree/>
+    
+        <JSR223PostProcessor guiclass="TestBeanGUI" testclass="JSR223PostProcessor" testname="Get admin form key PostProcessor" enabled="true">
+        <stringProp name="script">
+        function getFormKeyFromResponse()
+        {
+            var url = prev.getUrlAsString(),
+            responseCode =  prev.getResponseCode(),
+            formKey = null;
+            searchPattern = /var FORM_KEY = '(.+)'/;
+            if (responseCode == "200" &amp;&amp; url) {
+                response = prev.getResponseDataAsString();
+                formKey = response  &amp;&amp; response.match(searchPattern) ? response.match(searchPattern)[1] : null;
+            }
+            return formKey;
+        }
+
+        formKey = vars.get("form_key_storage");
+
+	   currentFormKey = getFormKeyFromResponse();
+
+	   if (currentFormKey != null &amp;&amp; currentFormKey != formKey) {
+		  vars.put("form_key_storage", currentFormKey);
+	   }
+        </stringProp>
+        <stringProp name="scriptLanguage">javascript</stringProp>
+        <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin/handle_admin_form_key.jmx</stringProp></JSR223PostProcessor>
+        <hashTree/>
+        <JSR223PreProcessor guiclass="TestBeanGUI" testclass="JSR223PreProcessor" testname="Set admin form key PreProcessor" enabled="true">
+            <stringProp name="script">
+                formKey =  vars.get("form_key_storage");
+                if (formKey
+                    &amp;&amp; sampler.getClass().getName() == 'org.apache.jmeter.protocol.http.sampler.HTTPSamplerProxy'
+                    &amp;&amp; sampler.getMethod() == "POST")
+                    {
+                        arguments = sampler.getArguments();
+                        for (i=0; i&lt;arguments.getArgumentCount(); i++)
+                        {
+                            argument = arguments.getArgument(i);
+                            if (argument.getName() == 'form_key' &amp;&amp; argument.getValue() != formKey) {
+                            log.info("admin form key updated: " + argument.getValue() + " =&gt; " + formKey);
+                            argument.setValue(formKey);
+                        }
+                    }
+                }
+            </stringProp>
+            <stringProp name="scriptLanguage">javascript</stringProp>
+        </JSR223PreProcessor>
+        <hashTree/>
+    
+    <CookieManager guiclass="CookiePanel" testclass="CookieManager" testname="HTTP Cookie Manager" enabled="true">
+      <collectionProp name="CookieManager.cookies"/>
+      <boolProp name="CookieManager.clearEachIteration">false</boolProp>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/http_cookie_manager_without_clear_each_iteration.jmx</stringProp></CookieManager>
+    <hashTree/>
+  
+    <GenericController guiclass="LogicControllerGui" testclass="GenericController" testname="Admin Login" enabled="true">
+  <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/simple_controller.jmx</stringProp>
+</GenericController>
+    <hashTree>
+    <CriticalSectionController guiclass="CriticalSectionControllerGui" testclass="CriticalSectionController" testname="Admin Login Lock" enabled="true">
+        <stringProp name="CriticalSectionController.lockName">get-admin-email</stringProp>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/lock_controller.jmx</stringProp></CriticalSectionController>
+    <hashTree>
+    
+    <BeanShellSampler guiclass="BeanShellSamplerGui" testclass="BeanShellSampler" testname="SetUp - Get Admin Email" enabled="true">
+      <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/get_admin_email.jmx</stringProp>
+      <stringProp name="BeanShellSampler.query">
+adminUserList = props.get("adminUserList");
+adminUser = adminUserList.poll();
+if (adminUser == null) {
+  SampleResult.setResponseMessage("adminUser list is empty");
+  SampleResult.setResponseData("adminUser list is empty","UTF-8");
+  IsSuccess=false;
+  SampleResult.setSuccessful(false);
+  SampleResult.setStopThread(true);
+}
+vars.put("admin_user", adminUser);
+      </stringProp>
+      <stringProp name="BeanShellSampler.filename"/>
+      <stringProp name="BeanShellSampler.parameters"/>
+      <boolProp name="BeanShellSampler.resetInterpreter">true</boolProp>
+    </BeanShellSampler>
+    <hashTree/>
+  </hashTree>
+  
+    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="SetUp - Login" enabled="true">
+      <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
+        <collectionProp name="Arguments.arguments"/>
+      </elementProp>
+      <stringProp name="HTTPSampler.domain"/>
+      <stringProp name="HTTPSampler.port"/>
+      <stringProp name="HTTPSampler.connect_timeout"/>
+      <stringProp name="HTTPSampler.response_timeout"/>
+      <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
+      <stringProp name="HTTPSampler.contentEncoding"/>
+      <stringProp name="HTTPSampler.path">${base_path}${admin_path}</stringProp>
+      <stringProp name="HTTPSampler.method">GET</stringProp>
+      <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
+      <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
+      <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
+      <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
+      <boolProp name="HTTPSampler.monitor">false</boolProp>
+      <stringProp name="HTTPSampler.embedded_url_re"/>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_login/admin_login.jmx</stringProp></HTTPSamplerProxy>
+    <hashTree>
+      <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert login form shown" enabled="true">
+        <collectionProp name="Asserion.test_strings">
+          <stringProp name="-1397214398">Welcome</stringProp>
+          <stringProp name="-515240035">&lt;title&gt;Magento Admin&lt;/title&gt;</stringProp>
+        </collectionProp>
+        <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
+        <boolProp name="Assertion.assume_success">false</boolProp>
+        <intProp name="Assertion.test_type">2</intProp>
+      </ResponseAssertion>
+      <hashTree/>
+      <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract form key" enabled="true">
+        <stringProp name="RegexExtractor.useHeaders">false</stringProp>
+        <stringProp name="RegexExtractor.refname">admin_form_key</stringProp>
+        <stringProp name="RegexExtractor.regex">&lt;input name="form_key" type="hidden" value="([^'"]+)" /&gt;</stringProp>
+        <stringProp name="RegexExtractor.template">$1$</stringProp>
+        <stringProp name="RegexExtractor.default"/>
+        <stringProp name="RegexExtractor.match_number">1</stringProp>
+      </RegexExtractor>
+      <hashTree/>
+      <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert form_key extracted" enabled="true">
+        <collectionProp name="Asserion.test_strings">
+          <stringProp name="2845929">^.+$</stringProp>
+        </collectionProp>
+        <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
+        <boolProp name="Assertion.assume_success">false</boolProp>
+        <intProp name="Assertion.test_type">1</intProp>
+        <stringProp name="Assertion.scope">variable</stringProp>
+        <stringProp name="Scope.variable">admin_form_key</stringProp>
+      </ResponseAssertion>
+      <hashTree/>
+    </hashTree>
+  
+    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="SetUp - Login Submit Form" enabled="true">
+      <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
+        <collectionProp name="Arguments.arguments">
+          <elementProp name="dummy" elementType="HTTPArgument">
             <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.name">export_filter[thumbnail_label]</stringProp>
             <stringProp name="Argument.value"/>
             <stringProp name="Argument.metadata">=</stringProp>
             <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">dummy</stringProp>
           </elementProp>
-          <elementProp name="export_filter[tier_price][]" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.name">export_filter[tier_price][]</stringProp>
-            <stringProp name="Argument.value">,</stringProp>
-            <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-          </elementProp>
-          <elementProp name="export_filter[updated_at]" elementType="HTTPArgument">
+          <elementProp name="form_key" elementType="HTTPArgument">
             <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.name">export_filter[updated_at]</stringProp>
-            <stringProp name="Argument.value"/>
+            <stringProp name="Argument.value">${admin_form_key}</stringProp>
             <stringProp name="Argument.metadata">=</stringProp>
             <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">form_key</stringProp>
           </elementProp>
-          <elementProp name="export_filter[upsell_tgtr_position_behavior][]" elementType="HTTPArgument">
+          <elementProp name="login[password]" elementType="HTTPArgument">
             <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.name">export_filter[upsell_tgtr_position_behavior][]</stringProp>
-            <stringProp name="Argument.value">,</stringProp>
+            <stringProp name="Argument.value">${admin_password}</stringProp>
             <stringProp name="Argument.metadata">=</stringProp>
             <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">login[password]</stringProp>
           </elementProp>
-          <elementProp name="export_filter[upsell_tgtr_position_limit][]" elementType="HTTPArgument">
+          <elementProp name="login[username]" elementType="HTTPArgument">
             <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.name">export_filter[upsell_tgtr_position_limit][]</stringProp>
-            <stringProp name="Argument.value">,</stringProp>
+            <stringProp name="Argument.value">${admin_user}</stringProp>
             <stringProp name="Argument.metadata">=</stringProp>
             <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">login[username]</stringProp>
           </elementProp>
-          <elementProp name="export_filter[url_key]" elementType="HTTPArgument">
+        </collectionProp>
+      </elementProp>
+      <stringProp name="HTTPSampler.domain"/>
+      <stringProp name="HTTPSampler.port"/>
+      <stringProp name="HTTPSampler.connect_timeout"/>
+      <stringProp name="HTTPSampler.response_timeout"/>
+      <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
+      <stringProp name="HTTPSampler.contentEncoding"/>
+      <stringProp name="HTTPSampler.path">${base_path}${admin_path}/admin/dashboard/</stringProp>
+      <stringProp name="HTTPSampler.method">POST</stringProp>
+      <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
+      <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
+      <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
+      <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
+      <stringProp name="HTTPSampler.implementation">Java</stringProp>
+      <boolProp name="HTTPSampler.monitor">false</boolProp>
+      <stringProp name="HTTPSampler.embedded_url_re"/>
+      <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_login/admin_login_submit_form.jmx</stringProp>
+    </HTTPSamplerProxy>
+    <hashTree>
+        <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract form key" enabled="true">
+            <stringProp name="RegexExtractor.useHeaders">false</stringProp>
+            <stringProp name="RegexExtractor.refname">admin_form_key</stringProp>
+            <stringProp name="RegexExtractor.regex">&lt;input name="form_key" type="hidden" value="([^'"]+)" /&gt;</stringProp>
+            <stringProp name="RegexExtractor.template">$1$</stringProp>
+            <stringProp name="RegexExtractor.default"/>
+            <stringProp name="RegexExtractor.match_number">1</stringProp>
+        <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_login/admin_retrieve_form_key.jmx</stringProp></RegexExtractor>
+        <hashTree/>
+    </hashTree>
+  </hashTree>
+  
+    <GenericController guiclass="LogicControllerGui" testclass="GenericController" testname="Simple Controller" enabled="true">
+  <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/simple_controller.jmx</stringProp>
+</GenericController>
+    <hashTree>
+    <TestFragmentController guiclass="TestFragmentControllerGui" testclass="TestFragmentController" testname="Admin Edit Product" enabled="true"/>
+              <hashTree>
+                <BeanShellSampler guiclass="BeanShellSamplerGui" testclass="BeanShellSampler" testname="SetUp - Generate Unique Ids for each Thread" enabled="true">
+                  <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_edit_product/admin_edit_product_updated.jmx</stringProp>
+                  <stringProp name="BeanShellSampler.query">import java.util.ArrayList;
+    import java.util.HashMap;
+    import java.util.Random;
+
+    try {
+    Random random = new Random();
+    if (${seedForRandom} &gt; 0) {
+      random.setSeed(${seedForRandom} + ${__threadNum});
+    }
+    simpleCount = props.get("simple_products_list").size();
+    configCount = props.get("configurable_products_list").size();
+    productCount = 0;
+    if (simpleCount &gt; configCount) {
+    	productCount = configCount;
+    } else {
+    	productCount = simpleCount;
+    }
+    int threadsNumber = ctx.getThreadGroup().getNumThreads();
+    if (threadsNumber == 0) {
+    	threadsNumber = 1;
+    }
+    //Current thread number starts from 0
+    currentThreadNum = ctx.getThreadNum();
+
+    String siterator = vars.get("threadIterator_" + currentThreadNum.toString());
+    iterator = 0;
+    if(siterator == null){
+    	vars.put("threadIterator_" + currentThreadNum.toString() , "0");
+    } else {
+    	iterator = Integer.parseInt(siterator);
+    	iterator ++;
+    	vars.put("threadIterator_" + currentThreadNum.toString() , iterator.toString());
+    }
+
+    //Number of products for one thread
+    productClusterLength = productCount / threadsNumber;
+
+    if (iterator &gt;= productClusterLength) {
+    	vars.put("threadIterator_" + currentThreadNum.toString(), "0");
+    	iterator = 0;
+    }
+
+    //Index of the current product from the cluster
+    i = productClusterLength * currentThreadNum + iterator;
+
+    //ids of simple and configurable products to edit
+    vars.put("simple_product_id", props.get("simple_products_list").get(i).get("id"));
+    vars.put("configurable_product_id", props.get("configurable_products_list").get(i).get("id"));
+
+    //id of related product
+    do {
+    	relatedIndex = random.nextInt(props.get("simple_products_list").size());
+    } while(i == relatedIndex);
+    vars.put("related_product_id", props.get("simple_products_list").get(relatedIndex).get("id"));
+    } catch (Exception ex) {
+    log.info("Script execution failed", ex);
+}</stringProp>
+                  <stringProp name="BeanShellSampler.filename"/>
+                  <stringProp name="BeanShellSampler.parameters"/>
+                  <boolProp name="BeanShellSampler.resetInterpreter">false</boolProp>
+                </BeanShellSampler>
+                <hashTree/>
+                <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Edit Simple Product" enabled="true">
+                  <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
+                    <collectionProp name="Arguments.arguments"/>
+                  </elementProp>
+                  <stringProp name="HTTPSampler.domain"/>
+                  <stringProp name="HTTPSampler.port"/>
+                  <stringProp name="HTTPSampler.connect_timeout"/>
+                  <stringProp name="HTTPSampler.response_timeout"/>
+                  <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
+                  <stringProp name="HTTPSampler.contentEncoding"/>
+                  <stringProp name="HTTPSampler.path">${base_path}${admin_path}/catalog/product/edit/id/${simple_product_id}/</stringProp>
+                  <stringProp name="HTTPSampler.method">GET</stringProp>
+                  <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
+                  <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
+                  <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
+                  <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
+                  <boolProp name="HTTPSampler.monitor">false</boolProp>
+                  <stringProp name="HTTPSampler.embedded_url_re"/>
+                </HTTPSamplerProxy>
+                <hashTree>
+                  <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Response Assertion" enabled="true">
+                    <collectionProp name="Asserion.test_strings">
+                      <stringProp name="1355179215">Product</stringProp>
+                    </collectionProp>
+                    <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
+                    <boolProp name="Assertion.assume_success">false</boolProp>
+                    <intProp name="Assertion.test_type">16</intProp>
+                  </ResponseAssertion>
+                  <hashTree/>
+                  <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract name" enabled="true">
+                    <stringProp name="RegexExtractor.useHeaders">false</stringProp>
+                    <stringProp name="RegexExtractor.refname">simple_product_name</stringProp>
+                    <stringProp name="RegexExtractor.regex">,"name":"([^'"]+)",</stringProp>
+                    <stringProp name="RegexExtractor.template">$1$</stringProp>
+                    <stringProp name="RegexExtractor.default"/>
+                    <stringProp name="RegexExtractor.match_number">1</stringProp>
+                  </RegexExtractor>
+                  <hashTree/>
+                  <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract sku" enabled="true">
+                    <stringProp name="RegexExtractor.useHeaders">false</stringProp>
+                    <stringProp name="RegexExtractor.refname">simple_product_sku</stringProp>
+                    <stringProp name="RegexExtractor.regex">,"sku":"([^'"]+)",</stringProp>
+                    <stringProp name="RegexExtractor.template">$1$</stringProp>
+                    <stringProp name="RegexExtractor.default"/>
+                    <stringProp name="RegexExtractor.match_number">1</stringProp>
+                  </RegexExtractor>
+                  <hashTree/>
+                  <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract category" enabled="true">
+                    <stringProp name="RegexExtractor.useHeaders">false</stringProp>
+                    <stringProp name="RegexExtractor.refname">simple_product_category_id</stringProp>
+                    <stringProp name="RegexExtractor.regex">,"category_ids":."(\d+)".</stringProp>
+                    <stringProp name="RegexExtractor.template">$1$</stringProp>
+                    <stringProp name="RegexExtractor.default"/>
+                    <stringProp name="RegexExtractor.match_number">1</stringProp>
+                  </RegexExtractor>
+                  <hashTree/>
+                </hashTree>
+                <BeanShellSampler guiclass="BeanShellSamplerGui" testclass="BeanShellSampler" testname="SetUp - Set updated values" enabled="true">
+                  <stringProp name="TestPlan.comments">Passing arguments between threads</stringProp>
+                  <stringProp name="BeanShellSampler.query">//Additional category to be added
+
+    int categoryId = Integer.parseInt(vars.get("simple_product_category_id"));
+    if (categoryId &gt; 4) {
+        categoryId = categoryId - 1;
+    } else {
+        categoryId = categoryId + 1;
+    }
+    vars.put("category_additional", categoryId.toString());
+    //New price
+    vars.put("price_new", "9999");
+    //New special price
+    vars.put("special_price_new", "8888");
+    //New quantity
+    vars.put("quantity_new", "100600");</stringProp>
+                  <stringProp name="BeanShellSampler.filename"/>
+                  <stringProp name="BeanShellSampler.parameters"/>
+                  <boolProp name="BeanShellSampler.resetInterpreter">false</boolProp>
+                </BeanShellSampler>
+                <hashTree/>
+                <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Edit Simple Product Validate" enabled="true">
+                  <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
+                    <collectionProp name="Arguments.arguments">
+                      <elementProp name="ajax" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value">true</stringProp>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">ajax</stringProp>
+                        <stringProp name="Argument.desc">false</stringProp>
+                      </elementProp>
+                      <elementProp name="isAjax" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value">true</stringProp>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">isAjax</stringProp>
+                        <stringProp name="Argument.desc">false</stringProp>
+                      </elementProp>
+                      <elementProp name="form_key" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value">${admin_form_key}</stringProp>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">form_key</stringProp>
+                        <stringProp name="Argument.desc">false</stringProp>
+                      </elementProp>
+                      <elementProp name="product[name]" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value">${simple_product_name}</stringProp>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">product[name]</stringProp>
+                        <stringProp name="Argument.desc">false</stringProp>
+                      </elementProp>
+                      <elementProp name="product[sku]" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value">${simple_product_sku}</stringProp>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">product[sku]</stringProp>
+                        <stringProp name="Argument.desc">false</stringProp>
+                      </elementProp>
+                      <elementProp name="product[price]" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value">${price_new}</stringProp>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">product[price]</stringProp>
+                        <stringProp name="Argument.desc">false</stringProp>
+                      </elementProp>
+                      <elementProp name="product[tax_class_id]" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value">2</stringProp>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">product[tax_class_id]</stringProp>
+                        <stringProp name="Argument.desc">false</stringProp>
+                      </elementProp>
+                      <elementProp name="product[quantity_and_stock_status][qty]" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value">${quantity_new}</stringProp>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">product[quantity_and_stock_status][qty]</stringProp>
+                        <stringProp name="Argument.desc">false</stringProp>
+                      </elementProp>
+                      <elementProp name="product[quantity_and_stock_status][is_in_stock]" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value">1</stringProp>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">product[quantity_and_stock_status][is_in_stock]</stringProp>
+                        <stringProp name="Argument.desc">false</stringProp>
+                      </elementProp>
+                      <elementProp name="product[weight]" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value">1.0000</stringProp>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">product[weight]</stringProp>
+                        <stringProp name="Argument.desc">false</stringProp>
+                      </elementProp>
+                      <elementProp name="product[product_has_weight]" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value">1</stringProp>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">product[product_has_weight]</stringProp>
+                        <stringProp name="Argument.desc">false</stringProp>
+                      </elementProp>
+                      <elementProp name="product[category_ids][]" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value">${simple_product_category_id}</stringProp>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">product[category_ids][]</stringProp>
+                        <stringProp name="Argument.desc">false</stringProp>
+                      </elementProp>
+                      <elementProp name="product[description]" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value">&lt;p&gt;Full simple product Description ${simple_product_id} Edited&lt;/p&gt;</stringProp>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">product[description]</stringProp>
+                        <stringProp name="Argument.desc">false</stringProp>
+                      </elementProp>
+                      <elementProp name="product[status]" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value">1</stringProp>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">product[status]</stringProp>
+                        <stringProp name="Argument.desc">false</stringProp>
+                      </elementProp>
+                      <elementProp name="product[configurable_variations]" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value"/>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">product[configurable_variations]</stringProp>
+                        <stringProp name="Argument.desc">false</stringProp>
+                      </elementProp>
+                      <elementProp name="affect_configurable_product_attributes" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value">1</stringProp>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">affect_configurable_product_attributes</stringProp>
+                        <stringProp name="Argument.desc">false</stringProp>
+                      </elementProp>
+                      <elementProp name="product[image]" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value"/>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">product[image]</stringProp>
+                        <stringProp name="Argument.desc">false</stringProp>
+                      </elementProp>
+                      <elementProp name="product[small_image]" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value"/>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">product[small_image]</stringProp>
+                        <stringProp name="Argument.desc">false</stringProp>
+                      </elementProp>
+                      <elementProp name="product[thumbnail]" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value"/>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">product[thumbnail]</stringProp>
+                        <stringProp name="Argument.desc">false</stringProp>
+                      </elementProp>
+                      <elementProp name="product[url_key]" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value">${simple_product_name}</stringProp>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">product[url_key]</stringProp>
+                        <stringProp name="Argument.desc">false</stringProp>
+                      </elementProp>
+                      <elementProp name="product[meta_title]" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value">${simple_product_name} Meta Title Edited</stringProp>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">product[meta_title]</stringProp>
+                        <stringProp name="Argument.desc">false</stringProp>
+                      </elementProp>
+                      <elementProp name="product[meta_keyword]" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value">${simple_product_name} Meta Keyword Edited</stringProp>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">product[meta_keyword]</stringProp>
+                        <stringProp name="Argument.desc">false</stringProp>
+                      </elementProp>
+                      <elementProp name="product[meta_description]" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value">${simple_product_name} Meta Description Edited</stringProp>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">product[meta_description]</stringProp>
+                        <stringProp name="Argument.desc">false</stringProp>
+                      </elementProp>
+                      <elementProp name="product[website_ids][]" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value">1</stringProp>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">product[website_ids][]</stringProp>
+                        <stringProp name="Argument.desc">false</stringProp>
+                      </elementProp>
+                      <elementProp name="product[special_price]" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value">${special_price_new}</stringProp>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">product[special_price]</stringProp>
+                        <stringProp name="Argument.desc">false</stringProp>
+                      </elementProp>
+                      <elementProp name="product[special_from_date]" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value"/>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">product[special_from_date]</stringProp>
+                        <stringProp name="Argument.desc">false</stringProp>
+                      </elementProp>
+                      <elementProp name="product[special_to_date]" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value"/>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">product[special_to_date]</stringProp>
+                        <stringProp name="Argument.desc">false</stringProp>
+                      </elementProp>
+                      <elementProp name="product[cost]" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value"/>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">product[cost]</stringProp>
+                        <stringProp name="Argument.desc">false</stringProp>
+                      </elementProp>
+                      <elementProp name="product[stock_data][use_config_manage_stock]" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value">1</stringProp>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">product[stock_data][use_config_manage_stock]</stringProp>
+                        <stringProp name="Argument.desc">false</stringProp>
+                      </elementProp>
+                      <elementProp name="product[stock_data][original_inventory_qty]" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value">${quantity_new}</stringProp>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">product[stock_data][original_inventory_qty]</stringProp>
+                        <stringProp name="Argument.desc">false</stringProp>
+                      </elementProp>
+                      <elementProp name="product[stock_data][qty]" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value">${quantity_new}</stringProp>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">product[stock_data][qty]</stringProp>
+                        <stringProp name="Argument.desc">false</stringProp>
+                      </elementProp>
+                      <elementProp name="product[stock_data][min_qty]" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value">0</stringProp>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">product[stock_data][min_qty]</stringProp>
+                        <stringProp name="Argument.desc">false</stringProp>
+                      </elementProp>
+                      <elementProp name="product[stock_data][use_config_min_qty]" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value">1</stringProp>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">product[stock_data][use_config_min_qty]</stringProp>
+                        <stringProp name="Argument.desc">false</stringProp>
+                      </elementProp>
+                      <elementProp name="product[stock_data][min_sale_qty]" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value">1</stringProp>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">product[stock_data][min_sale_qty]</stringProp>
+                        <stringProp name="Argument.desc">false</stringProp>
+                      </elementProp>
+                      <elementProp name="product[stock_data][use_config_min_sale_qty]" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value">1</stringProp>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">product[stock_data][use_config_min_sale_qty]</stringProp>
+                        <stringProp name="Argument.desc">false</stringProp>
+                      </elementProp>
+                      <elementProp name="product[stock_data][max_sale_qty]" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value">10000</stringProp>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">product[stock_data][max_sale_qty]</stringProp>
+                        <stringProp name="Argument.desc">false</stringProp>
+                      </elementProp>
+                      <elementProp name="product[stock_data][use_config_max_sale_qty]" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value">1</stringProp>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">product[stock_data][use_config_max_sale_qty]</stringProp>
+                        <stringProp name="Argument.desc">false</stringProp>
+                      </elementProp>
+                      <elementProp name="product[stock_data][is_qty_decimal]" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value">0</stringProp>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">product[stock_data][is_qty_decimal]</stringProp>
+                        <stringProp name="Argument.desc">false</stringProp>
+                      </elementProp>
+                      <elementProp name="product[stock_data][is_decimal_divided]" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value">0</stringProp>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">product[stock_data][is_decimal_divided]</stringProp>
+                        <stringProp name="Argument.desc">false</stringProp>
+                      </elementProp>
+                      <elementProp name="product[stock_data][backorders]" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value">0</stringProp>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">product[stock_data][backorders]</stringProp>
+                        <stringProp name="Argument.desc">false</stringProp>
+                      </elementProp>
+                      <elementProp name="product[stock_data][use_config_backorders]" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value">1</stringProp>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">product[stock_data][use_config_backorders]</stringProp>
+                        <stringProp name="Argument.desc">false</stringProp>
+                      </elementProp>
+                      <elementProp name="product[stock_data][notify_stock_qty]" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value">1</stringProp>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">product[stock_data][notify_stock_qty]</stringProp>
+                        <stringProp name="Argument.desc">false</stringProp>
+                      </elementProp>
+                      <elementProp name="product[stock_data][use_config_notify_stock_qty]" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value">1</stringProp>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">product[stock_data][use_config_notify_stock_qty]</stringProp>
+                        <stringProp name="Argument.desc">false</stringProp>
+                      </elementProp>
+                      <elementProp name="product[stock_data][enable_qty_increments]" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value">0</stringProp>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">product[stock_data][enable_qty_increments]</stringProp>
+                        <stringProp name="Argument.desc">false</stringProp>
+                      </elementProp>
+                      <elementProp name="product[stock_data][qty_increments]" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value">0</stringProp>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">product[stock_data][qty_increments]</stringProp>
+                        <stringProp name="Argument.desc">false</stringProp>
+                      </elementProp>
+                      <elementProp name="product[stock_data][use_config_qty_increments]" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value">1</stringProp>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">product[stock_data][use_config_qty_increments]</stringProp>
+                        <stringProp name="Argument.desc">false</stringProp>
+                      </elementProp>
+                      <elementProp name="product[stock_data][is_in_stock]" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value">1</stringProp>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">product[stock_data][is_in_stock]</stringProp>
+                        <stringProp name="Argument.desc">false</stringProp>
+                      </elementProp>
+                      <elementProp name="product[custom_design]" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value"/>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">product[custom_design]</stringProp>
+                        <stringProp name="Argument.desc">false</stringProp>
+                      </elementProp>
+                      <elementProp name="product[custom_design_from]" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value"/>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">product[custom_design_from]</stringProp>
+                        <stringProp name="Argument.desc">false</stringProp>
+                      </elementProp>
+                      <elementProp name="product[custom_design_to]" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value"/>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">product[custom_design_to]</stringProp>
+                        <stringProp name="Argument.desc">false</stringProp>
+                      </elementProp>
+                      <elementProp name="product[custom_layout_update]" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value"/>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">product[custom_layout_update]</stringProp>
+                        <stringProp name="Argument.desc">false</stringProp>
+                      </elementProp>
+                      <elementProp name="product[page_layout]" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value"/>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">product[page_layout]</stringProp>
+                        <stringProp name="Argument.desc">false</stringProp>
+                      </elementProp>
+                      <elementProp name="product[options_container]" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value">container2</stringProp>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">product[options_container]</stringProp>
+                        <stringProp name="Argument.desc">false</stringProp>
+                      </elementProp>
+                      <elementProp name="new-variations-attribute-set-id" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value"/>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">new-variations-attribute-set-id</stringProp>
+                        <stringProp name="Argument.desc">false</stringProp>
+                      </elementProp>
+                    </collectionProp>
+                  </elementProp>
+                  <stringProp name="HTTPSampler.domain"/>
+                  <stringProp name="HTTPSampler.port"/>
+                  <stringProp name="HTTPSampler.connect_timeout"/>
+                  <stringProp name="HTTPSampler.response_timeout"/>
+                  <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
+                  <stringProp name="HTTPSampler.contentEncoding"/>
+                  <stringProp name="HTTPSampler.path">${base_path}${admin_path}/catalog/product/validate/id/${simple_product_id}/?isAjax=true</stringProp>
+                  <stringProp name="HTTPSampler.method">POST</stringProp>
+                  <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
+                  <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
+                  <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
+                  <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
+                  <boolProp name="HTTPSampler.monitor">false</boolProp>
+                  <stringProp name="HTTPSampler.embedded_url_re"/>
+                </HTTPSamplerProxy>
+                <hashTree>
+                  <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Response Assertion" enabled="true">
+                    <collectionProp name="Asserion.test_strings">
+                      <stringProp name="1853918323">{"error":false}</stringProp>
+                    </collectionProp>
+                    <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
+                    <boolProp name="Assertion.assume_success">false</boolProp>
+                    <intProp name="Assertion.test_type">2</intProp>
+                  </ResponseAssertion>
+                  <hashTree/>
+                </hashTree>
+                <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Edit Simple Product Save" enabled="true">
+                  <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
+                    <collectionProp name="Arguments.arguments">
+                      <elementProp name="ajax" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value">true</stringProp>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">ajax</stringProp>
+                        <stringProp name="Argument.desc">false</stringProp>
+                      </elementProp>
+                      <elementProp name="isAjax" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value">true</stringProp>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">isAjax</stringProp>
+                        <stringProp name="Argument.desc">false</stringProp>
+                      </elementProp>
+                      <elementProp name="form_key" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value">${admin_form_key}</stringProp>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">form_key</stringProp>
+                        <stringProp name="Argument.desc">false</stringProp>
+                      </elementProp>
+                      <elementProp name="product[name]" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value">${simple_product_name}</stringProp>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">product[name]</stringProp>
+                        <stringProp name="Argument.desc">false</stringProp>
+                      </elementProp>
+                      <elementProp name="product[sku]" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value">${simple_product_sku}</stringProp>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">product[sku]</stringProp>
+                        <stringProp name="Argument.desc">false</stringProp>
+                      </elementProp>
+                      <elementProp name="product[price]" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value">${price_new}</stringProp>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">product[price]</stringProp>
+                        <stringProp name="Argument.desc">false</stringProp>
+                      </elementProp>
+                      <elementProp name="product[tax_class_id]" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value">2</stringProp>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">product[tax_class_id]</stringProp>
+                        <stringProp name="Argument.desc">false</stringProp>
+                      </elementProp>
+                      <elementProp name="product[quantity_and_stock_status][qty]" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value">${quantity_new}</stringProp>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">product[quantity_and_stock_status][qty]</stringProp>
+                        <stringProp name="Argument.desc">false</stringProp>
+                      </elementProp>
+                      <elementProp name="product[quantity_and_stock_status][is_in_stock]" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value">1</stringProp>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">product[quantity_and_stock_status][is_in_stock]</stringProp>
+                        <stringProp name="Argument.desc">false</stringProp>
+                      </elementProp>
+                      <elementProp name="product[weight]" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value">1.0000</stringProp>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">product[weight]</stringProp>
+                        <stringProp name="Argument.desc">false</stringProp>
+                      </elementProp>
+                      <elementProp name="product[product_has_weight]" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value">1</stringProp>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">product[product_has_weight]</stringProp>
+                        <stringProp name="Argument.desc">false</stringProp>
+                      </elementProp>
+                      <elementProp name="product[category_ids][]" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value">${simple_product_category_id}</stringProp>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">product[category_ids][]</stringProp>
+                        <stringProp name="Argument.desc">false</stringProp>
+                      </elementProp>
+                      <elementProp name="product[category_ids][]" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value">${category_additional}</stringProp>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">product[category_ids][]</stringProp>
+                      </elementProp>
+                      <elementProp name="product[description]" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value">&lt;p&gt;Full simple product Description ${simple_product_id} Edited&lt;/p&gt;</stringProp>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">product[description]</stringProp>
+                        <stringProp name="Argument.desc">false</stringProp>
+                      </elementProp>
+                      <elementProp name="product[status]" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value">1</stringProp>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">product[status]</stringProp>
+                        <stringProp name="Argument.desc">false</stringProp>
+                      </elementProp>
+                      <elementProp name="product[configurable_variations]" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value"/>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">product[configurable_variations]</stringProp>
+                        <stringProp name="Argument.desc">false</stringProp>
+                      </elementProp>
+                      <elementProp name="affect_configurable_product_attributes" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value">1</stringProp>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">affect_configurable_product_attributes</stringProp>
+                        <stringProp name="Argument.desc">false</stringProp>
+                      </elementProp>
+                      <elementProp name="product[image]" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value"/>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">product[image]</stringProp>
+                        <stringProp name="Argument.desc">false</stringProp>
+                      </elementProp>
+                      <elementProp name="product[small_image]" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value"/>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">product[small_image]</stringProp>
+                        <stringProp name="Argument.desc">false</stringProp>
+                      </elementProp>
+                      <elementProp name="product[thumbnail]" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value"/>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">product[thumbnail]</stringProp>
+                        <stringProp name="Argument.desc">false</stringProp>
+                      </elementProp>
+                      <elementProp name="product[url_key]" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value">${simple_product_name}</stringProp>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">product[url_key]</stringProp>
+                        <stringProp name="Argument.desc">false</stringProp>
+                      </elementProp>
+                      <elementProp name="product[meta_title]" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value">${simple_product_name} Meta Title Edited</stringProp>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">product[meta_title]</stringProp>
+                        <stringProp name="Argument.desc">false</stringProp>
+                      </elementProp>
+                      <elementProp name="product[meta_keyword]" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value">${simple_product_name} Meta Keyword Edited</stringProp>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">product[meta_keyword]</stringProp>
+                        <stringProp name="Argument.desc">false</stringProp>
+                      </elementProp>
+                      <elementProp name="product[meta_description]" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value">${simple_product_name} Meta Description Edited</stringProp>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">product[meta_description]</stringProp>
+                        <stringProp name="Argument.desc">false</stringProp>
+                      </elementProp>
+                      <elementProp name="product[website_ids][]" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value">1</stringProp>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">product[website_ids][]</stringProp>
+                        <stringProp name="Argument.desc">false</stringProp>
+                      </elementProp>
+                      <elementProp name="product[special_price]" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value">${special_price_new}</stringProp>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">product[special_price]</stringProp>
+                        <stringProp name="Argument.desc">false</stringProp>
+                      </elementProp>
+                      <elementProp name="product[special_from_date]" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value"/>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">product[special_from_date]</stringProp>
+                        <stringProp name="Argument.desc">false</stringProp>
+                      </elementProp>
+                      <elementProp name="product[special_to_date]" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value"/>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">product[special_to_date]</stringProp>
+                        <stringProp name="Argument.desc">false</stringProp>
+                      </elementProp>
+                      <elementProp name="product[cost]" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value"/>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">product[cost]</stringProp>
+                        <stringProp name="Argument.desc">false</stringProp>
+                      </elementProp>
+                      <elementProp name="product[stock_data][use_config_manage_stock]" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value">1</stringProp>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">product[stock_data][use_config_manage_stock]</stringProp>
+                        <stringProp name="Argument.desc">false</stringProp>
+                      </elementProp>
+                      <elementProp name="product[stock_data][original_inventory_qty]" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value">${quantity_new}</stringProp>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">product[stock_data][original_inventory_qty]</stringProp>
+                        <stringProp name="Argument.desc">false</stringProp>
+                      </elementProp>
+                      <elementProp name="product[stock_data][qty]" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value">${quantity_new}</stringProp>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">product[stock_data][qty]</stringProp>
+                        <stringProp name="Argument.desc">false</stringProp>
+                      </elementProp>
+                      <elementProp name="product[stock_data][min_qty]" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value">0</stringProp>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">product[stock_data][min_qty]</stringProp>
+                        <stringProp name="Argument.desc">false</stringProp>
+                      </elementProp>
+                      <elementProp name="product[stock_data][use_config_min_qty]" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value">1</stringProp>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">product[stock_data][use_config_min_qty]</stringProp>
+                        <stringProp name="Argument.desc">false</stringProp>
+                      </elementProp>
+                      <elementProp name="product[stock_data][min_sale_qty]" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value">1</stringProp>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">product[stock_data][min_sale_qty]</stringProp>
+                        <stringProp name="Argument.desc">false</stringProp>
+                      </elementProp>
+                      <elementProp name="product[stock_data][use_config_min_sale_qty]" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value">1</stringProp>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">product[stock_data][use_config_min_sale_qty]</stringProp>
+                        <stringProp name="Argument.desc">false</stringProp>
+                      </elementProp>
+                      <elementProp name="product[stock_data][max_sale_qty]" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value">10000</stringProp>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">product[stock_data][max_sale_qty]</stringProp>
+                        <stringProp name="Argument.desc">false</stringProp>
+                      </elementProp>
+                      <elementProp name="product[stock_data][use_config_max_sale_qty]" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value">1</stringProp>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">product[stock_data][use_config_max_sale_qty]</stringProp>
+                        <stringProp name="Argument.desc">false</stringProp>
+                      </elementProp>
+                      <elementProp name="product[stock_data][is_qty_decimal]" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value">0</stringProp>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">product[stock_data][is_qty_decimal]</stringProp>
+                        <stringProp name="Argument.desc">false</stringProp>
+                      </elementProp>
+                      <elementProp name="product[stock_data][is_decimal_divided]" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value">0</stringProp>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">product[stock_data][is_decimal_divided]</stringProp>
+                        <stringProp name="Argument.desc">false</stringProp>
+                      </elementProp>
+                      <elementProp name="product[stock_data][backorders]" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value">0</stringProp>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">product[stock_data][backorders]</stringProp>
+                        <stringProp name="Argument.desc">false</stringProp>
+                      </elementProp>
+                      <elementProp name="product[stock_data][use_config_backorders]" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value">1</stringProp>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">product[stock_data][use_config_backorders]</stringProp>
+                        <stringProp name="Argument.desc">false</stringProp>
+                      </elementProp>
+                      <elementProp name="product[stock_data][notify_stock_qty]" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value">1</stringProp>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">product[stock_data][notify_stock_qty]</stringProp>
+                        <stringProp name="Argument.desc">false</stringProp>
+                      </elementProp>
+                      <elementProp name="product[stock_data][use_config_notify_stock_qty]" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value">1</stringProp>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">product[stock_data][use_config_notify_stock_qty]</stringProp>
+                        <stringProp name="Argument.desc">false</stringProp>
+                      </elementProp>
+                      <elementProp name="product[stock_data][enable_qty_increments]" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value">0</stringProp>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">product[stock_data][enable_qty_increments]</stringProp>
+                        <stringProp name="Argument.desc">false</stringProp>
+                      </elementProp>
+                      <elementProp name="product[stock_data][qty_increments]" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value">0</stringProp>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">product[stock_data][qty_increments]</stringProp>
+                        <stringProp name="Argument.desc">false</stringProp>
+                      </elementProp>
+                      <elementProp name="product[stock_data][use_config_qty_increments]" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value">1</stringProp>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">product[stock_data][use_config_qty_increments]</stringProp>
+                        <stringProp name="Argument.desc">false</stringProp>
+                      </elementProp>
+                      <elementProp name="product[stock_data][is_in_stock]" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value">1</stringProp>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">product[stock_data][is_in_stock]</stringProp>
+                        <stringProp name="Argument.desc">false</stringProp>
+                      </elementProp>
+                      <elementProp name="product[custom_design]" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value"/>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">product[custom_design]</stringProp>
+                        <stringProp name="Argument.desc">false</stringProp>
+                      </elementProp>
+                      <elementProp name="product[custom_design_from]" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value"/>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">product[custom_design_from]</stringProp>
+                        <stringProp name="Argument.desc">false</stringProp>
+                      </elementProp>
+                      <elementProp name="product[custom_design_to]" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value"/>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">product[custom_design_to]</stringProp>
+                        <stringProp name="Argument.desc">false</stringProp>
+                      </elementProp>
+                      <elementProp name="product[custom_layout_update]" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value"/>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">product[custom_layout_update]</stringProp>
+                        <stringProp name="Argument.desc">false</stringProp>
+                      </elementProp>
+                      <elementProp name="product[page_layout]" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value"/>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">product[page_layout]</stringProp>
+                        <stringProp name="Argument.desc">false</stringProp>
+                      </elementProp>
+                      <elementProp name="product[options_container]" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value">container2</stringProp>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">product[options_container]</stringProp>
+                        <stringProp name="Argument.desc">false</stringProp>
+                      </elementProp>
+                      <elementProp name="new-variations-attribute-set-id" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value"/>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">new-variations-attribute-set-id</stringProp>
+                        <stringProp name="Argument.desc">false</stringProp>
+                      </elementProp>
+                    </collectionProp>
+                  </elementProp>
+                  <stringProp name="HTTPSampler.domain"/>
+                  <stringProp name="HTTPSampler.port"/>
+                  <stringProp name="HTTPSampler.connect_timeout"/>
+                  <stringProp name="HTTPSampler.response_timeout"/>
+                  <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
+                  <stringProp name="HTTPSampler.contentEncoding"/>
+                  <stringProp name="HTTPSampler.path">${base_path}${admin_path}/catalog/product/save/id/${simple_product_id}/back/edit/active_tab/product-details/</stringProp>
+                  <stringProp name="HTTPSampler.method">POST</stringProp>
+                  <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
+                  <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
+                  <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
+                  <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
+                  <boolProp name="HTTPSampler.monitor">false</boolProp>
+                  <stringProp name="HTTPSampler.embedded_url_re"/>
+                </HTTPSamplerProxy>
+                <hashTree>
+                  <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Response Assertion" enabled="true">
+                    <collectionProp name="Asserion.test_strings">
+                      <stringProp name="-583471546">You saved the product</stringProp>
+                    </collectionProp>
+                    <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
+                    <boolProp name="Assertion.assume_success">false</boolProp>
+                    <intProp name="Assertion.test_type">2</intProp>
+                  </ResponseAssertion>
+                  <hashTree/>
+                </hashTree>
+                <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Edit Configurable Product" enabled="true">
+                  <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
+                    <collectionProp name="Arguments.arguments"/>
+                  </elementProp>
+                  <stringProp name="HTTPSampler.domain"/>
+                  <stringProp name="HTTPSampler.port"/>
+                  <stringProp name="HTTPSampler.connect_timeout"/>
+                  <stringProp name="HTTPSampler.response_timeout"/>
+                  <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
+                  <stringProp name="HTTPSampler.contentEncoding"/>
+                  <stringProp name="HTTPSampler.path">${base_path}${admin_path}/catalog/product/edit/id/${configurable_product_id}/</stringProp>
+                  <stringProp name="HTTPSampler.method">GET</stringProp>
+                  <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
+                  <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
+                  <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
+                  <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
+                  <boolProp name="HTTPSampler.monitor">false</boolProp>
+                  <stringProp name="HTTPSampler.embedded_url_re"/>
+                </HTTPSamplerProxy>
+                <hashTree>
+                  <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Response Assertion" enabled="true">
+                    <collectionProp name="Asserion.test_strings">
+                      <stringProp name="1355179215">Product</stringProp>
+                    </collectionProp>
+                    <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
+                    <boolProp name="Assertion.assume_success">false</boolProp>
+                    <intProp name="Assertion.test_type">16</intProp>
+                  </ResponseAssertion>
+                  <hashTree/>
+                  <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract name" enabled="true">
+                    <stringProp name="RegexExtractor.useHeaders">false</stringProp>
+                    <stringProp name="RegexExtractor.refname">configurable_product_name</stringProp>
+                    <stringProp name="RegexExtractor.regex">,"name":"([^'"]+)",</stringProp>
+                    <stringProp name="RegexExtractor.template">$1$</stringProp>
+                    <stringProp name="RegexExtractor.default"/>
+                    <stringProp name="RegexExtractor.match_number">1</stringProp>
+                  </RegexExtractor>
+                  <hashTree/>
+                  <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract sku" enabled="true">
+                    <stringProp name="RegexExtractor.useHeaders">false</stringProp>
+                    <stringProp name="RegexExtractor.refname">configurable_product_sku</stringProp>
+                    <stringProp name="RegexExtractor.regex">,"sku":"([^'"]+)",</stringProp>
+                    <stringProp name="RegexExtractor.template">$1$</stringProp>
+                    <stringProp name="RegexExtractor.default"/>
+                    <stringProp name="RegexExtractor.match_number">1</stringProp>
+                  </RegexExtractor>
+                  <hashTree/>
+                  <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract category" enabled="true">
+                    <stringProp name="RegexExtractor.useHeaders">false</stringProp>
+                    <stringProp name="RegexExtractor.refname">configurable_product_category_id</stringProp>
+                    <stringProp name="RegexExtractor.regex">,"category_ids":."(\d+)"</stringProp>
+                    <stringProp name="RegexExtractor.template">$1$</stringProp>
+                    <stringProp name="RegexExtractor.default"/>
+                    <stringProp name="RegexExtractor.match_number">1</stringProp>
+                  </RegexExtractor>
+                  <hashTree/>
+                  <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract configurable attribute id" enabled="true">
+                    <stringProp name="RegexExtractor.useHeaders">false</stringProp>
+                    <stringProp name="RegexExtractor.refname">configurable_attribute_id</stringProp>
+                    <stringProp name="RegexExtractor.regex">,"configurable_variation":"([^'"]+)",</stringProp>
+                    <stringProp name="RegexExtractor.template">$1$</stringProp>
+                    <stringProp name="RegexExtractor.default"/>
+                    <stringProp name="RegexExtractor.match_number">1</stringProp>
+                    <boolProp name="RegexExtractor.default_empty_value">true</boolProp>
+                  </RegexExtractor>
+                  <hashTree/>
+                  <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract configurable matrix" enabled="true">
+                    <stringProp name="RegexExtractor.useHeaders">false</stringProp>
+                    <stringProp name="RegexExtractor.refname">configurable_matrix</stringProp>
+                    <stringProp name="RegexExtractor.regex">"configurable-matrix":(\[.*?\])</stringProp>
+                    <stringProp name="RegexExtractor.template">$1$</stringProp>
+                    <stringProp name="RegexExtractor.default"/>
+                    <stringProp name="RegexExtractor.match_number">1</stringProp>
+                    <boolProp name="RegexExtractor.default_empty_value">true</boolProp>
+                  </RegexExtractor>
+                  <hashTree/>
+                  <com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor guiclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.gui.JSONPathExtractorGui" testclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor" testname="Extract associated products ids" enabled="true">
+                    <stringProp name="VAR">associated_products_ids</stringProp>
+                    <stringProp name="JSONPATH">$.[*].id</stringProp>
+                    <stringProp name="DEFAULT"/>
+                    <stringProp name="VARIABLE">configurable_matrix</stringProp>
+                    <stringProp name="SUBJECT">VAR</stringProp>
+                  </com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor>
+                  <hashTree/>
+                  <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract configurable product json" enabled="true">
+                    <stringProp name="RegexExtractor.useHeaders">false</stringProp>
+                    <stringProp name="RegexExtractor.refname">configurable_product_data</stringProp>
+                    <stringProp name="RegexExtractor.regex">(\{"product":.*?configurable_attributes_data.*?\})\s*&lt;</stringProp>
+                    <stringProp name="RegexExtractor.template">$1$</stringProp>
+                    <stringProp name="RegexExtractor.default"/>
+                    <stringProp name="RegexExtractor.match_number">1</stringProp>
+                  </RegexExtractor>
+                  <hashTree/>
+                  <com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor guiclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.gui.JSONPathExtractorGui" testclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor" testname="Extract configurable attributes data" enabled="true">
+                    <stringProp name="VAR">configurable_attributes_data</stringProp>
+                    <stringProp name="JSONPATH">$.product.configurable_attributes_data</stringProp>
+                    <stringProp name="DEFAULT"/>
+                    <stringProp name="VARIABLE">configurable_product_data</stringProp>
+                    <stringProp name="SUBJECT">VAR</stringProp>
+                  </com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor>
+                  <hashTree/>
+                  <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract attribute ids" enabled="true">
+                    <stringProp name="RegexExtractor.useHeaders">false</stringProp>
+                    <stringProp name="RegexExtractor.refname">configurable_attribute_ids</stringProp>
+                    <stringProp name="RegexExtractor.regex">"attribute_id":"(\d+)"</stringProp>
+                    <stringProp name="RegexExtractor.template">$1$</stringProp>
+                    <stringProp name="RegexExtractor.default"/>
+                    <stringProp name="RegexExtractor.match_number">-1</stringProp>
+                    <stringProp name="Sample.scope">variable</stringProp>
+                    <stringProp name="Scope.variable">configurable_attributes_data</stringProp>
+                  </RegexExtractor>
+                  <hashTree/>
+                  <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract attribute codes" enabled="true">
+                    <stringProp name="RegexExtractor.useHeaders">false</stringProp>
+                    <stringProp name="RegexExtractor.refname">configurable_attribute_codes</stringProp>
+                    <stringProp name="RegexExtractor.regex">"code":"(\w+)"</stringProp>
+                    <stringProp name="RegexExtractor.template">$1$</stringProp>
+                    <stringProp name="RegexExtractor.default"/>
+                    <stringProp name="RegexExtractor.match_number">-1</stringProp>
+                    <stringProp name="Sample.scope">variable</stringProp>
+                    <stringProp name="Scope.variable">configurable_attributes_data</stringProp>
+                  </RegexExtractor>
+                  <hashTree/>
+                  <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract attribute labels" enabled="true">
+                    <stringProp name="RegexExtractor.useHeaders">false</stringProp>
+                    <stringProp name="RegexExtractor.refname">configurable_attribute_labels</stringProp>
+                    <stringProp name="RegexExtractor.regex">"label":"(.*?)"</stringProp>
+                    <stringProp name="RegexExtractor.template">$1$</stringProp>
+                    <stringProp name="RegexExtractor.default"/>
+                    <stringProp name="RegexExtractor.match_number">-1</stringProp>
+                    <stringProp name="Sample.scope">variable</stringProp>
+                    <stringProp name="Scope.variable">configurable_attributes_data</stringProp>
+                  </RegexExtractor>
+                  <hashTree/>
+                  <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract attribute values" enabled="true">
+                    <stringProp name="RegexExtractor.useHeaders">false</stringProp>
+                    <stringProp name="RegexExtractor.refname">configurable_attribute_values</stringProp>
+                    <stringProp name="RegexExtractor.regex">"values":(\{(?:\}|.*?\}\}))</stringProp>
+                    <stringProp name="RegexExtractor.template">$1$</stringProp>
+                    <stringProp name="RegexExtractor.default"/>
+                    <stringProp name="RegexExtractor.match_number">-1</stringProp>
+                    <stringProp name="Sample.scope">variable</stringProp>
+                    <stringProp name="Scope.variable">configurable_attributes_data</stringProp>
+                  </RegexExtractor>
+                  <hashTree/>
+                </hashTree>
+                <ForeachController guiclass="ForeachControlPanel" testclass="ForeachController" testname="ForEach configurable attribute id" enabled="true">
+                  <stringProp name="ForeachController.inputVal">configurable_attribute_ids</stringProp>
+                  <stringProp name="ForeachController.returnVal">configurable_attribute_id</stringProp>
+                  <boolProp name="ForeachController.useSeparator">true</boolProp>
+                </ForeachController>
+                <hashTree>
+                  <CounterConfig guiclass="CounterConfigGui" testclass="CounterConfig" testname="Counter" enabled="true">
+                    <stringProp name="CounterConfig.start">1</stringProp>
+                    <stringProp name="CounterConfig.end">${configurable_attribute_ids_matchNr}</stringProp>
+                    <stringProp name="CounterConfig.incr">1</stringProp>
+                    <stringProp name="CounterConfig.name">attribute_counter</stringProp>
+                    <stringProp name="CounterConfig.format"/>
+                    <boolProp name="CounterConfig.per_user">true</boolProp>
+                    <boolProp name="CounterConfig.reset_on_tg_iteration">true</boolProp>
+                  </CounterConfig>
+                  <hashTree/>
+                  <BeanShellSampler guiclass="BeanShellSamplerGui" testclass="BeanShellSampler" testname="Process configurable attribute values" enabled="true">
+                    <stringProp name="BeanShellSampler.query">return vars.get("configurable_attribute_values_" + vars.get("attribute_counter"));</stringProp>
+                    <stringProp name="BeanShellSampler.filename"/>
+                    <stringProp name="BeanShellSampler.parameters"/>
+                    <boolProp name="BeanShellSampler.resetInterpreter">false</boolProp>
+                  </BeanShellSampler>
+                  <hashTree>
+                    <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Exctract attribute values" enabled="true">
+                      <stringProp name="RegexExtractor.useHeaders">false</stringProp>
+                      <stringProp name="RegexExtractor.refname">attribute_${configurable_attribute_id}_values</stringProp>
+                      <stringProp name="RegexExtractor.regex">"value_index":"(\d+)"</stringProp>
+                      <stringProp name="RegexExtractor.template">$1$</stringProp>
+                      <stringProp name="RegexExtractor.default"/>
+                      <stringProp name="RegexExtractor.match_number">-1</stringProp>
+                      <stringProp name="Scope.variable">configurable_attribute_values_${attribute_counter}</stringProp>
+                    </RegexExtractor>
+                    <hashTree/>
+                  </hashTree>
+                </hashTree>
+                <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Edit Configurable Product Validate" enabled="true">
+                  <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
+                    <collectionProp name="Arguments.arguments">
+                      <elementProp name="isAjax" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value">true</stringProp>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">isAjax</stringProp>
+                        <stringProp name="Argument.desc">false</stringProp>
+                      </elementProp>
+                      <elementProp name="form_key" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value">${admin_form_key}</stringProp>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">form_key</stringProp>
+                        <stringProp name="Argument.desc">false</stringProp>
+                      </elementProp>
+                      <elementProp name="product[name]" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value">${configurable_product_name}</stringProp>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">product[name]</stringProp>
+                        <stringProp name="Argument.desc">false</stringProp>
+                      </elementProp>
+                      <elementProp name="product[sku]" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value">${configurable_product_sku}</stringProp>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">product[sku]</stringProp>
+                        <stringProp name="Argument.desc">false</stringProp>
+                      </elementProp>
+                      <elementProp name="product[price]" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value">${price_new}</stringProp>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">product[price]</stringProp>
+                        <stringProp name="Argument.desc">false</stringProp>
+                      </elementProp>
+                      <elementProp name="product[tax_class_id]" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value">2</stringProp>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">product[tax_class_id]</stringProp>
+                        <stringProp name="Argument.desc">false</stringProp>
+                      </elementProp>
+                      <elementProp name="product[quantity_and_stock_status][is_in_stock]" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value">1</stringProp>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">product[quantity_and_stock_status][is_in_stock]</stringProp>
+                        <stringProp name="Argument.desc">false</stringProp>
+                      </elementProp>
+                      <elementProp name="product[weight]" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value">3</stringProp>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">product[weight]</stringProp>
+                        <stringProp name="Argument.desc">false</stringProp>
+                      </elementProp>
+                      <elementProp name="product[category_ids][]" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value">${configurable_product_category_id}</stringProp>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">product[category_ids][]</stringProp>
+                        <stringProp name="Argument.desc">false</stringProp>
+                      </elementProp>
+                      <elementProp name="product[category_ids][]" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value">${category_additional}</stringProp>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">product[category_ids][]</stringProp>
+                        <stringProp name="Argument.desc">false</stringProp>
+                      </elementProp>
+                      <elementProp name="product[description]" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value">&lt;p&gt;Configurable product description ${configurable_product_id} Edited&lt;/p&gt;</stringProp>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">product[description]</stringProp>
+                        <stringProp name="Argument.desc">false</stringProp>
+                      </elementProp>
+                      <elementProp name="product[status]" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value">1</stringProp>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">product[status]</stringProp>
+                        <stringProp name="Argument.desc">false</stringProp>
+                      </elementProp>
+                      <elementProp name="product[meta_title]" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value">${configurable_product_name} Meta Title Edited</stringProp>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">product[meta_title]</stringProp>
+                        <stringProp name="Argument.desc">false</stringProp>
+                      </elementProp>
+                      <elementProp name="product[meta_keyword]" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value">${configurable_product_name} Meta Keyword Edited</stringProp>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">product[meta_keyword]</stringProp>
+                        <stringProp name="Argument.desc">false</stringProp>
+                      </elementProp>
+                      <elementProp name="product[meta_description]" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value">${configurable_product_name} Meta Description Edited</stringProp>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">product[meta_description]</stringProp>
+                        <stringProp name="Argument.desc">false</stringProp>
+                      </elementProp>
+                      <elementProp name="product[website_ids][]" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value">1</stringProp>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">product[website_ids][]</stringProp>
+                        <stringProp name="Argument.desc">false</stringProp>
+                      </elementProp>
+                      <elementProp name="product[special_price]" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value">${special_price_new}</stringProp>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">product[special_price]</stringProp>
+                        <stringProp name="Argument.desc">false</stringProp>
+                      </elementProp>
+                      <elementProp name="product[special_from_date]" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value"/>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">product[special_from_date]</stringProp>
+                        <stringProp name="Argument.desc">false</stringProp>
+                      </elementProp>
+                      <elementProp name="product[special_to_date]" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value"/>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">product[special_to_date]</stringProp>
+                        <stringProp name="Argument.desc">false</stringProp>
+                      </elementProp>
+                      <elementProp name="product[cost]" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value"/>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">product[cost]</stringProp>
+                        <stringProp name="Argument.desc">false</stringProp>
+                      </elementProp>
+                      <elementProp name="product[stock_data][use_config_manage_stock]" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value">1</stringProp>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">product[stock_data][use_config_manage_stock]</stringProp>
+                        <stringProp name="Argument.desc">false</stringProp>
+                      </elementProp>
+                      <elementProp name="product[stock_data][min_qty]" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value">0</stringProp>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">product[stock_data][min_qty]</stringProp>
+                        <stringProp name="Argument.desc">false</stringProp>
+                      </elementProp>
+                      <elementProp name="product[stock_data][use_config_min_qty]" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value">1</stringProp>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">product[stock_data][use_config_min_qty]</stringProp>
+                        <stringProp name="Argument.desc">false</stringProp>
+                      </elementProp>
+                      <elementProp name="product[stock_data][min_sale_qty]" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value">1</stringProp>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">product[stock_data][min_sale_qty]</stringProp>
+                        <stringProp name="Argument.desc">false</stringProp>
+                      </elementProp>
+                      <elementProp name="product[stock_data][use_config_min_sale_qty]" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value">1</stringProp>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">product[stock_data][use_config_min_sale_qty]</stringProp>
+                        <stringProp name="Argument.desc">false</stringProp>
+                      </elementProp>
+                      <elementProp name="product[stock_data][use_config_max_sale_qty]" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value">1</stringProp>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">product[stock_data][use_config_max_sale_qty]</stringProp>
+                        <stringProp name="Argument.desc">false</stringProp>
+                      </elementProp>
+                      <elementProp name="product[stock_data][is_qty_decimal]" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value">0</stringProp>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">product[stock_data][is_qty_decimal]</stringProp>
+                        <stringProp name="Argument.desc">false</stringProp>
+                      </elementProp>
+                      <elementProp name="product[stock_data][is_decimal_divided]" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value">0</stringProp>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">product[stock_data][is_decimal_divided]</stringProp>
+                        <stringProp name="Argument.desc">false</stringProp>
+                      </elementProp>
+                      <elementProp name="product[stock_data][backorders]" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value">0</stringProp>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">product[stock_data][backorders]</stringProp>
+                        <stringProp name="Argument.desc">false</stringProp>
+                      </elementProp>
+                      <elementProp name="product[stock_data][use_config_backorders]" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value">1</stringProp>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">product[stock_data][use_config_backorders]</stringProp>
+                        <stringProp name="Argument.desc">false</stringProp>
+                      </elementProp>
+                      <elementProp name="product[stock_data][notify_stock_qty]" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value">1</stringProp>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">product[stock_data][notify_stock_qty]</stringProp>
+                        <stringProp name="Argument.desc">false</stringProp>
+                      </elementProp>
+                      <elementProp name="product[stock_data][use_config_notify_stock_qty]" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value">1</stringProp>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">product[stock_data][use_config_notify_stock_qty]</stringProp>
+                        <stringProp name="Argument.desc">false</stringProp>
+                      </elementProp>
+                      <elementProp name="product[stock_data][enable_qty_increments]" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value">0</stringProp>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">product[stock_data][enable_qty_increments]</stringProp>
+                        <stringProp name="Argument.desc">false</stringProp>
+                      </elementProp>
+                      <elementProp name="product[stock_data][qty_increments]" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value">0</stringProp>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">product[stock_data][qty_increments]</stringProp>
+                        <stringProp name="Argument.desc">false</stringProp>
+                      </elementProp>
+                      <elementProp name="product[stock_data][use_config_qty_increments]" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value">1</stringProp>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">product[stock_data][use_config_qty_increments]</stringProp>
+                        <stringProp name="Argument.desc">false</stringProp>
+                      </elementProp>
+                      <elementProp name="product[stock_data][is_in_stock]" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value">1</stringProp>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">product[stock_data][is_in_stock]</stringProp>
+                        <stringProp name="Argument.desc">false</stringProp>
+                      </elementProp>
+                      <elementProp name="product[custom_design]" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value"/>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">product[custom_design]</stringProp>
+                        <stringProp name="Argument.desc">false</stringProp>
+                      </elementProp>
+                      <elementProp name="product[custom_design_from]" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value"/>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">product[custom_design_from]</stringProp>
+                        <stringProp name="Argument.desc">false</stringProp>
+                      </elementProp>
+                      <elementProp name="product[custom_design_to]" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value"/>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">product[custom_design_to]</stringProp>
+                        <stringProp name="Argument.desc">false</stringProp>
+                      </elementProp>
+                      <elementProp name="product[custom_layout_update]" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value"/>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">product[custom_layout_update]</stringProp>
+                        <stringProp name="Argument.desc">false</stringProp>
+                      </elementProp>
+                      <elementProp name="product[page_layout]" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value"/>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">product[page_layout]</stringProp>
+                        <stringProp name="Argument.desc">false</stringProp>
+                      </elementProp>
+                      <elementProp name="product[options_container]" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value">container2</stringProp>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">product[options_container]</stringProp>
+                        <stringProp name="Argument.desc">false</stringProp>
+                      </elementProp>
+                      <elementProp name="product[configurable_variation]" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value">${configurable_attribute_id}</stringProp>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">product[configurable_variation]</stringProp>
+                        <stringProp name="Argument.desc">false</stringProp>
+                      </elementProp>
+                      <elementProp name="product[url_key]" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value">${configurable_product_name}</stringProp>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">product[url_key]</stringProp>
+                      </elementProp>
+                      <elementProp name="product[use_config_gift_message_available]" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value">1</stringProp>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">product[use_config_gift_message_available]</stringProp>
+                      </elementProp>
+                      <elementProp name="product[use_config_gift_wrapping_available]" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value">1</stringProp>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">product[use_config_gift_wrapping_available]</stringProp>
+                      </elementProp>
+                      <elementProp name="product[visibility]" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value">4</stringProp>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">product[visibility]</stringProp>
+                      </elementProp>
+                      <elementProp name="product[product_has_weight]" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value">1</stringProp>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">product[product_has_weight]</stringProp>
+                        <stringProp name="Argument.desc">true</stringProp>
+                      </elementProp>
+                      <elementProp name="product[stock_data][qty]" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value">50</stringProp>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">product[stock_data][qty]</stringProp>
+                        <stringProp name="Argument.desc">false</stringProp>
+                      </elementProp>
+                      <elementProp name="product[stock_data][type_id]" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value">configurable</stringProp>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">product[stock_data][type_id]</stringProp>
+                        <stringProp name="Argument.desc">false</stringProp>
+                      </elementProp>
+                    </collectionProp>
+                  </elementProp>
+                  <stringProp name="HTTPSampler.domain"/>
+                  <stringProp name="HTTPSampler.port"/>
+                  <stringProp name="HTTPSampler.connect_timeout"/>
+                  <stringProp name="HTTPSampler.response_timeout"/>
+                  <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
+                  <stringProp name="HTTPSampler.contentEncoding"/>
+                  <stringProp name="HTTPSampler.path">${base_path}${admin_path}/catalog/product/validate/id/${configurable_product_id}/</stringProp>
+                  <stringProp name="HTTPSampler.method">POST</stringProp>
+                  <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
+                  <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
+                  <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
+                  <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
+                  <boolProp name="HTTPSampler.monitor">false</boolProp>
+                  <stringProp name="HTTPSampler.embedded_url_re"/>
+                </HTTPSamplerProxy>
+                <hashTree>
+                  <BeanShellPreProcessor guiclass="TestBeanGUI" testclass="BeanShellPreProcessor" testname="Configure product options" enabled="true">
+                    <boolProp name="resetInterpreter">false</boolProp>
+                    <stringProp name="parameters"/>
+                    <stringProp name="filename"/>
+                    <stringProp name="script">try {
+    	int attributesCount = Integer.parseInt(vars.get("configurable_attribute_ids_matchNr"));
+    	for (int i = 1; i &lt;= attributesCount; i++) {
+    		attributeId = vars.get("configurable_attribute_ids_" + i.toString());
+    		attributeCode = vars.get("configurable_attribute_codes_" + i.toString());
+    		attributeLabel = vars.get("configurable_attribute_labels_" + i.toString());
+    		ctx.getCurrentSampler().addArgument("attributes[" + (i - 1).toString() + "]", attributeId);
+    		ctx.getCurrentSampler().addArgument("attribute_codes[" + (i - 1).toString() + "]", attributeCode);
+    		ctx.getCurrentSampler().addArgument("product[" + attributeCode + "]", attributeId);
+    		ctx.getCurrentSampler().addArgument("product[configurable_attributes_data][" + attributeId + "][attribute_id]", attributeId);
+    		ctx.getCurrentSampler().addArgument("product[configurable_attributes_data][" + attributeId + "][position]", (i - 1).toString());
+    		ctx.getCurrentSampler().addArgument("product[configurable_attributes_data][" + attributeId + "][code]", attributeCode);
+    		ctx.getCurrentSampler().addArgument("product[configurable_attributes_data][" + attributeId + "][label]", attributeLabel);
+
+    		int valuesCount = Integer.parseInt(vars.get("attribute_" + attributeId + "_values_matchNr"));
+    		for (int j = 1; j &lt;= valuesCount; j++) {
+    			attributeValue = vars.get("attribute_" + attributeId + "_values_" + j.toString());
+    			ctx.getCurrentSampler().addArgument(
+    				"product[configurable_attributes_data][" + attributeId + "][values][" + attributeValue + "][include]",
+    				"1"
+    			);
+    			ctx.getCurrentSampler().addArgument(
+    				"product[configurable_attributes_data][" + attributeId + "][values][" + attributeValue + "][value_index]",
+    				attributeValue
+    			);
+    		}
+    	}
+    	ctx.getCurrentSampler().addArgument("associated_product_ids_serialized", vars.get("associated_products_ids").toString());
+    } catch (Exception e) {
+        log.error("error???", e);
+    }</stringProp>
+                  </BeanShellPreProcessor>
+                  <hashTree/>
+                  <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Response Assertion" enabled="true">
+                    <collectionProp name="Asserion.test_strings">
+                      <stringProp name="1853918323">{"error":false}</stringProp>
+                    </collectionProp>
+                    <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
+                    <boolProp name="Assertion.assume_success">false</boolProp>
+                    <intProp name="Assertion.test_type">2</intProp>
+                  </ResponseAssertion>
+                  <hashTree/>
+                </hashTree>
+                <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Edit Configurable Product Save" enabled="true">
+                  <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
+                    <collectionProp name="Arguments.arguments">
+                      <elementProp name="ajax" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value">true</stringProp>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">ajax</stringProp>
+                        <stringProp name="Argument.desc">false</stringProp>
+                      </elementProp>
+                      <elementProp name="isAjax" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value">true</stringProp>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">isAjax</stringProp>
+                        <stringProp name="Argument.desc">false</stringProp>
+                      </elementProp>
+                      <elementProp name="form_key" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value">${admin_form_key}</stringProp>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">form_key</stringProp>
+                        <stringProp name="Argument.desc">false</stringProp>
+                      </elementProp>
+                      <elementProp name="product[name]" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value">${configurable_product_name}</stringProp>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">product[name]</stringProp>
+                        <stringProp name="Argument.desc">false</stringProp>
+                      </elementProp>
+                      <elementProp name="product[sku]" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value">${configurable_product_sku}</stringProp>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">product[sku]</stringProp>
+                        <stringProp name="Argument.desc">false</stringProp>
+                      </elementProp>
+                      <elementProp name="product[price]" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value">${price_new}</stringProp>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">product[price]</stringProp>
+                        <stringProp name="Argument.desc">false</stringProp>
+                      </elementProp>
+                      <elementProp name="product[tax_class_id]admin" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value">2</stringProp>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">product[tax_class_id]admin</stringProp>
+                        <stringProp name="Argument.desc">false</stringProp>
+                      </elementProp>
+                      <elementProp name="product[quantity_and_stock_status][is_in_stock]" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value">1</stringProp>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">product[quantity_and_stock_status][is_in_stock]</stringProp>
+                        <stringProp name="Argument.desc">false</stringProp>
+                      </elementProp>
+                      <elementProp name="product[weight]" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value">3</stringProp>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">product[weight]</stringProp>
+                        <stringProp name="Argument.desc">false</stringProp>
+                      </elementProp>
+                      <elementProp name="product[category_ids][]" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value">${configurable_product_category_id}</stringProp>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">product[category_ids][]</stringProp>
+                        <stringProp name="Argument.desc">false</stringProp>
+                      </elementProp>
+                      <elementProp name="product[category_ids][]" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value">${category_additional}</stringProp>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">product[category_ids][]</stringProp>
+                        <stringProp name="Argument.desc">false</stringProp>
+                      </elementProp>
+                      <elementProp name="product[description]" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value">&lt;p&gt;Configurable product description ${configurable_product_id} Edited&lt;/p&gt;</stringProp>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">product[description]</stringProp>
+                        <stringProp name="Argument.desc">false</stringProp>
+                      </elementProp>
+                      <elementProp name="product[status]" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value">1</stringProp>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">product[status]</stringProp>
+                        <stringProp name="Argument.desc">false</stringProp>
+                      </elementProp>
+                      <elementProp name="product[meta_title]" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value">${configurable_product_name} Meta Title Edited</stringProp>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">product[meta_title]</stringProp>
+                        <stringProp name="Argument.desc">false</stringProp>
+                      </elementProp>
+                      <elementProp name="product[meta_keyword]" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value">${configurable_product_name} Meta Keyword Edited</stringProp>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">product[meta_keyword]</stringProp>
+                        <stringProp name="Argument.desc">false</stringProp>
+                      </elementProp>
+                      <elementProp name="product[meta_description]" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value">${configurable_product_name} Meta Description Edited</stringProp>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">product[meta_description]</stringProp>
+                        <stringProp name="Argument.desc">false</stringProp>
+                      </elementProp>
+                      <elementProp name="product[website_ids][]" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value">1</stringProp>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">product[website_ids][]</stringProp>
+                        <stringProp name="Argument.desc">false</stringProp>
+                      </elementProp>
+                      <elementProp name="product[special_price]" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value">${special_price_new}</stringProp>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">product[special_price]</stringProp>
+                        <stringProp name="Argument.desc">false</stringProp>
+                      </elementProp>
+                      <elementProp name="product[special_from_date]" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value"/>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">product[special_from_date]</stringProp>
+                        <stringProp name="Argument.desc">false</stringProp>
+                      </elementProp>
+                      <elementProp name="product[special_to_date]" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value"/>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">product[special_to_date]</stringProp>
+                        <stringProp name="Argument.desc">false</stringProp>
+                      </elementProp>
+                      <elementProp name="product[cost]" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value"/>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">product[cost]</stringProp>
+                        <stringProp name="Argument.desc">false</stringProp>
+                      </elementProp>
+                      <elementProp name="product[stock_data][use_config_manage_stock]" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value">1</stringProp>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">product[stock_data][use_config_manage_stock]</stringProp>
+                        <stringProp name="Argument.desc">false</stringProp>
+                      </elementProp>
+                      <elementProp name="product[stock_data][min_qty]" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value">0</stringProp>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">product[stock_data][min_qty]</stringProp>
+                        <stringProp name="Argument.desc">false</stringProp>
+                      </elementProp>
+                      <elementProp name="product[stock_data][use_config_min_qty]" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value">1</stringProp>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">product[stock_data][use_config_min_qty]</stringProp>
+                        <stringProp name="Argument.desc">false</stringProp>
+                      </elementProp>
+                      <elementProp name="product[stock_data][min_sale_qty]" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value">1</stringProp>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">product[stock_data][min_sale_qty]</stringProp>
+                        <stringProp name="Argument.desc">false</stringProp>
+                      </elementProp>
+                      <elementProp name="product[stock_data][use_config_min_sale_qty]" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value">1</stringProp>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">product[stock_data][use_config_min_sale_qty]</stringProp>
+                        <stringProp name="Argument.desc">false</stringProp>
+                      </elementProp>
+                      <elementProp name="product[stock_data][use_config_max_sale_qty]" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value">1</stringProp>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">product[stock_data][use_config_max_sale_qty]</stringProp>
+                        <stringProp name="Argument.desc">false</stringProp>
+                      </elementProp>
+                      <elementProp name="product[stock_data][is_qty_decimal]" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value">0</stringProp>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">product[stock_data][is_qty_decimal]</stringProp>
+                        <stringProp name="Argument.desc">false</stringProp>
+                      </elementProp>
+                      <elementProp name="product[stock_data][is_decimal_divided]" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value">0</stringProp>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">product[stock_data][is_decimal_divided]</stringProp>
+                        <stringProp name="Argument.desc">false</stringProp>
+                      </elementProp>
+                      <elementProp name="product[stock_data][backorders]" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value">0</stringProp>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">product[stock_data][backorders]</stringProp>
+                        <stringProp name="Argument.desc">false</stringProp>
+                      </elementProp>
+                      <elementProp name="product[stock_data][use_config_backorders]" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value">1</stringProp>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">product[stock_data][use_config_backorders]</stringProp>
+                        <stringProp name="Argument.desc">false</stringProp>
+                      </elementProp>
+                      <elementProp name="product[stock_data][notify_stock_qty]" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value">1</stringProp>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">product[stock_data][notify_stock_qty]</stringProp>
+                        <stringProp name="Argument.desc">false</stringProp>
+                      </elementProp>
+                      <elementProp name="product[stock_data][use_config_notify_stock_qty]" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value">1</stringProp>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">product[stock_data][use_config_notify_stock_qty]</stringProp>
+                        <stringProp name="Argument.desc">false</stringProp>
+                      </elementProp>
+                      <elementProp name="product[stock_data][enable_qty_increments]" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value">0</stringProp>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">product[stock_data][enable_qty_increments]</stringProp>
+                        <stringProp name="Argument.desc">false</stringProp>
+                      </elementProp>
+                      <elementProp name="product[stock_data][qty_increments]" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value">0</stringProp>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">product[stock_data][qty_increments]</stringProp>
+                        <stringProp name="Argument.desc">false</stringProp>
+                      </elementProp>
+                      <elementProp name="product[stock_data][use_config_qty_increments]" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value">1</stringProp>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">product[stock_data][use_config_qty_increments]</stringProp>
+                        <stringProp name="Argument.desc">false</stringProp>
+                      </elementProp>
+                      <elementProp name="product[stock_data][is_in_stock]" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value">1</stringProp>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">product[stock_data][is_in_stock]</stringProp>
+                        <stringProp name="Argument.desc">false</stringProp>
+                      </elementProp>
+                      <elementProp name="product[custom_design]" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value"/>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">product[custom_design]</stringProp>
+                        <stringProp name="Argument.desc">false</stringProp>
+                      </elementProp>
+                      <elementProp name="product[custom_design_from]" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value"/>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">product[custom_design_from]</stringProp>
+                        <stringProp name="Argument.desc">false</stringProp>
+                      </elementProp>
+                      <elementProp name="product[custom_design_to]" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value"/>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">product[custom_design_to]</stringProp>
+                        <stringProp name="Argument.desc">false</stringProp>
+                      </elementProp>
+                      <elementProp name="product[custom_layout_update]" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value"/>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">product[custom_layout_update]</stringProp>
+                        <stringProp name="Argument.desc">false</stringProp>
+                      </elementProp>
+                      <elementProp name="product[page_layout]" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value"/>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">product[page_layout]</stringProp>
+                        <stringProp name="Argument.desc">false</stringProp>
+                      </elementProp>
+                      <elementProp name="product[options_container]" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value">container2</stringProp>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">product[options_container]</stringProp>
+                        <stringProp name="Argument.desc">false</stringProp>
+                      </elementProp>
+                      <elementProp name="product[configurable_variation]" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value">${configurable_attribute_id}</stringProp>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">product[configurable_variation]</stringProp>
+                        <stringProp name="Argument.desc">false</stringProp>
+                      </elementProp>
+                      <elementProp name="product[url_key]" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value">${configurable_product_name}</stringProp>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">product[url_key]</stringProp>
+                      </elementProp>
+                      <elementProp name="product[use_config_gift_message_available]" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value">1</stringProp>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">product[use_config_gift_message_available]</stringProp>
+                      </elementProp>
+                      <elementProp name="product[use_config_gift_wrapping_available]" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value">1</stringProp>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">product[use_config_gift_wrapping_available]</stringProp>
+                      </elementProp>
+                      <elementProp name="product[visibility]" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value">4</stringProp>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">product[visibility]</stringProp>
+                      </elementProp>
+                      <elementProp name="product[product_has_weight]" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value">1</stringProp>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">product[product_has_weight]</stringProp>
+                        <stringProp name="Argument.desc">true</stringProp>
+                      </elementProp>
+                      <elementProp name="product[stock_data][qty]" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value">50</stringProp>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">product[stock_data][qty]</stringProp>
+                        <stringProp name="Argument.desc">false</stringProp>
+                      </elementProp>
+                      <elementProp name="product[stock_data][type_id]" elementType="HTTPArgument">
+                        <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                        <stringProp name="Argument.value">configurable</stringProp>
+                        <stringProp name="Argument.metadata">=</stringProp>
+                        <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                        <stringProp name="Argument.name">product[stock_data][type_id]</stringProp>
+                        <stringProp name="Argument.desc">false</stringProp>
+                      </elementProp>
+                    </collectionProp>
+                  </elementProp>
+                  <stringProp name="HTTPSampler.domain"/>
+                  <stringProp name="HTTPSampler.port"/>
+                  <stringProp name="HTTPSampler.connect_timeout"/>
+                  <stringProp name="HTTPSampler.response_timeout"/>
+                  <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
+                  <stringProp name="HTTPSampler.contentEncoding"/>
+                  <stringProp name="HTTPSampler.path">${base_path}${admin_path}/catalog/product/save/id/${configurable_product_id}/back/edit/active_tab/product-details/</stringProp>
+                  <stringProp name="HTTPSampler.method">POST</stringProp>
+                  <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
+                  <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
+                  <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
+                  <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
+                  <boolProp name="HTTPSampler.monitor">false</boolProp>
+                  <stringProp name="HTTPSampler.embedded_url_re"/>
+                </HTTPSamplerProxy>
+                <hashTree>
+                  <BeanShellPreProcessor guiclass="TestBeanGUI" testclass="BeanShellPreProcessor" testname="Configure product options" enabled="true">
+                    <boolProp name="resetInterpreter">false</boolProp>
+                    <stringProp name="parameters"/>
+                    <stringProp name="filename"/>
+                    <stringProp name="script">try {
+    	int attributesCount = Integer.parseInt(vars.get("configurable_attribute_ids_matchNr"));
+    	for (int i = 1; i &lt;= attributesCount; i++) {
+    		attributeId = vars.get("configurable_attribute_ids_" + i.toString());
+    		attributeCode = vars.get("configurable_attribute_codes_" + i.toString());
+    		attributeLabel = vars.get("configurable_attribute_labels_" + i.toString());
+    		ctx.getCurrentSampler().addArgument("attributes[" + (i - 1).toString() + "]", attributeId);
+    		ctx.getCurrentSampler().addArgument("attribute_codes[" + (i - 1).toString() + "]", attributeCode);
+    		ctx.getCurrentSampler().addArgument("product[" + attributeCode + "]", attributeId);
+    		ctx.getCurrentSampler().addArgument("product[configurable_attributes_data][" + attributeId + "][attribute_id]", attributeId);
+    		ctx.getCurrentSampler().addArgument("product[configurable_attributes_data][" + attributeId + "][position]", (i - 1).toString());
+    		ctx.getCurrentSampler().addArgument("product[configurable_attributes_data][" + attributeId + "][code]", attributeCode);
+    		ctx.getCurrentSampler().addArgument("product[configurable_attributes_data][" + attributeId + "][label]", attributeLabel);
+
+    		int valuesCount = Integer.parseInt(vars.get("attribute_" + attributeId + "_values_matchNr"));
+    		for (int j = 1; j &lt;= valuesCount; j++) {
+    			attributeValue = vars.get("attribute_" + attributeId + "_values_" + j.toString());
+    			ctx.getCurrentSampler().addArgument(
+    				"product[configurable_attributes_data][" + attributeId + "][values][" + attributeValue + "][include]",
+    				"1"
+    			);
+    			ctx.getCurrentSampler().addArgument(
+    				"product[configurable_attributes_data][" + attributeId + "][values][" + attributeValue + "][value_index]",
+    				attributeValue
+    			);
+    		}
+    	}
+    	ctx.getCurrentSampler().addArgument("associated_product_ids_serialized", vars.get("associated_products_ids").toString());
+    } catch (Exception e) {
+        log.error("error???", e);
+    }</stringProp>
+                  </BeanShellPreProcessor>
+                  <hashTree/>
+                  <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Response Assertion" enabled="true">
+                    <collectionProp name="Asserion.test_strings">
+                      <stringProp name="-583471546">You saved the product</stringProp>
+                    </collectionProp>
+                    <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
+                    <boolProp name="Assertion.assume_success">false</boolProp>
+                    <intProp name="Assertion.test_type">2</intProp>
+                    <stringProp name="TestPlan.comments"> if have trouble see messages-message-error </stringProp>
+                  </ResponseAssertion>
+        <hashTree/>
+      </hashTree>
+    </hashTree>
+  </hashTree>
+  
+    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Logout" enabled="true">
+      <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
+        <collectionProp name="Arguments.arguments"/>
+      </elementProp>
+      <stringProp name="HTTPSampler.domain"/>
+      <stringProp name="HTTPSampler.port"/>
+      <stringProp name="HTTPSampler.connect_timeout"/>
+      <stringProp name="HTTPSampler.response_timeout"/>
+      <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
+      <stringProp name="HTTPSampler.contentEncoding"/>
+      <stringProp name="HTTPSampler.path">${base_path}${admin_path}/admin/auth/logout/</stringProp>
+      <stringProp name="HTTPSampler.method">GET</stringProp>
+      <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
+      <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
+      <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
+      <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
+      <boolProp name="HTTPSampler.monitor">false</boolProp>
+      <stringProp name="HTTPSampler.embedded_url_re"/>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/setup/admin_logout.jmx</stringProp></HTTPSamplerProxy>
+    <hashTree>
+    
+    <BeanShellPostProcessor guiclass="TestBeanGUI" testclass="BeanShellPostProcessor" testname="Return Admin to Pool" enabled="true">
+        <boolProp name="resetInterpreter">false</boolProp>
+        <stringProp name="parameters"/>
+        <stringProp name="filename"/>
+        <stringProp name="script">
+adminUserList = props.get("adminUserList");
+adminUserList.add(vars.get("admin_user"));
+        </stringProp>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/common/return_admin_email_to_pool.jmx</stringProp></BeanShellPostProcessor>
+    <hashTree/>
+  </hashTree>
+  </hashTree>
+
+  
+    <ThroughputController guiclass="ThroughputControllerGui" testclass="ThroughputController" testname="Admin Category Management" enabled="true">
+      <intProp name="ThroughputController.style">1</intProp>
+      <boolProp name="ThroughputController.perThread">false</boolProp>
+      <intProp name="ThroughputController.maxThroughput">1</intProp>
+      <stringProp name="ThroughputController.percentThroughput">${adminCategoryManagementPercentage}</stringProp>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/_system/scenario_controller_tmpl.jmx</stringProp></ThroughputController>
+    <hashTree>
+        <JSR223PreProcessor guiclass="TestBeanGUI" testclass="JSR223PreProcessor" testname="Set Test Label" enabled="true">
+            <stringProp name="script">
+var testLabel = "${testLabel}" ? " (${testLabel})" : "";
+if (testLabel
+    &amp;&amp; sampler.getClass().getName() == 'org.apache.jmeter.protocol.http.sampler.HTTPSamplerProxy'
+) {
+    if (sampler.getName().indexOf(testLabel) == -1) {
+       sampler.setName(sampler.getName() + testLabel);
+    }
+} else if (sampler.getName().indexOf("SetUp - ") == -1) {
+    sampler.setName("SetUp - " + sampler.getName());
+}
+            </stringProp>
+            <stringProp name="scriptLanguage">javascript</stringProp>
+        <stringProp name="TestPlan.comments">mpaf/tool/fragments/_system/setup_label.jmx</stringProp></JSR223PreProcessor>
+        <hashTree/>
+        <BeanShellSampler guiclass="BeanShellSamplerGui" testclass="BeanShellSampler" testname="SetUp - Set Label" enabled="true">
+            <stringProp name="BeanShellSampler.query">
+                vars.put("testLabel", "Admin Category Management");
+            </stringProp>
+            <boolProp name="BeanShellSampler.resetInterpreter">true</boolProp>
+        </BeanShellSampler>
+        <hashTree/>
+    
+        <JSR223PostProcessor guiclass="TestBeanGUI" testclass="JSR223PostProcessor" testname="Get admin form key PostProcessor" enabled="true">
+        <stringProp name="script">
+        function getFormKeyFromResponse()
+        {
+            var url = prev.getUrlAsString(),
+            responseCode =  prev.getResponseCode(),
+            formKey = null;
+            searchPattern = /var FORM_KEY = '(.+)'/;
+            if (responseCode == "200" &amp;&amp; url) {
+                response = prev.getResponseDataAsString();
+                formKey = response  &amp;&amp; response.match(searchPattern) ? response.match(searchPattern)[1] : null;
+            }
+            return formKey;
+        }
+
+        formKey = vars.get("form_key_storage");
+
+	   currentFormKey = getFormKeyFromResponse();
+
+	   if (currentFormKey != null &amp;&amp; currentFormKey != formKey) {
+		  vars.put("form_key_storage", currentFormKey);
+	   }
+        </stringProp>
+        <stringProp name="scriptLanguage">javascript</stringProp>
+        <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin/handle_admin_form_key.jmx</stringProp></JSR223PostProcessor>
+        <hashTree/>
+        <JSR223PreProcessor guiclass="TestBeanGUI" testclass="JSR223PreProcessor" testname="Set admin form key PreProcessor" enabled="true">
+            <stringProp name="script">
+                formKey =  vars.get("form_key_storage");
+                if (formKey
+                    &amp;&amp; sampler.getClass().getName() == 'org.apache.jmeter.protocol.http.sampler.HTTPSamplerProxy'
+                    &amp;&amp; sampler.getMethod() == "POST")
+                    {
+                        arguments = sampler.getArguments();
+                        for (i=0; i&lt;arguments.getArgumentCount(); i++)
+                        {
+                            argument = arguments.getArgument(i);
+                            if (argument.getName() == 'form_key' &amp;&amp; argument.getValue() != formKey) {
+                            log.info("admin form key updated: " + argument.getValue() + " =&gt; " + formKey);
+                            argument.setValue(formKey);
+                        }
+                    }
+                }
+            </stringProp>
+            <stringProp name="scriptLanguage">javascript</stringProp>
+        </JSR223PreProcessor>
+        <hashTree/>
+    
+    <CookieManager guiclass="CookiePanel" testclass="CookieManager" testname="HTTP Cookie Manager" enabled="true">
+      <collectionProp name="CookieManager.cookies"/>
+      <boolProp name="CookieManager.clearEachIteration">false</boolProp>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/http_cookie_manager_without_clear_each_iteration.jmx</stringProp></CookieManager>
+    <hashTree/>
+  
+    <GenericController guiclass="LogicControllerGui" testclass="GenericController" testname="Admin Login" enabled="true">
+  <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/simple_controller.jmx</stringProp>
+</GenericController>
+    <hashTree>
+    <CriticalSectionController guiclass="CriticalSectionControllerGui" testclass="CriticalSectionController" testname="Admin Login Lock" enabled="true">
+        <stringProp name="CriticalSectionController.lockName">get-admin-email</stringProp>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/lock_controller.jmx</stringProp></CriticalSectionController>
+    <hashTree>
+    
+    <BeanShellSampler guiclass="BeanShellSamplerGui" testclass="BeanShellSampler" testname="SetUp - Get Admin Email" enabled="true">
+      <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/get_admin_email.jmx</stringProp>
+      <stringProp name="BeanShellSampler.query">
+adminUserList = props.get("adminUserList");
+adminUser = adminUserList.poll();
+if (adminUser == null) {
+  SampleResult.setResponseMessage("adminUser list is empty");
+  SampleResult.setResponseData("adminUser list is empty","UTF-8");
+  IsSuccess=false;
+  SampleResult.setSuccessful(false);
+  SampleResult.setStopThread(true);
+}
+vars.put("admin_user", adminUser);
+      </stringProp>
+      <stringProp name="BeanShellSampler.filename"/>
+      <stringProp name="BeanShellSampler.parameters"/>
+      <boolProp name="BeanShellSampler.resetInterpreter">true</boolProp>
+    </BeanShellSampler>
+    <hashTree/>
+  </hashTree>
+  
+    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="SetUp - Login" enabled="true">
+      <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
+        <collectionProp name="Arguments.arguments"/>
+      </elementProp>
+      <stringProp name="HTTPSampler.domain"/>
+      <stringProp name="HTTPSampler.port"/>
+      <stringProp name="HTTPSampler.connect_timeout"/>
+      <stringProp name="HTTPSampler.response_timeout"/>
+      <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
+      <stringProp name="HTTPSampler.contentEncoding"/>
+      <stringProp name="HTTPSampler.path">${base_path}${admin_path}</stringProp>
+      <stringProp name="HTTPSampler.method">GET</stringProp>
+      <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
+      <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
+      <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
+      <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
+      <boolProp name="HTTPSampler.monitor">false</boolProp>
+      <stringProp name="HTTPSampler.embedded_url_re"/>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_login/admin_login.jmx</stringProp></HTTPSamplerProxy>
+    <hashTree>
+      <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert login form shown" enabled="true">
+        <collectionProp name="Asserion.test_strings">
+          <stringProp name="-1397214398">Welcome</stringProp>
+          <stringProp name="-515240035">&lt;title&gt;Magento Admin&lt;/title&gt;</stringProp>
+        </collectionProp>
+        <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
+        <boolProp name="Assertion.assume_success">false</boolProp>
+        <intProp name="Assertion.test_type">2</intProp>
+      </ResponseAssertion>
+      <hashTree/>
+      <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract form key" enabled="true">
+        <stringProp name="RegexExtractor.useHeaders">false</stringProp>
+        <stringProp name="RegexExtractor.refname">admin_form_key</stringProp>
+        <stringProp name="RegexExtractor.regex">&lt;input name="form_key" type="hidden" value="([^'"]+)" /&gt;</stringProp>
+        <stringProp name="RegexExtractor.template">$1$</stringProp>
+        <stringProp name="RegexExtractor.default"/>
+        <stringProp name="RegexExtractor.match_number">1</stringProp>
+      </RegexExtractor>
+      <hashTree/>
+      <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert form_key extracted" enabled="true">
+        <collectionProp name="Asserion.test_strings">
+          <stringProp name="2845929">^.+$</stringProp>
+        </collectionProp>
+        <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
+        <boolProp name="Assertion.assume_success">false</boolProp>
+        <intProp name="Assertion.test_type">1</intProp>
+        <stringProp name="Assertion.scope">variable</stringProp>
+        <stringProp name="Scope.variable">admin_form_key</stringProp>
+      </ResponseAssertion>
+      <hashTree/>
+    </hashTree>
+  
+    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="SetUp - Login Submit Form" enabled="true">
+      <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
+        <collectionProp name="Arguments.arguments">
+          <elementProp name="dummy" elementType="HTTPArgument">
             <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.name">export_filter[url_key]</stringProp>
             <stringProp name="Argument.value"/>
             <stringProp name="Argument.metadata">=</stringProp>
             <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">dummy</stringProp>
           </elementProp>
-          <elementProp name="export_filter[url_path]" elementType="HTTPArgument">
+          <elementProp name="form_key" elementType="HTTPArgument">
             <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.name">export_filter[url_path]</stringProp>
-            <stringProp name="Argument.value"/>
+            <stringProp name="Argument.value">${admin_form_key}</stringProp>
             <stringProp name="Argument.metadata">=</stringProp>
             <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">form_key</stringProp>
           </elementProp>
-          <elementProp name="export_filter[use_config_allow_message][]" elementType="HTTPArgument">
+          <elementProp name="login[password]" elementType="HTTPArgument">
             <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.name">export_filter[use_config_allow_message][]</stringProp>
-            <stringProp name="Argument.value">,</stringProp>
+            <stringProp name="Argument.value">${admin_password}</stringProp>
             <stringProp name="Argument.metadata">=</stringProp>
             <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">login[password]</stringProp>
           </elementProp>
-          <elementProp name="export_filter[use_config_email_template][]" elementType="HTTPArgument">
+          <elementProp name="login[username]" elementType="HTTPArgument">
             <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.name">export_filter[use_config_email_template][]</stringProp>
-            <stringProp name="Argument.value">,</stringProp>
+            <stringProp name="Argument.value">${admin_user}</stringProp>
             <stringProp name="Argument.metadata">=</stringProp>
             <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">login[username]</stringProp>
           </elementProp>
-          <elementProp name="export_filter[use_config_is_redeemable][]" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.name">export_filter[use_config_is_redeemable][]</stringProp>
-            <stringProp name="Argument.value">,</stringProp>
-            <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+        </collectionProp>
+      </elementProp>
+      <stringProp name="HTTPSampler.domain"/>
+      <stringProp name="HTTPSampler.port"/>
+      <stringProp name="HTTPSampler.connect_timeout"/>
+      <stringProp name="HTTPSampler.response_timeout"/>
+      <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
+      <stringProp name="HTTPSampler.contentEncoding"/>
+      <stringProp name="HTTPSampler.path">${base_path}${admin_path}/admin/dashboard/</stringProp>
+      <stringProp name="HTTPSampler.method">POST</stringProp>
+      <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
+      <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
+      <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
+      <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
+      <stringProp name="HTTPSampler.implementation">Java</stringProp>
+      <boolProp name="HTTPSampler.monitor">false</boolProp>
+      <stringProp name="HTTPSampler.embedded_url_re"/>
+      <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_login/admin_login_submit_form.jmx</stringProp>
+    </HTTPSamplerProxy>
+    <hashTree>
+        <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract form key" enabled="true">
+            <stringProp name="RegexExtractor.useHeaders">false</stringProp>
+            <stringProp name="RegexExtractor.refname">admin_form_key</stringProp>
+            <stringProp name="RegexExtractor.regex">&lt;input name="form_key" type="hidden" value="([^'"]+)" /&gt;</stringProp>
+            <stringProp name="RegexExtractor.template">$1$</stringProp>
+            <stringProp name="RegexExtractor.default"/>
+            <stringProp name="RegexExtractor.match_number">1</stringProp>
+        <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_login/admin_retrieve_form_key.jmx</stringProp></RegexExtractor>
+        <hashTree/>
+    </hashTree>
+  </hashTree>
+  
+    <OnceOnlyController guiclass="OnceOnlyControllerGui" testclass="OnceOnlyController" testname="Once Only Controller" enabled="true">
+  <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/once_only_controller.jmx</stringProp>
+</OnceOnlyController>
+    <hashTree>
+    <GenericController guiclass="LogicControllerGui" testclass="GenericController" testname="SetUp - Admin Category Management" enabled="true">
+  <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/setup/setup_admin_category_management.jmx</stringProp>
+</GenericController>
+    <hashTree>
+      <BeanShellSampler guiclass="BeanShellSamplerGui" testclass="BeanShellSampler" testname="SetUp - BeanShell Sampler: Clear Admin Category Management properties" enabled="true">
+        <stringProp name="BeanShellSampler.query">props.remove("admin_category_ids_list");</stringProp>
+        <stringProp name="BeanShellSampler.filename"/>
+        <stringProp name="BeanShellSampler.parameters"/>
+        <boolProp name="BeanShellSampler.resetInterpreter">false</boolProp>
+      </BeanShellSampler>
+      <hashTree/>
+      <GenericController guiclass="LogicControllerGui" testclass="GenericController" testname="Get categories of last level" enabled="true"/>
+      <hashTree>
+        <HeaderManager guiclass="HeaderPanel" testclass="HeaderManager" testname="HTTP Header Manager" enabled="true">
+          <collectionProp name="HeaderManager.headers">
+            <elementProp name="" elementType="Header">
+              <stringProp name="Header.name">Content-Type</stringProp>
+              <stringProp name="Header.value">application/json</stringProp>
+            </elementProp>
+            <elementProp name="" elementType="Header">
+              <stringProp name="Header.name">Accept</stringProp>
+              <stringProp name="Header.value">*/*</stringProp>
+            </elementProp>
+          </collectionProp>
+        </HeaderManager>
+        <hashTree/>
+        <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="SetUp - Admin Token Retrieval" enabled="true">
+          <boolProp name="HTTPSampler.postBodyRaw">true</boolProp>
+          <elementProp name="HTTPsampler.Arguments" elementType="Arguments">
+            <collectionProp name="Arguments.arguments">
+              <elementProp name="" elementType="HTTPArgument">
+                <boolProp name="HTTPArgument.always_encode">false</boolProp>
+                <stringProp name="Argument.value">{"username":"${admin_user}","password":"${admin_password}"}</stringProp>
+                <stringProp name="Argument.metadata">=</stringProp>
+              </elementProp>
+            </collectionProp>
           </elementProp>
-          <elementProp name="export_filter[use_config_lifetime][]" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.name">export_filter[use_config_lifetime][]</stringProp>
-            <stringProp name="Argument.value">,</stringProp>
-            <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
+          <stringProp name="HTTPSampler.domain"/>
+          <stringProp name="HTTPSampler.port"/>
+          <stringProp name="HTTPSampler.connect_timeout"/>
+          <stringProp name="HTTPSampler.response_timeout"/>
+          <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
+          <stringProp name="HTTPSampler.contentEncoding"/>
+          <stringProp name="HTTPSampler.path">${base_path}rest/V1/integration/admin/token</stringProp>
+          <stringProp name="HTTPSampler.method">POST</stringProp>
+          <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
+          <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
+          <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
+          <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
+          <boolProp name="HTTPSampler.monitor">false</boolProp>
+          <stringProp name="HTTPSampler.embedded_url_re"/>
+        </HTTPSamplerProxy>
+        <hashTree>
+          <com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor guiclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.gui.JSONPathExtractorGui" testclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor" testname="jp@gc - JSON Path Extractor" enabled="true">
+            <stringProp name="VAR">admin_token</stringProp>
+            <stringProp name="JSONPATH">$</stringProp>
+            <stringProp name="DEFAULT"/>
+            <stringProp name="VARIABLE"/>
+            <stringProp name="SUBJECT">BODY</stringProp>
+          </com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor>
+          <hashTree/>
+          <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert token not null" enabled="true">
+            <collectionProp name="Asserion.test_strings">
+              <stringProp name="484395188">^[a-z0-9-]+$</stringProp>
+            </collectionProp>
+            <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
+            <boolProp name="Assertion.assume_success">false</boolProp>
+            <intProp name="Assertion.test_type">1</intProp>
+            <stringProp name="Assertion.scope">variable</stringProp>
+            <stringProp name="Scope.variable">admin_token</stringProp>
+          </ResponseAssertion>
+          <hashTree/>
+        </hashTree>
+        <HeaderManager guiclass="HeaderPanel" testclass="HeaderManager" testname="HTTP Header Manager" enabled="true">
+          <collectionProp name="HeaderManager.headers">
+            <elementProp name="" elementType="Header">
+              <stringProp name="Header.name">Authorization</stringProp>
+              <stringProp name="Header.value">Bearer ${admin_token}</stringProp>
+            </elementProp>
+          </collectionProp>
+        </HeaderManager>
+        <hashTree/>
+        <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="SetUp - API Get categories" enabled="true">
+          <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
+            <collectionProp name="Arguments.arguments">
+              <elementProp name="searchCriteria[filterGroups][0][filters][0][field]" elementType="HTTPArgument">
+                <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                <stringProp name="Argument.value">children_count</stringProp>
+                <stringProp name="Argument.metadata">=</stringProp>
+                <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                <stringProp name="Argument.name">searchCriteria[filterGroups][0][filters][0][field]</stringProp>
+              </elementProp>
+              <elementProp name="searchCriteria[filterGroups][0][filters][0][value]" elementType="HTTPArgument">
+                <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                <stringProp name="Argument.value">0</stringProp>
+                <stringProp name="Argument.metadata">=</stringProp>
+                <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                <stringProp name="Argument.name">searchCriteria[filterGroups][0][filters][0][value]</stringProp>
+              </elementProp>
+              <elementProp name="searchCriteria[filterGroups][1][filters][0][field]" elementType="HTTPArgument">
+                <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                <stringProp name="Argument.value">level</stringProp>
+                <stringProp name="Argument.metadata">=</stringProp>
+                <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                <stringProp name="Argument.name">searchCriteria[filterGroups][1][filters][0][field]</stringProp>
+              </elementProp>
+              <elementProp name="searchCriteria[filterGroups][1][filters][0][value]" elementType="HTTPArgument">
+                <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                <stringProp name="Argument.value">2</stringProp>
+                <stringProp name="Argument.metadata">=</stringProp>
+                <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                <stringProp name="Argument.name">searchCriteria[filterGroups][1][filters][0][value]</stringProp>
+              </elementProp>
+              <elementProp name="searchCriteria[filterGroups][1][filters][0][conditionType]" elementType="HTTPArgument">
+                <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                <stringProp name="Argument.value">gt</stringProp>
+                <stringProp name="Argument.metadata">=</stringProp>
+                <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                <stringProp name="Argument.name">searchCriteria[filterGroups][1][filters][0][conditionType]</stringProp>
+              </elementProp>
+              <elementProp name="searchCriteria[pageSize]" elementType="HTTPArgument">
+                <boolProp name="HTTPArgument.always_encode">true</boolProp>
+                <stringProp name="Argument.value">${adminCategoryCount}</stringProp>
+                <stringProp name="Argument.metadata">=</stringProp>
+                <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                <stringProp name="Argument.name">searchCriteria[pageSize]</stringProp>
+              </elementProp>
+            </collectionProp>
           </elementProp>
-          <elementProp name="export_filter[visibility]" elementType="HTTPArgument">
+          <stringProp name="HTTPSampler.domain"/>
+          <stringProp name="HTTPSampler.port"/>
+          <stringProp name="HTTPSampler.connect_timeout"/>
+          <stringProp name="HTTPSampler.response_timeout"/>
+          <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
+          <stringProp name="HTTPSampler.contentEncoding"/>
+          <stringProp name="HTTPSampler.path">${base_path}rest/default/V1/categories/list</stringProp>
+          <stringProp name="HTTPSampler.method">GET</stringProp>
+          <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
+          <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
+          <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
+          <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
+          <boolProp name="HTTPSampler.monitor">false</boolProp>
+          <stringProp name="HTTPSampler.embedded_url_re"/>
+        </HTTPSamplerProxy>
+        <hashTree>
+          <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Regular Expression Extractor" enabled="true">
+            <stringProp name="RegexExtractor.useHeaders">false</stringProp>
+            <stringProp name="RegexExtractor.refname">category_list_id</stringProp>
+            <stringProp name="RegexExtractor.regex">\{\"id\":(\d+),</stringProp>
+            <stringProp name="RegexExtractor.template">$1$</stringProp>
+            <stringProp name="RegexExtractor.default"/>
+            <stringProp name="RegexExtractor.match_number">-1</stringProp>
+          </RegexExtractor>
+          <hashTree/>
+        </hashTree>
+        <ForeachController guiclass="ForeachControlPanel" testclass="ForeachController" testname="ForEach Category Id" enabled="true">
+          <stringProp name="ForeachController.inputVal">category_list_id</stringProp>
+          <stringProp name="ForeachController.returnVal">category_id</stringProp>
+          <boolProp name="ForeachController.useSeparator">true</boolProp>
+        </ForeachController>
+        <hashTree>
+          <BeanShellSampler guiclass="BeanShellSamplerGui" testclass="BeanShellSampler" testname="Process categories ids" enabled="true">
+            <stringProp name="BeanShellSampler.query">import java.util.ArrayList;
+
+adminCategoryIdsList = props.get("admin_category_ids_list");
+// If it is first iteration of cycle then recreate categories ids list
+if (adminCategoryIdsList == null) {
+    adminCategoryIdsList = new ArrayList();
+    props.put("admin_category_ids_list", adminCategoryIdsList);
+}
+adminCategoryIdsList.add(vars.get("category_id"));</stringProp>
+            <stringProp name="BeanShellSampler.filename"/>
+            <stringProp name="BeanShellSampler.parameters"/>
+            <boolProp name="BeanShellSampler.resetInterpreter">false</boolProp>
+          </BeanShellSampler>
+          <hashTree/>
+        </hashTree>
+      </hashTree>
+    </hashTree>
+  </hashTree>
+  
+    <GenericController guiclass="LogicControllerGui" testclass="GenericController" testname="Simple Controller" enabled="true">
+  <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/simple_controller.jmx</stringProp>
+</GenericController>
+    <hashTree>
+    <TestFragmentController guiclass="TestFragmentControllerGui" testclass="TestFragmentController" testname="Admin Category Management" enabled="true">
+  <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_category_management/admin_category_management.jmx</stringProp>
+</TestFragmentController>
+    <hashTree>
+         <JSR223Sampler guiclass="TestBeanGUI" testclass="JSR223Sampler" testname="SetUp - Set Arguments" enabled="true">
+      <stringProp name="scriptLanguage">javascript</stringProp>
+      <stringProp name="parameters"/>
+      <stringProp name="filename"/>
+      <stringProp name="cacheKey"/>
+      <stringProp name="script">random = new java.util.Random();
+if (${seedForRandom} &gt; 0) {
+random.setSeed(${seedForRandom} + ${__threadNum});
+}
+
+/**
+ * Get unique ids for fix concurrent category saving
+ */
+function getNextProductNumber(i) {
+    number = productsVariationsSize * ${__threadNum} - i;
+    if (number &gt;= productsSize) {
+        log.info("${testLabel}: capacity of product list is not enough for support all ${adminPoolUsers} threads");
+        return random.nextInt(productsSize);
+    }
+    return productsVariationsSize * ${__threadNum} - i;
+}
+
+var productsVariationsSize = 5,
+    productsSize = props.get("simple_products_list").size();
+
+
+for (i = 1; i&lt;= productsVariationsSize; i++) {
+    var productVariablePrefix = "simple_product_" + i + "_";
+    number = getNextProductNumber(i);
+    simpleList = props.get("simple_products_list").get(number);
+
+    vars.put(productVariablePrefix + "url_key", simpleList.get("url_key"));
+    vars.put(productVariablePrefix + "id", simpleList.get("id"));
+    vars.put(productVariablePrefix + "name", simpleList.get("title"));
+}
+
+categoryIndex = random.nextInt(props.get("admin_category_ids_list").size());
+vars.put("parent_category_id", props.get("admin_category_ids_list").get(categoryIndex));
+do {
+categoryIndexNew = random.nextInt(props.get("admin_category_ids_list").size());
+} while(categoryIndex == categoryIndexNew);
+vars.put("new_parent_category_id", props.get("admin_category_ids_list").get(categoryIndexNew));</stringProp>
+    </JSR223Sampler>
+      <hashTree/>
+      <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Landing Page" enabled="true">
+        <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
+          <collectionProp name="Arguments.arguments"/>
+        </elementProp>
+        <stringProp name="HTTPSampler.domain"/>
+        <stringProp name="HTTPSampler.port"/>
+        <stringProp name="HTTPSampler.connect_timeout"/>
+        <stringProp name="HTTPSampler.response_timeout"/>
+        <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
+        <stringProp name="HTTPSampler.contentEncoding"/>
+        <stringProp name="HTTPSampler.path">${base_path}${admin_path}/catalog/category/</stringProp>
+        <stringProp name="HTTPSampler.method">GET</stringProp>
+        <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
+        <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
+        <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
+        <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
+        <boolProp name="HTTPSampler.monitor">false</boolProp>
+        <stringProp name="HTTPSampler.embedded_url_re"/>
+      </HTTPSamplerProxy>
+      <hashTree>
+        <HeaderManager guiclass="HeaderPanel" testclass="HeaderManager" testname="HTTP Header Manager" enabled="true">
+          <collectionProp name="HeaderManager.headers">
+            <elementProp name="Accept-Language" elementType="Header">
+              <stringProp name="Header.name">Accept-Language</stringProp>
+              <stringProp name="Header.value">en-US,en;q=0.5</stringProp>
+            </elementProp>
+            <elementProp name="Accept" elementType="Header">
+              <stringProp name="Header.name">Accept</stringProp>
+              <stringProp name="Header.value">text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8</stringProp>
+            </elementProp>
+            <elementProp name="User-Agent" elementType="Header">
+              <stringProp name="Header.name">User-Agent</stringProp>
+              <stringProp name="Header.value">Mozilla/5.0 (Windows NT 6.1; WOW64; rv:27.0) Gecko/20100101 Firefox/27.0</stringProp>
+            </elementProp>
+            <elementProp name="Accept-Encoding" elementType="Header">
+              <stringProp name="Header.name">Accept-Encoding</stringProp>
+              <stringProp name="Header.value">gzip, deflate</stringProp>
+            </elementProp>
+          </collectionProp>
+        </HeaderManager>
+        <hashTree/>
+        <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract form key" enabled="true">
+          <stringProp name="RegexExtractor.useHeaders">false</stringProp>
+          <stringProp name="RegexExtractor.refname">admin_form_key</stringProp>
+          <stringProp name="RegexExtractor.regex">&lt;input name="form_key" type="hidden" value="([^'"]+)" /&gt;</stringProp>
+          <stringProp name="RegexExtractor.template">$1$</stringProp>
+          <stringProp name="RegexExtractor.default"/>
+          <stringProp name="RegexExtractor.match_number">1</stringProp>
+        </RegexExtractor>
+        <hashTree/>
+      </hashTree>
+      <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Select parent category" enabled="true">
+        <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
+          <collectionProp name="Arguments.arguments"/>
+        </elementProp>
+        <stringProp name="HTTPSampler.domain"/>
+        <stringProp name="HTTPSampler.port"/>
+        <stringProp name="HTTPSampler.connect_timeout"/>
+        <stringProp name="HTTPSampler.response_timeout"/>
+        <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
+        <stringProp name="HTTPSampler.contentEncoding"/>
+        <stringProp name="HTTPSampler.path">${base_path}${admin_path}/catalog/category/edit/id/${parent_category_id}/</stringProp>
+        <stringProp name="HTTPSampler.method">GET</stringProp>
+        <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
+        <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
+        <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
+        <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
+        <boolProp name="HTTPSampler.monitor">false</boolProp>
+        <stringProp name="HTTPSampler.embedded_url_re"/>
+      </HTTPSamplerProxy>
+      <hashTree>
+        <HeaderManager guiclass="HeaderPanel" testclass="HeaderManager" testname="HTTP Header Manager" enabled="true">
+          <collectionProp name="HeaderManager.headers">
+            <elementProp name="Accept-Language" elementType="Header">
+              <stringProp name="Header.name">Accept-Language</stringProp>
+              <stringProp name="Header.value">en-US,en;q=0.5</stringProp>
+            </elementProp>
+            <elementProp name="Accept" elementType="Header">
+              <stringProp name="Header.name">Accept</stringProp>
+              <stringProp name="Header.value">text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8</stringProp>
+            </elementProp>
+            <elementProp name="User-Agent" elementType="Header">
+              <stringProp name="Header.name">User-Agent</stringProp>
+              <stringProp name="Header.value">Mozilla/5.0 (Windows NT 6.1; WOW64; rv:27.0) Gecko/20100101 Firefox/27.0</stringProp>
+            </elementProp>
+            <elementProp name="Accept-Encoding" elementType="Header">
+              <stringProp name="Header.name">Accept-Encoding</stringProp>
+              <stringProp name="Header.value">gzip, deflate</stringProp>
+            </elementProp>
+          </collectionProp>
+        </HeaderManager>
+        <hashTree/>
+      </hashTree>
+      <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Open new category page" enabled="true">
+        <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
+          <collectionProp name="Arguments.arguments"/>
+        </elementProp>
+        <stringProp name="HTTPSampler.domain"/>
+        <stringProp name="HTTPSampler.port"/>
+        <stringProp name="HTTPSampler.connect_timeout"/>
+        <stringProp name="HTTPSampler.response_timeout"/>
+        <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
+        <stringProp name="HTTPSampler.contentEncoding"/>
+        <stringProp name="HTTPSampler.path">${base_path}${admin_path}/catalog/category/add/store/0/parent/${parent_category_id}</stringProp>
+        <stringProp name="HTTPSampler.method">GET</stringProp>
+        <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
+        <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
+        <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
+        <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
+        <boolProp name="HTTPSampler.monitor">false</boolProp>
+        <stringProp name="HTTPSampler.embedded_url_re"/>
+      </HTTPSamplerProxy>
+      <hashTree>
+        <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Response Assertion" enabled="true">
+          <collectionProp name="Asserion.test_strings">
+            <stringProp name="-1903925024">&lt;title&gt;New Category</stringProp>
+          </collectionProp>
+          <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
+          <boolProp name="Assertion.assume_success">false</boolProp>
+          <intProp name="Assertion.test_type">2</intProp>
+        </ResponseAssertion>
+        <hashTree/>
+      </hashTree>
+      <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Create category" enabled="true">
+        <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
+          <collectionProp name="Arguments.arguments">
+            <elementProp name="id" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value"/>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">id</stringProp>
+            </elementProp>
+            <elementProp name="parent" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">${parent_category_id}</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">parent</stringProp>
+            </elementProp>
+            <elementProp name="path" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value"/>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">path</stringProp>
+            </elementProp>
+            <elementProp name="store_id" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value"/>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">store_id</stringProp>
+            </elementProp>
+            <elementProp name="is_active" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">0</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">is_active</stringProp>
+            </elementProp>
+            <elementProp name="include_in_menu" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">0</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">include_in_menu</stringProp>
+            </elementProp>
+            <elementProp name="is_anchor" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">1</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">is_anchor</stringProp>
+            </elementProp>
+            <elementProp name="use_config[available_sort_by]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">true</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">use_config[available_sort_by]</stringProp>
+            </elementProp>
+            <elementProp name="use_config[default_sort_by]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">true</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">use_config[default_sort_by]</stringProp>
+            </elementProp>
+            <elementProp name="use_config[filter_price_range]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">true</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">use_config[filter_price_range]</stringProp>
+            </elementProp>
+            <elementProp name="use_default[url_key]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">false</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">use_default[url_key]</stringProp>
+            </elementProp>
+            <elementProp name="url_key_create_redirect" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">0</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">url_key_create_redirect</stringProp>
+            </elementProp>
+            <elementProp name="custom_use_parent_settings" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">0</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">custom_use_parent_settings</stringProp>
+            </elementProp>
+            <elementProp name="custom_apply_to_products" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">0</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">custom_apply_to_products</stringProp>
+            </elementProp>
+            <elementProp name="name" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">Admin Category Management ${__time(YMDHMS)}-${__threadNum}-${__Random(1,1000000)}</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">name</stringProp>
+            </elementProp>
+            <elementProp name="url_key" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">admin-category-management-${__time(YMDHMS)}-${__threadNum}-${__Random(1,1000000)}</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">url_key</stringProp>
+            </elementProp>
+            <elementProp name="meta_title" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value"/>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">meta_title</stringProp>
+            </elementProp>
+            <elementProp name="description" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value"/>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">description</stringProp>
+            </elementProp>
+            <elementProp name="display_mode" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">PRODUCTS</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">display_mode</stringProp>
+            </elementProp>
+            <elementProp name="default_sort_by" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">position</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">default_sort_by</stringProp>
+            </elementProp>
+            <elementProp name="meta_keywords" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value"/>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">meta_keywords</stringProp>
+            </elementProp>
+            <elementProp name="meta_description" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value"/>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">meta_description</stringProp>
+            </elementProp>
+            <elementProp name="custom_layout_update" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value"/>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">custom_layout_update</stringProp>
+            </elementProp>
+            <elementProp name="category_products" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">false</boolProp>
+              <stringProp name="Argument.value">{"${simple_product_1_id}":"","${simple_product_2_id}":"","${simple_product_3_id}":"","${simple_product_4_id}":"","${simple_product_5_id}":""}</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">category_products</stringProp>
+            </elementProp>
+            <elementProp name="form_key" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">${admin_form_key}</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">form_key</stringProp>
+            </elementProp>
+          </collectionProp>
+        </elementProp>
+        <stringProp name="HTTPSampler.domain"/>
+        <stringProp name="HTTPSampler.port"/>
+        <stringProp name="HTTPSampler.connect_timeout"/>
+        <stringProp name="HTTPSampler.response_timeout"/>
+        <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
+        <stringProp name="HTTPSampler.contentEncoding"/>
+        <stringProp name="HTTPSampler.path">${base_path}${admin_path}/catalog/category/save/</stringProp>
+        <stringProp name="HTTPSampler.method">POST</stringProp>
+        <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
+        <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
+        <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
+        <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
+        <boolProp name="HTTPSampler.monitor">false</boolProp>
+        <stringProp name="HTTPSampler.embedded_url_re"/>
+      </HTTPSamplerProxy>
+      <hashTree>
+        <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract category id" enabled="true">
+          <stringProp name="RegexExtractor.useHeaders">URL</stringProp>
+          <stringProp name="RegexExtractor.refname">admin_category_id</stringProp>
+          <stringProp name="RegexExtractor.regex">/catalog/category/edit/id/(\d+)/</stringProp>
+          <stringProp name="RegexExtractor.template">$1$</stringProp>
+          <stringProp name="RegexExtractor.default"/>
+          <stringProp name="RegexExtractor.match_number">1</stringProp>
+        </RegexExtractor>
+        <hashTree/>
+        <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert category id" enabled="true">
+          <collectionProp name="Asserion.test_strings">
+            <stringProp name="89649215">^\d+$</stringProp>
+          </collectionProp>
+          <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
+          <boolProp name="Assertion.assume_success">false</boolProp>
+          <intProp name="Assertion.test_type">1</intProp>
+          <stringProp name="Assertion.scope">variable</stringProp>
+          <stringProp name="Scope.variable">admin_category_id</stringProp>
+        </ResponseAssertion>
+        <hashTree/>
+      </hashTree>
+      <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Select created category" enabled="true">
+        <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
+          <collectionProp name="Arguments.arguments"/>
+        </elementProp>
+        <stringProp name="HTTPSampler.domain"/>
+        <stringProp name="HTTPSampler.port"/>
+        <stringProp name="HTTPSampler.connect_timeout"/>
+        <stringProp name="HTTPSampler.response_timeout"/>
+        <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
+        <stringProp name="HTTPSampler.contentEncoding"/>
+        <stringProp name="HTTPSampler.path">${base_path}${admin_path}/catalog/category/edit/id/${admin_category_id}/</stringProp>
+        <stringProp name="HTTPSampler.method">GET</stringProp>
+        <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
+        <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
+        <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
+        <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
+        <boolProp name="HTTPSampler.monitor">false</boolProp>
+        <stringProp name="HTTPSampler.embedded_url_re"/>
+      </HTTPSamplerProxy>
+      <hashTree>
+        <HeaderManager guiclass="HeaderPanel" testclass="HeaderManager" testname="HTTP Header Manager" enabled="true">
+          <collectionProp name="HeaderManager.headers">
+            <elementProp name="Accept-Language" elementType="Header">
+              <stringProp name="Header.name">Accept-Language</stringProp>
+              <stringProp name="Header.value">en-US,en;q=0.5</stringProp>
+            </elementProp>
+            <elementProp name="Accept" elementType="Header">
+              <stringProp name="Header.name">Accept</stringProp>
+              <stringProp name="Header.value">text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8</stringProp>
+            </elementProp>
+            <elementProp name="User-Agent" elementType="Header">
+              <stringProp name="Header.name">User-Agent</stringProp>
+              <stringProp name="Header.value">Mozilla/5.0 (Windows NT 6.1; WOW64; rv:27.0) Gecko/20100101 Firefox/27.0</stringProp>
+            </elementProp>
+            <elementProp name="Accept-Encoding" elementType="Header">
+              <stringProp name="Header.name">Accept-Encoding</stringProp>
+              <stringProp name="Header.value">gzip, deflate</stringProp>
+            </elementProp>
+          </collectionProp>
+        </HeaderManager>
+        <hashTree/>
+        <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract category row id" enabled="true">
+          <stringProp name="RegexExtractor.useHeaders">false</stringProp>
+          <stringProp name="RegexExtractor.refname">admin_category_entity_id</stringProp>
+          <stringProp name="RegexExtractor.regex">"entity_id":"([^"]+)"</stringProp>
+          <stringProp name="RegexExtractor.template">$1$</stringProp>
+          <stringProp name="RegexExtractor.default"/>
+          <stringProp name="RegexExtractor.match_number">1</stringProp>
+        </RegexExtractor>
+        <hashTree/>
+        <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract category attribute set id" enabled="true">
+          <stringProp name="RegexExtractor.useHeaders">false</stringProp>
+          <stringProp name="RegexExtractor.refname">admin_category_attribute_set_id</stringProp>
+          <stringProp name="RegexExtractor.regex">"attribute_set_id":"([^"]+)"</stringProp>
+          <stringProp name="RegexExtractor.template">$1$</stringProp>
+          <stringProp name="RegexExtractor.default"/>
+          <stringProp name="RegexExtractor.match_number">1</stringProp>
+        </RegexExtractor>
+        <hashTree/>
+        <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract category parent Id" enabled="true">
+          <stringProp name="RegexExtractor.useHeaders">false</stringProp>
+          <stringProp name="RegexExtractor.refname">admin_category_parent_id</stringProp>
+          <stringProp name="RegexExtractor.regex">"parent_id":"([^"]+)"</stringProp>
+          <stringProp name="RegexExtractor.template">$1$</stringProp>
+          <stringProp name="RegexExtractor.default"/>
+          <stringProp name="RegexExtractor.match_number">1</stringProp>
+        </RegexExtractor>
+        <hashTree/>
+        <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract category created at" enabled="true">
+          <stringProp name="RegexExtractor.useHeaders">false</stringProp>
+          <stringProp name="RegexExtractor.refname">admin_category_created_at</stringProp>
+          <stringProp name="RegexExtractor.regex">"created_at":"([^"]+)"</stringProp>
+          <stringProp name="RegexExtractor.template">$1$</stringProp>
+          <stringProp name="RegexExtractor.default"/>
+          <stringProp name="RegexExtractor.match_number">1</stringProp>
+        </RegexExtractor>
+        <hashTree/>
+        <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract category updated at" enabled="true">
+          <stringProp name="RegexExtractor.useHeaders">false</stringProp>
+          <stringProp name="RegexExtractor.refname">admin_category_updated_at</stringProp>
+          <stringProp name="RegexExtractor.regex">"updated_at":"([^"]+)"</stringProp>
+          <stringProp name="RegexExtractor.template">$1$</stringProp>
+          <stringProp name="RegexExtractor.default"/>
+          <stringProp name="RegexExtractor.match_number">1</stringProp>
+        </RegexExtractor>
+        <hashTree/>
+        <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract category path" enabled="true">
+          <stringProp name="RegexExtractor.useHeaders">false</stringProp>
+          <stringProp name="RegexExtractor.refname">admin_category_path</stringProp>
+          <stringProp name="RegexExtractor.regex">"entity_id":(.+)"path":"([^\"]+)"</stringProp>
+          <stringProp name="RegexExtractor.template">$2$</stringProp>
+          <stringProp name="RegexExtractor.default"/>
+          <stringProp name="RegexExtractor.match_number">1</stringProp>
+        </RegexExtractor>
+        <hashTree/>
+        <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract category level" enabled="true">
+          <stringProp name="RegexExtractor.useHeaders">false</stringProp>
+          <stringProp name="RegexExtractor.refname">admin_category_level</stringProp>
+          <stringProp name="RegexExtractor.regex">"level":"([^"]+)"</stringProp>
+          <stringProp name="RegexExtractor.template">$1$</stringProp>
+          <stringProp name="RegexExtractor.default"/>
+          <stringProp name="RegexExtractor.match_number">1</stringProp>
+        </RegexExtractor>
+        <hashTree/>
+        <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract category name" enabled="true">
+          <stringProp name="RegexExtractor.useHeaders">false</stringProp>
+          <stringProp name="RegexExtractor.refname">admin_category_name</stringProp>
+          <stringProp name="RegexExtractor.regex">"entity_id":(.+)"name":"([^"]+)"</stringProp>
+          <stringProp name="RegexExtractor.template">$2$</stringProp>
+          <stringProp name="RegexExtractor.default"/>
+          <stringProp name="RegexExtractor.match_number">1</stringProp>
+        </RegexExtractor>
+        <hashTree/>
+        <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract category url key" enabled="true">
+          <stringProp name="RegexExtractor.useHeaders">false</stringProp>
+          <stringProp name="RegexExtractor.refname">admin_category_url_key</stringProp>
+          <stringProp name="RegexExtractor.regex">"url_key":"([^"]+)"</stringProp>
+          <stringProp name="RegexExtractor.template">$1$</stringProp>
+          <stringProp name="RegexExtractor.default"/>
+          <stringProp name="RegexExtractor.match_number">1</stringProp>
+        </RegexExtractor>
+        <hashTree/>
+        <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract category url path" enabled="true">
+          <stringProp name="RegexExtractor.useHeaders">false</stringProp>
+          <stringProp name="RegexExtractor.refname">admin_category_url_path</stringProp>
+          <stringProp name="RegexExtractor.regex">"url_path":"([^"]+)"</stringProp>
+          <stringProp name="RegexExtractor.template">$1$</stringProp>
+          <stringProp name="RegexExtractor.default"/>
+          <stringProp name="RegexExtractor.match_number">1</stringProp>
+        </RegexExtractor>
+        <hashTree/>
+        <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert category row id" enabled="true">
+          <collectionProp name="Asserion.test_strings">
+            <stringProp name="89649215">^\d+$</stringProp>
+          </collectionProp>
+          <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
+          <boolProp name="Assertion.assume_success">false</boolProp>
+          <intProp name="Assertion.test_type">1</intProp>
+          <stringProp name="Assertion.scope">variable</stringProp>
+          <stringProp name="Scope.variable">admin_category_entity_id</stringProp>
+        </ResponseAssertion>
+        <hashTree/>
+        <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert category attribute set id" enabled="true">
+          <collectionProp name="Asserion.test_strings">
+            <stringProp name="89649215">^\d+$</stringProp>
+          </collectionProp>
+          <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
+          <boolProp name="Assertion.assume_success">false</boolProp>
+          <intProp name="Assertion.test_type">1</intProp>
+          <stringProp name="Assertion.scope">variable</stringProp>
+          <stringProp name="Scope.variable">admin_category_attribute_set_id</stringProp>
+        </ResponseAssertion>
+        <hashTree/>
+        <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert category parent id" enabled="true">
+          <collectionProp name="Asserion.test_strings">
+            <stringProp name="89649215">^\d+$</stringProp>
+          </collectionProp>
+          <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
+          <boolProp name="Assertion.assume_success">false</boolProp>
+          <intProp name="Assertion.test_type">1</intProp>
+          <stringProp name="Assertion.scope">variable</stringProp>
+          <stringProp name="Scope.variable">admin_category_parent_id</stringProp>
+        </ResponseAssertion>
+        <hashTree/>
+        <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert category created at" enabled="true">
+          <collectionProp name="Asserion.test_strings">
+            <stringProp name="2845929">^.+$</stringProp>
+          </collectionProp>
+          <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
+          <boolProp name="Assertion.assume_success">false</boolProp>
+          <intProp name="Assertion.test_type">1</intProp>
+          <stringProp name="Assertion.scope">variable</stringProp>
+          <stringProp name="Scope.variable">admin_category_created_at</stringProp>
+        </ResponseAssertion>
+        <hashTree/>
+        <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert category updated at" enabled="true">
+          <collectionProp name="Asserion.test_strings">
+            <stringProp name="2845929">^.+$</stringProp>
+          </collectionProp>
+          <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
+          <boolProp name="Assertion.assume_success">false</boolProp>
+          <intProp name="Assertion.test_type">1</intProp>
+          <stringProp name="Assertion.scope">variable</stringProp>
+          <stringProp name="Scope.variable">admin_category_updated_at</stringProp>
+        </ResponseAssertion>
+        <hashTree/>
+        <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert category path" enabled="true">
+          <collectionProp name="Asserion.test_strings">
+            <stringProp name="59022110">^[\d\\\/]+$</stringProp>
+          </collectionProp>
+          <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
+          <boolProp name="Assertion.assume_success">false</boolProp>
+          <intProp name="Assertion.test_type">1</intProp>
+          <stringProp name="Assertion.scope">variable</stringProp>
+          <stringProp name="Scope.variable">admin_category_path</stringProp>
+        </ResponseAssertion>
+        <hashTree/>
+        <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert category level" enabled="true">
+          <collectionProp name="Asserion.test_strings">
+            <stringProp name="89649215">^\d+$</stringProp>
+          </collectionProp>
+          <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
+          <boolProp name="Assertion.assume_success">false</boolProp>
+          <intProp name="Assertion.test_type">1</intProp>
+          <stringProp name="Assertion.scope">variable</stringProp>
+          <stringProp name="Scope.variable">admin_category_level</stringProp>
+        </ResponseAssertion>
+        <hashTree/>
+        <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert category name" enabled="true">
+          <collectionProp name="Asserion.test_strings">
+            <stringProp name="2845929">^.+$</stringProp>
+          </collectionProp>
+          <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
+          <boolProp name="Assertion.assume_success">false</boolProp>
+          <intProp name="Assertion.test_type">1</intProp>
+          <stringProp name="Assertion.scope">variable</stringProp>
+          <stringProp name="Scope.variable">admin_category_name</stringProp>
+        </ResponseAssertion>
+        <hashTree/>
+        <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert category url key" enabled="true">
+          <collectionProp name="Asserion.test_strings">
+            <stringProp name="2845929">^.+$</stringProp>
+          </collectionProp>
+          <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
+          <boolProp name="Assertion.assume_success">false</boolProp>
+          <intProp name="Assertion.test_type">1</intProp>
+          <stringProp name="Assertion.scope">variable</stringProp>
+          <stringProp name="Scope.variable">admin_category_url_key</stringProp>
+        </ResponseAssertion>
+        <hashTree/>
+        <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert category url path" enabled="true">
+          <collectionProp name="Asserion.test_strings">
+            <stringProp name="2845929">^.+$</stringProp>
+          </collectionProp>
+          <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
+          <boolProp name="Assertion.assume_success">false</boolProp>
+          <intProp name="Assertion.test_type">1</intProp>
+          <stringProp name="Assertion.scope">variable</stringProp>
+          <stringProp name="Scope.variable">admin_category_url_path</stringProp>
+        </ResponseAssertion>
+        <hashTree/>
+          <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert products added" enabled="true">
+            <collectionProp name="Asserion.test_strings">
+              <stringProp name="417284990">${simple_product_1_name}</stringProp>
+              <stringProp name="1304788671">${simple_product_2_name}</stringProp>
+              <stringProp name="-2102674944">${simple_product_3_name}</stringProp>
+              <stringProp name="-1215171263">${simple_product_4_name}</stringProp>
+              <stringProp name="-327667582">${simple_product_5_name}</stringProp>
+            </collectionProp>
+            <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
+            <boolProp name="Assertion.assume_success">false</boolProp>
+            <intProp name="Assertion.test_type">2</intProp>
+          </ResponseAssertion>
+          <hashTree/>
+      </hashTree>
+      <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Move category" enabled="true">
+        <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
+          <collectionProp name="Arguments.arguments">
+            <elementProp name="id" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">${admin_category_id}</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">id</stringProp>
+            </elementProp>
+            <elementProp name="form_key" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">${admin_form_key}</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">form_key</stringProp>
+            </elementProp>
+            <elementProp name="point" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">append</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">point</stringProp>
+            </elementProp>
+            <elementProp name="pid" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">${new_parent_category_id}</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">pid</stringProp>
+            </elementProp>
+            <elementProp name="paid" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">${parent_category_id}</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">paid</stringProp>
+            </elementProp>
+            <elementProp name="aid" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">0</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">aid</stringProp>
+            </elementProp>
+            <elementProp name="isAjax" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">true</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">isAjax</stringProp>
+            </elementProp>
+          </collectionProp>
+        </elementProp>
+        <stringProp name="HTTPSampler.domain"/>
+        <stringProp name="HTTPSampler.port"/>
+        <stringProp name="HTTPSampler.connect_timeout"/>
+        <stringProp name="HTTPSampler.response_timeout"/>
+        <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
+        <stringProp name="HTTPSampler.contentEncoding"/>
+        <stringProp name="HTTPSampler.path">${base_path}${admin_path}/catalog/category/move/</stringProp>
+        <stringProp name="HTTPSampler.method">POST</stringProp>
+        <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
+        <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
+        <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
+        <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
+        <boolProp name="HTTPSampler.monitor">false</boolProp>
+        <stringProp name="HTTPSampler.embedded_url_re"/>
+      </HTTPSamplerProxy>
+      <hashTree/>
+      <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Delete category" enabled="true">
+        <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
+          <collectionProp name="Arguments.arguments"/>
+        </elementProp>
+        <stringProp name="HTTPSampler.domain"/>
+        <stringProp name="HTTPSampler.port"/>
+        <stringProp name="HTTPSampler.connect_timeout"/>
+        <stringProp name="HTTPSampler.response_timeout"/>
+        <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
+        <stringProp name="HTTPSampler.contentEncoding"/>
+        <stringProp name="HTTPSampler.path">${base_path}${admin_path}/catalog/category/delete/id/${admin_category_id}/</stringProp>
+        <stringProp name="HTTPSampler.method">GET</stringProp>
+        <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
+        <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
+        <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
+        <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
+        <boolProp name="HTTPSampler.monitor">false</boolProp>
+        <stringProp name="HTTPSampler.embedded_url_re"/>
+      </HTTPSamplerProxy>
+      <hashTree>
+        <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert category deleted" enabled="true">
+          <collectionProp name="Asserion.test_strings">
+            <stringProp name="1277069529">You deleted the category.</stringProp>
+          </collectionProp>
+          <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
+          <boolProp name="Assertion.assume_success">false</boolProp>
+          <intProp name="Assertion.test_type">2</intProp>
+        </ResponseAssertion>
+        <hashTree/>
+      </hashTree>
+      <TestAction guiclass="TestActionGui" testclass="TestAction" testname="Pause" enabled="true">
+        <intProp name="ActionProcessor.action">1</intProp>
+        <intProp name="ActionProcessor.target">0</intProp>
+        <stringProp name="ActionProcessor.duration">${__javaScript(Math.round(${adminCategoryManagementDelay}*1000))}</stringProp>
+      </TestAction>
+      <hashTree/>
+    </hashTree>
+  </hashTree>
+  
+    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Logout" enabled="true">
+      <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
+        <collectionProp name="Arguments.arguments"/>
+      </elementProp>
+      <stringProp name="HTTPSampler.domain"/>
+      <stringProp name="HTTPSampler.port"/>
+      <stringProp name="HTTPSampler.connect_timeout"/>
+      <stringProp name="HTTPSampler.response_timeout"/>
+      <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
+      <stringProp name="HTTPSampler.contentEncoding"/>
+      <stringProp name="HTTPSampler.path">${base_path}${admin_path}/admin/auth/logout/</stringProp>
+      <stringProp name="HTTPSampler.method">GET</stringProp>
+      <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
+      <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
+      <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
+      <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
+      <boolProp name="HTTPSampler.monitor">false</boolProp>
+      <stringProp name="HTTPSampler.embedded_url_re"/>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/setup/admin_logout.jmx</stringProp></HTTPSamplerProxy>
+    <hashTree>
+    
+    <BeanShellPostProcessor guiclass="TestBeanGUI" testclass="BeanShellPostProcessor" testname="Return Admin to Pool" enabled="true">
+        <boolProp name="resetInterpreter">false</boolProp>
+        <stringProp name="parameters"/>
+        <stringProp name="filename"/>
+        <stringProp name="script">
+adminUserList = props.get("adminUserList");
+adminUserList.add(vars.get("admin_user"));
+        </stringProp>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/common/return_admin_email_to_pool.jmx</stringProp></BeanShellPostProcessor>
+    <hashTree/>
+  </hashTree>
+  </hashTree>
+
+  
+    <ThroughputController guiclass="ThroughputControllerGui" testclass="ThroughputController" testname="Admin Promotion Rules" enabled="true">
+      <intProp name="ThroughputController.style">1</intProp>
+      <boolProp name="ThroughputController.perThread">false</boolProp>
+      <intProp name="ThroughputController.maxThroughput">1</intProp>
+      <stringProp name="ThroughputController.percentThroughput">${adminPromotionRulesPercentage}</stringProp>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/_system/scenario_controller_tmpl.jmx</stringProp></ThroughputController>
+    <hashTree>
+        <JSR223PreProcessor guiclass="TestBeanGUI" testclass="JSR223PreProcessor" testname="Set Test Label" enabled="true">
+            <stringProp name="script">
+var testLabel = "${testLabel}" ? " (${testLabel})" : "";
+if (testLabel
+    &amp;&amp; sampler.getClass().getName() == 'org.apache.jmeter.protocol.http.sampler.HTTPSamplerProxy'
+) {
+    if (sampler.getName().indexOf(testLabel) == -1) {
+       sampler.setName(sampler.getName() + testLabel);
+    }
+} else if (sampler.getName().indexOf("SetUp - ") == -1) {
+    sampler.setName("SetUp - " + sampler.getName());
+}
+            </stringProp>
+            <stringProp name="scriptLanguage">javascript</stringProp>
+        <stringProp name="TestPlan.comments">mpaf/tool/fragments/_system/setup_label.jmx</stringProp></JSR223PreProcessor>
+        <hashTree/>
+        <BeanShellSampler guiclass="BeanShellSamplerGui" testclass="BeanShellSampler" testname="SetUp - Set Label" enabled="true">
+            <stringProp name="BeanShellSampler.query">
+                vars.put("testLabel", "Admin Promotion Rules");
+            </stringProp>
+            <boolProp name="BeanShellSampler.resetInterpreter">true</boolProp>
+        </BeanShellSampler>
+        <hashTree/>
+    
+        <JSR223PostProcessor guiclass="TestBeanGUI" testclass="JSR223PostProcessor" testname="Get admin form key PostProcessor" enabled="true">
+        <stringProp name="script">
+        function getFormKeyFromResponse()
+        {
+            var url = prev.getUrlAsString(),
+            responseCode =  prev.getResponseCode(),
+            formKey = null;
+            searchPattern = /var FORM_KEY = '(.+)'/;
+            if (responseCode == "200" &amp;&amp; url) {
+                response = prev.getResponseDataAsString();
+                formKey = response  &amp;&amp; response.match(searchPattern) ? response.match(searchPattern)[1] : null;
+            }
+            return formKey;
+        }
+
+        formKey = vars.get("form_key_storage");
+
+	   currentFormKey = getFormKeyFromResponse();
+
+	   if (currentFormKey != null &amp;&amp; currentFormKey != formKey) {
+		  vars.put("form_key_storage", currentFormKey);
+	   }
+        </stringProp>
+        <stringProp name="scriptLanguage">javascript</stringProp>
+        <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin/handle_admin_form_key.jmx</stringProp></JSR223PostProcessor>
+        <hashTree/>
+        <JSR223PreProcessor guiclass="TestBeanGUI" testclass="JSR223PreProcessor" testname="Set admin form key PreProcessor" enabled="true">
+            <stringProp name="script">
+                formKey =  vars.get("form_key_storage");
+                if (formKey
+                    &amp;&amp; sampler.getClass().getName() == 'org.apache.jmeter.protocol.http.sampler.HTTPSamplerProxy'
+                    &amp;&amp; sampler.getMethod() == "POST")
+                    {
+                        arguments = sampler.getArguments();
+                        for (i=0; i&lt;arguments.getArgumentCount(); i++)
+                        {
+                            argument = arguments.getArgument(i);
+                            if (argument.getName() == 'form_key' &amp;&amp; argument.getValue() != formKey) {
+                            log.info("admin form key updated: " + argument.getValue() + " =&gt; " + formKey);
+                            argument.setValue(formKey);
+                        }
+                    }
+                }
+            </stringProp>
+            <stringProp name="scriptLanguage">javascript</stringProp>
+        </JSR223PreProcessor>
+        <hashTree/>
+    
+    <CookieManager guiclass="CookiePanel" testclass="CookieManager" testname="HTTP Cookie Manager" enabled="true">
+      <collectionProp name="CookieManager.cookies"/>
+      <boolProp name="CookieManager.clearEachIteration">false</boolProp>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/http_cookie_manager_without_clear_each_iteration.jmx</stringProp></CookieManager>
+    <hashTree/>
+  
+    <GenericController guiclass="LogicControllerGui" testclass="GenericController" testname="Admin Login" enabled="true">
+  <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/simple_controller.jmx</stringProp>
+</GenericController>
+    <hashTree>
+    <CriticalSectionController guiclass="CriticalSectionControllerGui" testclass="CriticalSectionController" testname="Admin Login Lock" enabled="true">
+        <stringProp name="CriticalSectionController.lockName">get-admin-email</stringProp>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/lock_controller.jmx</stringProp></CriticalSectionController>
+    <hashTree>
+    
+    <BeanShellSampler guiclass="BeanShellSamplerGui" testclass="BeanShellSampler" testname="SetUp - Get Admin Email" enabled="true">
+      <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/get_admin_email.jmx</stringProp>
+      <stringProp name="BeanShellSampler.query">
+adminUserList = props.get("adminUserList");
+adminUser = adminUserList.poll();
+if (adminUser == null) {
+  SampleResult.setResponseMessage("adminUser list is empty");
+  SampleResult.setResponseData("adminUser list is empty","UTF-8");
+  IsSuccess=false;
+  SampleResult.setSuccessful(false);
+  SampleResult.setStopThread(true);
+}
+vars.put("admin_user", adminUser);
+      </stringProp>
+      <stringProp name="BeanShellSampler.filename"/>
+      <stringProp name="BeanShellSampler.parameters"/>
+      <boolProp name="BeanShellSampler.resetInterpreter">true</boolProp>
+    </BeanShellSampler>
+    <hashTree/>
+  </hashTree>
+  
+    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="SetUp - Login" enabled="true">
+      <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
+        <collectionProp name="Arguments.arguments"/>
+      </elementProp>
+      <stringProp name="HTTPSampler.domain"/>
+      <stringProp name="HTTPSampler.port"/>
+      <stringProp name="HTTPSampler.connect_timeout"/>
+      <stringProp name="HTTPSampler.response_timeout"/>
+      <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
+      <stringProp name="HTTPSampler.contentEncoding"/>
+      <stringProp name="HTTPSampler.path">${base_path}${admin_path}</stringProp>
+      <stringProp name="HTTPSampler.method">GET</stringProp>
+      <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
+      <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
+      <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
+      <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
+      <boolProp name="HTTPSampler.monitor">false</boolProp>
+      <stringProp name="HTTPSampler.embedded_url_re"/>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_login/admin_login.jmx</stringProp></HTTPSamplerProxy>
+    <hashTree>
+      <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert login form shown" enabled="true">
+        <collectionProp name="Asserion.test_strings">
+          <stringProp name="-1397214398">Welcome</stringProp>
+          <stringProp name="-515240035">&lt;title&gt;Magento Admin&lt;/title&gt;</stringProp>
+        </collectionProp>
+        <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
+        <boolProp name="Assertion.assume_success">false</boolProp>
+        <intProp name="Assertion.test_type">2</intProp>
+      </ResponseAssertion>
+      <hashTree/>
+      <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract form key" enabled="true">
+        <stringProp name="RegexExtractor.useHeaders">false</stringProp>
+        <stringProp name="RegexExtractor.refname">admin_form_key</stringProp>
+        <stringProp name="RegexExtractor.regex">&lt;input name="form_key" type="hidden" value="([^'"]+)" /&gt;</stringProp>
+        <stringProp name="RegexExtractor.template">$1$</stringProp>
+        <stringProp name="RegexExtractor.default"/>
+        <stringProp name="RegexExtractor.match_number">1</stringProp>
+      </RegexExtractor>
+      <hashTree/>
+      <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert form_key extracted" enabled="true">
+        <collectionProp name="Asserion.test_strings">
+          <stringProp name="2845929">^.+$</stringProp>
+        </collectionProp>
+        <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
+        <boolProp name="Assertion.assume_success">false</boolProp>
+        <intProp name="Assertion.test_type">1</intProp>
+        <stringProp name="Assertion.scope">variable</stringProp>
+        <stringProp name="Scope.variable">admin_form_key</stringProp>
+      </ResponseAssertion>
+      <hashTree/>
+    </hashTree>
+  
+    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="SetUp - Login Submit Form" enabled="true">
+      <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
+        <collectionProp name="Arguments.arguments">
+          <elementProp name="dummy" elementType="HTTPArgument">
             <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.name">export_filter[visibility]</stringProp>
             <stringProp name="Argument.value"/>
             <stringProp name="Argument.metadata">=</stringProp>
             <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">dummy</stringProp>
           </elementProp>
-          <elementProp name="export_filter[weight][]" elementType="HTTPArgument">
+          <elementProp name="form_key" elementType="HTTPArgument">
             <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.name">export_filter[weight][]</stringProp>
-            <stringProp name="Argument.value">,</stringProp>
+            <stringProp name="Argument.value">${admin_form_key}</stringProp>
             <stringProp name="Argument.metadata">=</stringProp>
             <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">form_key</stringProp>
           </elementProp>
-          <elementProp name="export_filter[weight_type][]" elementType="HTTPArgument">
+          <elementProp name="login[password]" elementType="HTTPArgument">
             <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.name">export_filter[weight_type][]</stringProp>
-            <stringProp name="Argument.value">,</stringProp>
+            <stringProp name="Argument.value">${admin_password}</stringProp>
             <stringProp name="Argument.metadata">=</stringProp>
             <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">login[password]</stringProp>
           </elementProp>
-          <elementProp name="frontend_label" elementType="HTTPArgument">
+          <elementProp name="login[username]" elementType="HTTPArgument">
             <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.name">frontend_label</stringProp>
-            <stringProp name="Argument.value"/>
+            <stringProp name="Argument.value">${admin_user}</stringProp>
             <stringProp name="Argument.metadata">=</stringProp>
             <boolProp name="HTTPArgument.use_equals">true</boolProp>
+            <stringProp name="Argument.name">login[username]</stringProp>
           </elementProp>
         </collectionProp>
       </elementProp>
@@ -32292,35 +31396,474 @@ if (testLabel
       <stringProp name="HTTPSampler.response_timeout"/>
       <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
       <stringProp name="HTTPSampler.contentEncoding"/>
-      <stringProp name="HTTPSampler.path">${base_path}${admin_path}/admin/export/export/entity/catalog_product/file_format/csv</stringProp>
-      <stringProp name="HTTPSampler.method">POST</stringProp>
+      <stringProp name="HTTPSampler.path">${base_path}${admin_path}/admin/dashboard/</stringProp>
+      <stringProp name="HTTPSampler.method">POST</stringProp>
+      <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
+      <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
+      <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
+      <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
+      <stringProp name="HTTPSampler.implementation">Java</stringProp>
+      <boolProp name="HTTPSampler.monitor">false</boolProp>
+      <stringProp name="HTTPSampler.embedded_url_re"/>
+      <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_login/admin_login_submit_form.jmx</stringProp>
+    </HTTPSamplerProxy>
+    <hashTree>
+        <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract form key" enabled="true">
+            <stringProp name="RegexExtractor.useHeaders">false</stringProp>
+            <stringProp name="RegexExtractor.refname">admin_form_key</stringProp>
+            <stringProp name="RegexExtractor.regex">&lt;input name="form_key" type="hidden" value="([^'"]+)" /&gt;</stringProp>
+            <stringProp name="RegexExtractor.template">$1$</stringProp>
+            <stringProp name="RegexExtractor.default"/>
+            <stringProp name="RegexExtractor.match_number">1</stringProp>
+        <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_login/admin_retrieve_form_key.jmx</stringProp></RegexExtractor>
+        <hashTree/>
+    </hashTree>
+  </hashTree>
+  
+    <GenericController guiclass="LogicControllerGui" testclass="GenericController" testname="Simple Controller" enabled="true">
+  <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/simple_controller.jmx</stringProp>
+</GenericController>
+    <hashTree>
+    <TestFragmentController guiclass="TestFragmentControllerGui" testclass="TestFragmentController" testname="Admin Promotions Management" enabled="true">
+  <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_promotions_management/admin_promotions_management.jmx</stringProp>
+</TestFragmentController>
+    <hashTree>
+      <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Landing Page" enabled="true">
+        <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
+          <collectionProp name="Arguments.arguments"/>
+        </elementProp>
+        <stringProp name="HTTPSampler.domain"/>
+        <stringProp name="HTTPSampler.port"/>
+        <stringProp name="HTTPSampler.connect_timeout"/>
+        <stringProp name="HTTPSampler.response_timeout"/>
+        <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
+        <stringProp name="HTTPSampler.contentEncoding"/>
+        <stringProp name="HTTPSampler.path">${base_path}${admin_path}/sales_rule/promo_quote/</stringProp>
+        <stringProp name="HTTPSampler.method">GET</stringProp>
+        <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
+        <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
+        <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
+        <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
+        <boolProp name="HTTPSampler.monitor">false</boolProp>
+        <stringProp name="HTTPSampler.embedded_url_re"/>
+      </HTTPSamplerProxy>
+      <hashTree/>
+      <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Create New" enabled="true">
+        <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
+          <collectionProp name="Arguments.arguments"/>
+        </elementProp>
+        <stringProp name="HTTPSampler.domain"/>
+        <stringProp name="HTTPSampler.port"/>
+        <stringProp name="HTTPSampler.connect_timeout"/>
+        <stringProp name="HTTPSampler.response_timeout"/>
+        <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
+        <stringProp name="HTTPSampler.contentEncoding"/>
+        <stringProp name="HTTPSampler.path">${base_path}${admin_path}/sales_rule/promo_quote/new</stringProp>
+        <stringProp name="HTTPSampler.method">GET</stringProp>
+        <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
+        <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
+        <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
+        <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
+        <boolProp name="HTTPSampler.monitor">false</boolProp>
+        <stringProp name="HTTPSampler.embedded_url_re"/>
+      </HTTPSamplerProxy>
+      <hashTree/>
+      <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Create New Conditional" enabled="true">
+        <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
+          <collectionProp name="Arguments.arguments">
+            <elementProp name="isAjax" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">true</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">isAjax</stringProp>
+            </elementProp>
+            <elementProp name="form_key" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">${admin_form_key}</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">form_key</stringProp>
+              <stringProp name="Argument.desc">true</stringProp>
+            </elementProp>
+            <elementProp name="id" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">1--1</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">id</stringProp>
+            </elementProp>
+            <elementProp name="type" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">Magento\SalesRule\Model\Rule\Condition\Address|base_subtotal</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">type</stringProp>
+            </elementProp>
+          </collectionProp>
+        </elementProp>
+        <stringProp name="HTTPSampler.domain"/>
+        <stringProp name="HTTPSampler.port"/>
+        <stringProp name="HTTPSampler.connect_timeout"/>
+        <stringProp name="HTTPSampler.response_timeout"/>
+        <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
+        <stringProp name="HTTPSampler.contentEncoding"/>
+        <stringProp name="HTTPSampler.path">${base_path}${admin_path}/sales_rule/promo_quote/newConditionHtml/form/sales_rule_formrule_conditions_fieldset_/form_namespace/sales_rule_form</stringProp>
+        <stringProp name="HTTPSampler.method">POST</stringProp>
+        <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
+        <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
+        <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
+        <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
+        <boolProp name="HTTPSampler.monitor">false</boolProp>
+        <stringProp name="HTTPSampler.embedded_url_re"/>
+      </HTTPSamplerProxy>
+      <hashTree/>
+      <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Save" enabled="true">
+        <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
+          <collectionProp name="Arguments.arguments">
+            <elementProp name="name" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">Rule Name ${__time(YMDHMS)}-${__threadNum}-${__Random(1,1000000)}</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">name</stringProp>
+            </elementProp>
+            <elementProp name="is_active" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">0</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">is_active</stringProp>
+            </elementProp>
+            <elementProp name="use_auto_generation" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">0</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">use_auto_generation</stringProp>
+            </elementProp>
+            <elementProp name="is_rss" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">1</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">is_rss</stringProp>
+            </elementProp>
+            <elementProp name="apply_to_shipping" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">0</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">apply_to_shipping</stringProp>
+            </elementProp>
+            <elementProp name="stop_rules_processing" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">0</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">stop_rules_processing</stringProp>
+            </elementProp>
+            <elementProp name="coupon_code" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value"/>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">coupon_code</stringProp>
+            </elementProp>
+            <elementProp name="uses_per_coupon" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value"/>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">uses_per_coupon</stringProp>
+            </elementProp>
+            <elementProp name="uses_per_customer" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value"/>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">uses_per_customer</stringProp>
+            </elementProp>
+            <elementProp name="sort_order" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value"/>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">sort_order</stringProp>
+            </elementProp>
+            <elementProp name="discount_amount" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">5</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">discount_amount</stringProp>
+            </elementProp>
+            <elementProp name="discount_qty" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">0</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">discount_qty</stringProp>
+            </elementProp>
+            <elementProp name="discount_step" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value"/>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">discount_step</stringProp>
+            </elementProp>
+            <elementProp name="reward_points_delta" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value"/>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">reward_points_delta</stringProp>
+            </elementProp>
+            <elementProp name="store_labels[0]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value"/>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">store_labels[0]</stringProp>
+            </elementProp>
+            <elementProp name="description" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">Rule Description ${__time(YMDHMS)}-${__threadNum}-${__Random(1,1000000)}</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">description</stringProp>
+            </elementProp>
+            <elementProp name="coupon_type" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">1</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">coupon_type</stringProp>
+            </elementProp>
+            <elementProp name="simple_action" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">cart_fixed</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">simple_action</stringProp>
+            </elementProp>
+            <elementProp name="website_ids[0]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">1</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">website_ids[0]</stringProp>
+            </elementProp>
+            <elementProp name="customer_group_ids[0]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">0</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">customer_group_ids[0]</stringProp>
+            </elementProp>
+            <elementProp name="from_date" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value"/>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">from_date</stringProp>
+            </elementProp>
+            <elementProp name="to_date" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value"/>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">to_date</stringProp>
+            </elementProp>
+            <elementProp name="rule[conditions][1][type]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">Magento\SalesRule\Model\Rule\Condition\Combine</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">rule[conditions][1][type]</stringProp>
+            </elementProp>
+            <elementProp name="rule[conditions][1][aggregator]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">all</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">rule[conditions][1][aggregator]</stringProp>
+            </elementProp>
+            <elementProp name="rule[conditions][1][value]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">1</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">rule[conditions][1][value]</stringProp>
+            </elementProp>
+            <elementProp name="rule[conditions][1--1][type]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">Magento\SalesRule\Model\Rule\Condition\Address</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">rule[conditions][1--1][type]</stringProp>
+            </elementProp>
+            <elementProp name="rule[conditions][1--1][attribute]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">base_subtotal</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">rule[conditions][1--1][attribute]</stringProp>
+            </elementProp>
+            <elementProp name="rule[conditions][1--1][operator]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">&gt;=</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">rule[conditions][1--1][operator]</stringProp>
+            </elementProp>
+            <elementProp name="rule[conditions][1--1][value]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">100</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">rule[conditions][1--1][value]</stringProp>
+            </elementProp>
+            <elementProp name="rule[conditions][1][new_chlid]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value"/>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">rule[conditions][1][new_chlid]</stringProp>
+            </elementProp>
+            <elementProp name="rule[actions][1][type]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">Magento\SalesRule\Model\Rule\Condition\Product\Combine</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">rule[actions][1][type]</stringProp>
+            </elementProp>
+            <elementProp name="rule[actions][1][aggregator]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">all</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">rule[actions][1][aggregator]</stringProp>
+            </elementProp>
+            <elementProp name="rule[actions][1][value]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">1</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">rule[actions][1][value]</stringProp>
+            </elementProp>
+            <elementProp name="rule[actions][1][new_child]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value"/>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">rule[actions][1][new_child]</stringProp>
+            </elementProp>
+            <elementProp name="store_labels[1]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value"/>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">store_labels[1]</stringProp>
+            </elementProp>
+            <elementProp name="store_labels[2]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value"/>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">store_labels[2]</stringProp>
+            </elementProp>
+            <elementProp name="related_banners" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value"/>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">related_banners</stringProp>
+            </elementProp>
+            <elementProp name="form_key" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">${admin_form_key}</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">form_key</stringProp>
+            </elementProp>
+          </collectionProp>
+        </elementProp>
+        <stringProp name="HTTPSampler.domain"/>
+        <stringProp name="HTTPSampler.port"/>
+        <stringProp name="HTTPSampler.connect_timeout"/>
+        <stringProp name="HTTPSampler.response_timeout"/>
+        <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
+        <stringProp name="HTTPSampler.contentEncoding"/>
+        <stringProp name="HTTPSampler.path">${base_path}${admin_path}/sales_rule/promo_quote/save/</stringProp>
+        <stringProp name="HTTPSampler.method">POST</stringProp>
+        <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
+        <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
+        <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
+        <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
+        <boolProp name="HTTPSampler.monitor">false</boolProp>
+        <stringProp name="HTTPSampler.embedded_url_re"/>
+      </HTTPSamplerProxy>
+      <hashTree>
+        <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Response Assertion" enabled="true">
+          <collectionProp name="Asserion.test_strings">
+            <stringProp name="-396438583">You saved the rule.</stringProp>
+          </collectionProp>
+          <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
+          <boolProp name="Assertion.assume_success">false</boolProp>
+          <intProp name="Assertion.test_type">16</intProp>
+        </ResponseAssertion>
+        <hashTree/>
+      </hashTree>
+      <TestAction guiclass="TestActionGui" testclass="TestAction" testname="Pause" enabled="true">
+        <intProp name="ActionProcessor.action">1</intProp>
+        <intProp name="ActionProcessor.target">0</intProp>
+        <stringProp name="ActionProcessor.duration">${__javaScript(Math.round(${adminPromotionsManagementDelay}*1000))}</stringProp>
+      </TestAction>
+      <hashTree/>
+    </hashTree>
+  </hashTree>
+  
+    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Logout" enabled="true">
+      <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
+        <collectionProp name="Arguments.arguments"/>
+      </elementProp>
+      <stringProp name="HTTPSampler.domain"/>
+      <stringProp name="HTTPSampler.port"/>
+      <stringProp name="HTTPSampler.connect_timeout"/>
+      <stringProp name="HTTPSampler.response_timeout"/>
+      <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
+      <stringProp name="HTTPSampler.contentEncoding"/>
+      <stringProp name="HTTPSampler.path">${base_path}${admin_path}/admin/auth/logout/</stringProp>
+      <stringProp name="HTTPSampler.method">GET</stringProp>
       <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
       <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
       <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
       <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
       <boolProp name="HTTPSampler.monitor">false</boolProp>
       <stringProp name="HTTPSampler.embedded_url_re"/>
-    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/export_products/export_products.jmx</stringProp></HTTPSamplerProxy>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/setup/admin_logout.jmx</stringProp></HTTPSamplerProxy>
     <hashTree>
-      <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Response Assertion" enabled="true">
-        <collectionProp name="Asserion.test_strings">
-          <stringProp name="-261088822">Simple Product 1</stringProp>
-        </collectionProp>
-        <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
-        <boolProp name="Assertion.assume_success">false</boolProp>
-        <intProp name="Assertion.test_type">16</intProp>
-      </ResponseAssertion>
-      <hashTree/>
-    </hashTree>
+    
+    <BeanShellPostProcessor guiclass="TestBeanGUI" testclass="BeanShellPostProcessor" testname="Return Admin to Pool" enabled="true">
+        <boolProp name="resetInterpreter">false</boolProp>
+        <stringProp name="parameters"/>
+        <stringProp name="filename"/>
+        <stringProp name="script">
+adminUserList = props.get("adminUserList");
+adminUserList.add(vars.get("admin_user"));
+        </stringProp>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/common/return_admin_email_to_pool.jmx</stringProp></BeanShellPostProcessor>
+    <hashTree/>
   </hashTree>
   </hashTree>
 
   
-    <ThroughputController guiclass="ThroughputControllerGui" testclass="ThroughputController" testname="Export Customers" enabled="true">
+    <ThroughputController guiclass="ThroughputControllerGui" testclass="ThroughputController" testname="Admin Customer Management" enabled="true">
       <intProp name="ThroughputController.style">1</intProp>
       <boolProp name="ThroughputController.perThread">false</boolProp>
       <intProp name="ThroughputController.maxThroughput">1</intProp>
-      <stringProp name="ThroughputController.percentThroughput">${exportCustomersPercentage}</stringProp>
+      <stringProp name="ThroughputController.percentThroughput">${adminCustomerManagementPercentage}</stringProp>
     <stringProp name="TestPlan.comments">mpaf/tool/fragments/_system/scenario_controller_tmpl.jmx</stringProp></ThroughputController>
     <hashTree>
         <JSR223PreProcessor guiclass="TestBeanGUI" testclass="JSR223PreProcessor" testname="Set Test Label" enabled="true">
@@ -32341,7 +31884,7 @@ if (testLabel
         <hashTree/>
         <BeanShellSampler guiclass="BeanShellSamplerGui" testclass="BeanShellSampler" testname="SetUp - Set Label" enabled="true">
             <stringProp name="BeanShellSampler.query">
-                vars.put("testLabel", "Export Customers");
+                vars.put("testLabel", "Admin Customer Management");
             </stringProp>
             <boolProp name="BeanShellSampler.resetInterpreter">true</boolProp>
         </BeanShellSampler>
@@ -32401,10 +31944,36 @@ if (testLabel
     <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/http_cookie_manager_without_clear_each_iteration.jmx</stringProp></CookieManager>
     <hashTree/>
   
-    <OnceOnlyController guiclass="OnceOnlyControllerGui" testclass="OnceOnlyController" testname="Once Only Controller" enabled="true">
-  <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/once_only_controller.jmx</stringProp>
-</OnceOnlyController>
+    <GenericController guiclass="LogicControllerGui" testclass="GenericController" testname="Admin Login" enabled="true">
+  <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/simple_controller.jmx</stringProp>
+</GenericController>
     <hashTree>
+    <CriticalSectionController guiclass="CriticalSectionControllerGui" testclass="CriticalSectionController" testname="Admin Login Lock" enabled="true">
+        <stringProp name="CriticalSectionController.lockName">get-admin-email</stringProp>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/lock_controller.jmx</stringProp></CriticalSectionController>
+    <hashTree>
+    
+    <BeanShellSampler guiclass="BeanShellSamplerGui" testclass="BeanShellSampler" testname="SetUp - Get Admin Email" enabled="true">
+      <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/get_admin_email.jmx</stringProp>
+      <stringProp name="BeanShellSampler.query">
+adminUserList = props.get("adminUserList");
+adminUser = adminUserList.poll();
+if (adminUser == null) {
+  SampleResult.setResponseMessage("adminUser list is empty");
+  SampleResult.setResponseData("adminUser list is empty","UTF-8");
+  IsSuccess=false;
+  SampleResult.setSuccessful(false);
+  SampleResult.setStopThread(true);
+}
+vars.put("admin_user", adminUser);
+      </stringProp>
+      <stringProp name="BeanShellSampler.filename"/>
+      <stringProp name="BeanShellSampler.parameters"/>
+      <boolProp name="BeanShellSampler.resetInterpreter">true</boolProp>
+    </BeanShellSampler>
+    <hashTree/>
+  </hashTree>
+  
     <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="SetUp - Login" enabled="true">
       <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
         <collectionProp name="Arguments.arguments"/>
@@ -32505,987 +32074,1930 @@ if (testLabel
       <stringProp name="HTTPSampler.implementation">Java</stringProp>
       <boolProp name="HTTPSampler.monitor">false</boolProp>
       <stringProp name="HTTPSampler.embedded_url_re"/>
-      <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_login/admin_login_submit_form.jmx</stringProp>
-    </HTTPSamplerProxy>
-    <hashTree/>
-  </hashTree>
-  
-    <GenericController guiclass="LogicControllerGui" testclass="GenericController" testname="Simple Controller" enabled="true">
-  <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/simple_controller.jmx</stringProp>
-</GenericController>
-    <hashTree>
-    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Export Page" enabled="true">
-      <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
-        <collectionProp name="Arguments.arguments"/>
-      </elementProp>
-      <stringProp name="HTTPSampler.domain"/>
-      <stringProp name="HTTPSampler.port"/>
-      <stringProp name="HTTPSampler.connect_timeout"/>
-      <stringProp name="HTTPSampler.response_timeout"/>
-      <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
-      <stringProp name="HTTPSampler.contentEncoding"/>
-      <stringProp name="HTTPSampler.path">${base_path}${admin_path}/admin/export/</stringProp>
-      <stringProp name="HTTPSampler.method">GET</stringProp>
-      <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
-      <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
-      <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
-      <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
-      <boolProp name="HTTPSampler.monitor">false</boolProp>
-      <stringProp name="HTTPSampler.embedded_url_re"/>
-    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/common/export.jmx</stringProp></HTTPSamplerProxy>
-    <hashTree>
-      <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert success" enabled="true">
-        <collectionProp name="Asserion.test_strings">
-          <stringProp name="1723813687">Export Settings</stringProp>
-        </collectionProp>
-        <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
-        <boolProp name="Assertion.assume_success">false</boolProp>
-        <intProp name="Assertion.test_type">2</intProp>
-      </ResponseAssertion>
-      <hashTree/>
-    </hashTree>
-  
-    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Export Customers" enabled="true">
-      <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
-        <collectionProp name="Arguments.arguments">
-          <elementProp name="form_key" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">${admin_form_key}</stringProp>
-            <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">form_key</stringProp>
-            <stringProp name="Argument.desc">false</stringProp>
-          </elementProp>
-          <elementProp name="attribute_code" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value"/>
-            <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">attribute_code</stringProp>
-            <stringProp name="Argument.desc">true</stringProp>
-          </elementProp>
-          <elementProp name="export_filter[confirmation]" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value"/>
-            <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">export_filter[confirmation]</stringProp>
-            <stringProp name="Argument.desc">true</stringProp>
-          </elementProp>
-          <elementProp name="export_filter[created_at]" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value"/>
-            <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">export_filter[created_at]</stringProp>
-            <stringProp name="Argument.desc">true</stringProp>
-          </elementProp>
-          <elementProp name="export_filter[created_in]" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value"/>
-            <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">export_filter[created_in]</stringProp>
-            <stringProp name="Argument.desc">true</stringProp>
-          </elementProp>
-          <elementProp name="export_filter[default_billing][]" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">,</stringProp>
-            <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">export_filter[default_billing][]</stringProp>
-            <stringProp name="Argument.desc">true</stringProp>
-          </elementProp>
-          <elementProp name="export_filter[default_shipping][]" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">,</stringProp>
-            <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">export_filter[default_shipping][]</stringProp>
-            <stringProp name="Argument.desc">true</stringProp>
-          </elementProp>
-          <elementProp name="export_filter[disable_auto_group_change]" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value"/>
-            <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">export_filter[disable_auto_group_change]</stringProp>
-            <stringProp name="Argument.desc">true</stringProp>
-          </elementProp>
-          <elementProp name="export_filter[dob][]" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">,</stringProp>
-            <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">export_filter[dob][]</stringProp>
-            <stringProp name="Argument.desc">true</stringProp>
-          </elementProp>
-          <elementProp name="export_filter[email]" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value"/>
-            <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">export_filter[email]</stringProp>
-            <stringProp name="Argument.desc">true</stringProp>
-          </elementProp>
-          <elementProp name="export_filter[firstname]" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value"/>
-            <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">export_filter[firstname]</stringProp>
-            <stringProp name="Argument.desc">true</stringProp>
-          </elementProp>
-          <elementProp name="export_filter[gender]" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value"/>
-            <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">export_filter[gender]</stringProp>
-            <stringProp name="Argument.desc">true</stringProp>
-          </elementProp>
-          <elementProp name="export_filter[group_id]" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value"/>
-            <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">export_filter[group_id]</stringProp>
-            <stringProp name="Argument.desc">true</stringProp>
-          </elementProp>
-          <elementProp name="export_filter[lastname]" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value"/>
-            <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">export_filter[lastname]</stringProp>
-            <stringProp name="Argument.desc">true</stringProp>
-          </elementProp>
-          <elementProp name="export_filter[middlename]" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value"/>
-            <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">export_filter[middlename]</stringProp>
-            <stringProp name="Argument.desc">true</stringProp>
-          </elementProp>
-          <elementProp name="export_filter[password_hash]" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value"/>
-            <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">export_filter[password_hash]</stringProp>
-            <stringProp name="Argument.desc">true</stringProp>
-          </elementProp>
-          <elementProp name="export_filter[prefix]" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value"/>
-            <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">export_filter[prefix]</stringProp>
-            <stringProp name="Argument.desc">true</stringProp>
-          </elementProp>
-          <elementProp name="export_filter[reward_update_notification][]" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">,</stringProp>
-            <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">export_filter[reward_update_notification][]</stringProp>
-            <stringProp name="Argument.desc">true</stringProp>
-          </elementProp>
-          <elementProp name="export_filter[reward_warning_notification][]" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">,</stringProp>
-            <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">export_filter[reward_warning_notification][]</stringProp>
-            <stringProp name="Argument.desc">true</stringProp>
-          </elementProp>
-          <elementProp name="export_filter[rp_token]" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value"/>
-            <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">export_filter[rp_token]</stringProp>
-            <stringProp name="Argument.desc">true</stringProp>
-          </elementProp>
-          <elementProp name="export_filter[rp_token_created_at][]" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">,</stringProp>
-            <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">export_filter[rp_token_created_at][]</stringProp>
-            <stringProp name="Argument.desc">true</stringProp>
-          </elementProp>
-          <elementProp name="export_filter[store_id]" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value"/>
-            <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">export_filter[store_id]</stringProp>
-            <stringProp name="Argument.desc">true</stringProp>
-          </elementProp>
-          <elementProp name="export_filter[suffix]" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value"/>
-            <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">export_filter[suffix]</stringProp>
-            <stringProp name="Argument.desc">true</stringProp>
-          </elementProp>
-          <elementProp name="export_filter[taxvat]" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value"/>
-            <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">export_filter[taxvat]</stringProp>
-            <stringProp name="Argument.desc">true</stringProp>
-          </elementProp>
-          <elementProp name="export_filter[website_id]" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value"/>
-            <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">export_filter[website_id]</stringProp>
-            <stringProp name="Argument.desc">true</stringProp>
-          </elementProp>
-          <elementProp name="frontend_label" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value"/>
-            <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">frontend_label</stringProp>
-            <stringProp name="Argument.desc">true</stringProp>
-          </elementProp>
-        </collectionProp>
-      </elementProp>
-      <stringProp name="HTTPSampler.domain"/>
-      <stringProp name="HTTPSampler.port"/>
-      <stringProp name="HTTPSampler.connect_timeout"/>
-      <stringProp name="HTTPSampler.response_timeout"/>
-      <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
-      <stringProp name="HTTPSampler.contentEncoding"/>
-      <stringProp name="HTTPSampler.path">${base_path}${admin_path}/admin/export/export/entity/customer/file_format/csv</stringProp>
-      <stringProp name="HTTPSampler.method">POST</stringProp>
-      <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
-      <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
-      <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
-      <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
-      <boolProp name="HTTPSampler.monitor">false</boolProp>
-      <stringProp name="HTTPSampler.embedded_url_re"/>
-    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/export_customers/export_customers.jmx</stringProp></HTTPSamplerProxy>
+      <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_login/admin_login_submit_form.jmx</stringProp>
+    </HTTPSamplerProxy>
     <hashTree>
-      <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Response Assertion" enabled="true">
-        <collectionProp name="Asserion.test_strings">
-          <stringProp name="-2040454917">user_1@example.com</stringProp>
-        </collectionProp>
-        <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
-        <boolProp name="Assertion.assume_success">false</boolProp>
-        <intProp name="Assertion.test_type">16</intProp>
-      </ResponseAssertion>
-      <hashTree/>
+        <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract form key" enabled="true">
+            <stringProp name="RegexExtractor.useHeaders">false</stringProp>
+            <stringProp name="RegexExtractor.refname">admin_form_key</stringProp>
+            <stringProp name="RegexExtractor.regex">&lt;input name="form_key" type="hidden" value="([^'"]+)" /&gt;</stringProp>
+            <stringProp name="RegexExtractor.template">$1$</stringProp>
+            <stringProp name="RegexExtractor.default"/>
+            <stringProp name="RegexExtractor.match_number">1</stringProp>
+        <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_login/admin_retrieve_form_key.jmx</stringProp></RegexExtractor>
+        <hashTree/>
     </hashTree>
   </hashTree>
-  </hashTree>
-
   
-    <ThroughputController guiclass="ThroughputControllerGui" testclass="ThroughputController" testname="Browse Product Grid" enabled="true">
-      <intProp name="ThroughputController.style">1</intProp>
-      <boolProp name="ThroughputController.perThread">false</boolProp>
-      <intProp name="ThroughputController.maxThroughput">1</intProp>
-      <stringProp name="ThroughputController.percentThroughput">${browseProductGridPercentage}</stringProp>
-    <stringProp name="TestPlan.comments">mpaf/tool/fragments/_system/scenario_controller_tmpl.jmx</stringProp></ThroughputController>
+    <GenericController guiclass="LogicControllerGui" testclass="GenericController" testname="Simple Controller" enabled="true">
+  <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/simple_controller.jmx</stringProp>
+</GenericController>
     <hashTree>
-        <JSR223PreProcessor guiclass="TestBeanGUI" testclass="JSR223PreProcessor" testname="Set Test Label" enabled="true">
-            <stringProp name="script">
-var testLabel = "${testLabel}" ? " (${testLabel})" : "";
-if (testLabel
-    &amp;&amp; sampler.getClass().getName() == 'org.apache.jmeter.protocol.http.sampler.HTTPSamplerProxy'
-) {
-    if (sampler.getName().indexOf(testLabel) == -1) {
-       sampler.setName(sampler.getName() + testLabel);
-    }
-} else if (sampler.getName().indexOf("SetUp - ") == -1) {
-    sampler.setName("SetUp - " + sampler.getName());
-}
-            </stringProp>
-            <stringProp name="scriptLanguage">javascript</stringProp>
-        <stringProp name="TestPlan.comments">mpaf/tool/fragments/_system/setup_label.jmx</stringProp></JSR223PreProcessor>
+    <TestFragmentController guiclass="TestFragmentControllerGui" testclass="TestFragmentController" testname="Admin Customer Management" enabled="true">
+  <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_customer_management/admin_customer_management.jmx</stringProp>
+</TestFragmentController>
+    <hashTree>
+      <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Landing Page" enabled="true">
+        <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
+          <collectionProp name="Arguments.arguments"/>
+        </elementProp>
+        <stringProp name="HTTPSampler.domain"/>
+        <stringProp name="HTTPSampler.port"/>
+        <stringProp name="HTTPSampler.connect_timeout"/>
+        <stringProp name="HTTPSampler.response_timeout"/>
+        <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
+        <stringProp name="HTTPSampler.contentEncoding"/>
+        <stringProp name="HTTPSampler.path">${base_path}${admin_path}/customer/index</stringProp>
+        <stringProp name="HTTPSampler.method">GET</stringProp>
+        <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
+        <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
+        <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
+        <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
+        <boolProp name="HTTPSampler.monitor">false</boolProp>
+        <stringProp name="HTTPSampler.embedded_url_re"/>
+      </HTTPSamplerProxy>
+      <hashTree>
+        <HeaderManager guiclass="HeaderPanel" testclass="HeaderManager" testname="HTTP Header Manager" enabled="true">
+          <collectionProp name="HeaderManager.headers">
+            <elementProp name="Accept-Language" elementType="Header">
+              <stringProp name="Header.name">Accept-Language</stringProp>
+              <stringProp name="Header.value">en-US,en;q=0.5</stringProp>
+            </elementProp>
+            <elementProp name="Accept" elementType="Header">
+              <stringProp name="Header.name">Accept</stringProp>
+              <stringProp name="Header.value">text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8</stringProp>
+            </elementProp>
+            <elementProp name="User-Agent" elementType="Header">
+              <stringProp name="Header.name">User-Agent</stringProp>
+              <stringProp name="Header.value">Mozilla/5.0 (Windows NT 6.1; WOW64; rv:27.0) Gecko/20100101 Firefox/27.0</stringProp>
+            </elementProp>
+            <elementProp name="Accept-Encoding" elementType="Header">
+              <stringProp name="Header.name">Accept-Encoding</stringProp>
+              <stringProp name="Header.value">gzip, deflate</stringProp>
+            </elementProp>
+          </collectionProp>
+        </HeaderManager>
+        <hashTree/>
+      </hashTree>
+      <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Render" enabled="true">
+        <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
+          <collectionProp name="Arguments.arguments">
+            <elementProp name="namespace" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">customer_listing</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">namespace</stringProp>
+            </elementProp>
+            <elementProp name="search" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value"/>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">search</stringProp>
+            </elementProp>
+            <elementProp name="filters[placeholder]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">true</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">filters[placeholder]</stringProp>
+            </elementProp>
+            <elementProp name="paging[pageSize]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">20</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">paging[pageSize]</stringProp>
+            </elementProp>
+            <elementProp name="paging[current]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">1</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">paging[current]</stringProp>
+            </elementProp>
+            <elementProp name="sorting[field]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">entity_id</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">sorting[field]</stringProp>
+            </elementProp>
+            <elementProp name="sorting[direction]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">asc</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">sorting[direction]</stringProp>
+            </elementProp>
+            <elementProp name="isAjax" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">true</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">isAjax</stringProp>
+            </elementProp>
+          </collectionProp>
+        </elementProp>
+        <stringProp name="HTTPSampler.domain"/>
+        <stringProp name="HTTPSampler.port"/>
+        <stringProp name="HTTPSampler.connect_timeout"/>
+        <stringProp name="HTTPSampler.response_timeout"/>
+        <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
+        <stringProp name="HTTPSampler.contentEncoding"/>
+        <stringProp name="HTTPSampler.path">${base_path}${admin_path}/mui/index/render/</stringProp>
+        <stringProp name="HTTPSampler.method">GET</stringProp>
+        <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
+        <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
+        <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
+        <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
+        <boolProp name="HTTPSampler.monitor">false</boolProp>
+        <stringProp name="HTTPSampler.embedded_url_re"/>
+      </HTTPSamplerProxy>
+      <hashTree>
+        <HeaderManager guiclass="HeaderPanel" testclass="HeaderManager" testname="HTTP Header Manager" enabled="true">
+          <collectionProp name="HeaderManager.headers">
+            <elementProp name="" elementType="Header">
+              <stringProp name="Header.name">X-Requested-With</stringProp>
+              <stringProp name="Header.value">XMLHttpRequest</stringProp>
+            </elementProp>
+          </collectionProp>
+        </HeaderManager>
+        <hashTree/>
+      </hashTree>
+      <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Search Render" enabled="true">
+        <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
+          <collectionProp name="Arguments.arguments">
+            <elementProp name="namespace" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">customer_listing</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">namespace</stringProp>
+            </elementProp>
+            <elementProp name="search" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">Lastname</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">search</stringProp>
+            </elementProp>
+            <elementProp name="filters[placeholder]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">true</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">filters[placeholder]</stringProp>
+            </elementProp>
+            <elementProp name="paging[pageSize]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">20</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">paging[pageSize]</stringProp>
+            </elementProp>
+            <elementProp name="paging[current]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">1</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">paging[current]</stringProp>
+            </elementProp>
+            <elementProp name="sorting[field]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">entity_id</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">sorting[field]</stringProp>
+            </elementProp>
+            <elementProp name="sorting[direction]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">asc</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">sorting[direction]</stringProp>
+            </elementProp>
+            <elementProp name="isAjax" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">true</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">isAjax</stringProp>
+            </elementProp>
+          </collectionProp>
+        </elementProp>
+        <stringProp name="HTTPSampler.domain"/>
+        <stringProp name="HTTPSampler.port"/>
+        <stringProp name="HTTPSampler.connect_timeout"/>
+        <stringProp name="HTTPSampler.response_timeout"/>
+        <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
+        <stringProp name="HTTPSampler.contentEncoding"/>
+        <stringProp name="HTTPSampler.path">${base_path}${admin_path}/mui/index/render/</stringProp>
+        <stringProp name="HTTPSampler.method">GET</stringProp>
+        <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
+        <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
+        <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
+        <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
+        <boolProp name="HTTPSampler.monitor">false</boolProp>
+        <stringProp name="HTTPSampler.embedded_url_re"/>
+      </HTTPSamplerProxy>
+      <hashTree>
+        <HeaderManager guiclass="HeaderPanel" testclass="HeaderManager" testname="HTTP Header Manager" enabled="true">
+          <collectionProp name="HeaderManager.headers">
+            <elementProp name="" elementType="Header">
+              <stringProp name="Header.name">X-Requested-With</stringProp>
+              <stringProp name="Header.value">XMLHttpRequest</stringProp>
+            </elementProp>
+          </collectionProp>
+        </HeaderManager>
+        <hashTree/>
+        <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract customer edit url" enabled="true">
+          <stringProp name="RegexExtractor.useHeaders">false</stringProp>
+          <stringProp name="RegexExtractor.refname">customer_edit_url_path</stringProp>
+          <stringProp name="RegexExtractor.regex">actions":\{"edit":\{"href":"(?:http|https):\\/\\/(.*?)\\/customer\\/index\\/edit\\/id\\/(\d+)\\/",</stringProp>
+          <stringProp name="RegexExtractor.template">/customer/index/edit/id/$2$/</stringProp>
+          <stringProp name="RegexExtractor.default"/>
+          <stringProp name="RegexExtractor.match_number">0</stringProp>
+        </RegexExtractor>
+        <hashTree/>
+        <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert customer edit url" enabled="true">
+          <collectionProp name="Asserion.test_strings">
+            <stringProp name="2845929">^.+$</stringProp>
+          </collectionProp>
+          <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
+          <boolProp name="Assertion.assume_success">false</boolProp>
+          <intProp name="Assertion.test_type">1</intProp>
+          <stringProp name="Assertion.scope">variable</stringProp>
+          <stringProp name="Scope.variable">customer_edit_url_path</stringProp>
+        </ResponseAssertion>
+        <hashTree/>
+      </hashTree>
+      <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Edit Customer" enabled="true">
+        <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
+          <collectionProp name="Arguments.arguments"/>
+        </elementProp>
+        <stringProp name="HTTPSampler.domain"/>
+        <stringProp name="HTTPSampler.port"/>
+        <stringProp name="HTTPSampler.connect_timeout"/>
+        <stringProp name="HTTPSampler.response_timeout"/>
+        <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
+        <stringProp name="HTTPSampler.contentEncoding"/>
+        <stringProp name="HTTPSampler.path">${base_path}${admin_path}${customer_edit_url_path}</stringProp>
+        <stringProp name="HTTPSampler.method">GET</stringProp>
+        <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
+        <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
+        <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
+        <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
+        <boolProp name="HTTPSampler.monitor">false</boolProp>
+        <stringProp name="HTTPSampler.embedded_url_re"/>
+      </HTTPSamplerProxy>
+      <hashTree>
+        <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert edit customer page" enabled="true">
+          <collectionProp name="Asserion.test_strings">
+            <stringProp name="-1422614550">Customer Information</stringProp>
+          </collectionProp>
+          <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
+          <boolProp name="Assertion.assume_success">false</boolProp>
+          <intProp name="Assertion.test_type">2</intProp>
+        </ResponseAssertion>
+        <hashTree/>
+        <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract customer entity_id" enabled="true">
+          <stringProp name="RegexExtractor.useHeaders">false</stringProp>
+          <stringProp name="RegexExtractor.refname">admin_customer_entity_id</stringProp>
+          <stringProp name="RegexExtractor.regex">"entity_id":"(\d+)"</stringProp>
+          <stringProp name="RegexExtractor.template">$1$</stringProp>
+          <stringProp name="RegexExtractor.default"/>
+          <stringProp name="RegexExtractor.match_number">1</stringProp>
+        </RegexExtractor>
+        <hashTree/>
+        <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract website_id" enabled="true">
+          <stringProp name="RegexExtractor.useHeaders">false</stringProp>
+          <stringProp name="RegexExtractor.refname">admin_customer_website_id</stringProp>
+          <stringProp name="RegexExtractor.regex">"website_id":"(\d+)"</stringProp>
+          <stringProp name="RegexExtractor.template">$1$</stringProp>
+          <stringProp name="RegexExtractor.default"/>
+          <stringProp name="RegexExtractor.match_number">1</stringProp>
+        </RegexExtractor>
+        <hashTree/>
+        <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract customer firstname" enabled="true">
+          <stringProp name="RegexExtractor.useHeaders">false</stringProp>
+          <stringProp name="RegexExtractor.refname">admin_customer_firstname</stringProp>
+          <stringProp name="RegexExtractor.regex">"firstname":"([^"]+)"</stringProp>
+          <stringProp name="RegexExtractor.template">$1$</stringProp>
+          <stringProp name="RegexExtractor.default"/>
+          <stringProp name="RegexExtractor.match_number">1</stringProp>
+        </RegexExtractor>
+        <hashTree/>
+        <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract customer lastname" enabled="true">
+          <stringProp name="RegexExtractor.useHeaders">false</stringProp>
+          <stringProp name="RegexExtractor.refname">admin_customer_lastname</stringProp>
+          <stringProp name="RegexExtractor.regex">"lastname":"([^"]+)"</stringProp>
+          <stringProp name="RegexExtractor.template">$1$</stringProp>
+          <stringProp name="RegexExtractor.default"/>
+          <stringProp name="RegexExtractor.match_number">1</stringProp>
+        </RegexExtractor>
+        <hashTree/>
+        <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract customer email" enabled="true">
+          <stringProp name="RegexExtractor.useHeaders">false</stringProp>
+          <stringProp name="RegexExtractor.refname">admin_customer_email</stringProp>
+          <stringProp name="RegexExtractor.regex">"email":"([^\@]+@[^.]+.[^"]+)"</stringProp>
+          <stringProp name="RegexExtractor.template">$1$</stringProp>
+          <stringProp name="RegexExtractor.default"/>
+          <stringProp name="RegexExtractor.match_number">1</stringProp>
+        </RegexExtractor>
+        <hashTree/>
+        <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract group_id" enabled="true">
+          <stringProp name="RegexExtractor.useHeaders">false</stringProp>
+          <stringProp name="RegexExtractor.refname">admin_customer_group_id</stringProp>
+          <stringProp name="RegexExtractor.regex">"group_id":"(\d+)"</stringProp>
+          <stringProp name="RegexExtractor.template">$1$</stringProp>
+          <stringProp name="RegexExtractor.default"/>
+          <stringProp name="RegexExtractor.match_number">1</stringProp>
+        </RegexExtractor>
+        <hashTree/>
+        <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract store_id" enabled="true">
+          <stringProp name="RegexExtractor.useHeaders">false</stringProp>
+          <stringProp name="RegexExtractor.refname">admin_customer_store_id</stringProp>
+          <stringProp name="RegexExtractor.regex">"store_id":"(\d+)"</stringProp>
+          <stringProp name="RegexExtractor.template">$1$</stringProp>
+          <stringProp name="RegexExtractor.default"/>
+          <stringProp name="RegexExtractor.match_number">1</stringProp>
+        </RegexExtractor>
+        <hashTree/>
+        <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extact created_at" enabled="true">
+          <stringProp name="RegexExtractor.useHeaders">false</stringProp>
+          <stringProp name="RegexExtractor.refname">admin_customer_created_at</stringProp>
+          <stringProp name="RegexExtractor.regex">"created_at":"([^"]+)"</stringProp>
+          <stringProp name="RegexExtractor.template">$1$</stringProp>
+          <stringProp name="RegexExtractor.default"/>
+          <stringProp name="RegexExtractor.match_number">1</stringProp>
+        </RegexExtractor>
+        <hashTree/>
+        <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract updated_at" enabled="true">
+          <stringProp name="RegexExtractor.useHeaders">false</stringProp>
+          <stringProp name="RegexExtractor.refname">admin_customer_updated_at</stringProp>
+          <stringProp name="RegexExtractor.regex">"updated_at":"([^"]+)"</stringProp>
+          <stringProp name="RegexExtractor.template">$1$</stringProp>
+          <stringProp name="RegexExtractor.default"/>
+          <stringProp name="RegexExtractor.match_number">1</stringProp>
+        </RegexExtractor>
+        <hashTree/>
+        <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract is_active" enabled="true">
+          <stringProp name="RegexExtractor.useHeaders">false</stringProp>
+          <stringProp name="RegexExtractor.refname">admin_customer_is_active</stringProp>
+          <stringProp name="RegexExtractor.regex">"is_active":"(\d+)"</stringProp>
+          <stringProp name="RegexExtractor.template">$1$</stringProp>
+          <stringProp name="RegexExtractor.default"/>
+          <stringProp name="RegexExtractor.match_number">1</stringProp>
+        </RegexExtractor>
+        <hashTree/>
+        <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract disable_auto_group_change" enabled="true">
+          <stringProp name="RegexExtractor.useHeaders">false</stringProp>
+          <stringProp name="RegexExtractor.refname">admin_customer_disable_auto_group_change</stringProp>
+          <stringProp name="RegexExtractor.regex">"disable_auto_group_change":"(\d+)"</stringProp>
+          <stringProp name="RegexExtractor.template">$1$</stringProp>
+          <stringProp name="RegexExtractor.default"/>
+          <stringProp name="RegexExtractor.match_number">1</stringProp>
+        </RegexExtractor>
+        <hashTree/>
+        <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract created_in" enabled="true">
+          <stringProp name="RegexExtractor.useHeaders">false</stringProp>
+          <stringProp name="RegexExtractor.refname">admin_customer_created_in</stringProp>
+          <stringProp name="RegexExtractor.regex">"created_in":"([^"]+)"</stringProp>
+          <stringProp name="RegexExtractor.template">$1$</stringProp>
+          <stringProp name="RegexExtractor.default"/>
+          <stringProp name="RegexExtractor.match_number">1</stringProp>
+        </RegexExtractor>
+        <hashTree/>
+        <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract dob" enabled="true">
+          <stringProp name="RegexExtractor.useHeaders">false</stringProp>
+          <stringProp name="RegexExtractor.refname">admin_customer_dob</stringProp>
+          <stringProp name="RegexExtractor.regex">"dob":"(\d+)-(\d+)-(\d+)"</stringProp>
+          <stringProp name="RegexExtractor.template">$2$/$3$/$1$</stringProp>
+          <stringProp name="RegexExtractor.default"/>
+          <stringProp name="RegexExtractor.match_number">1</stringProp>
+        </RegexExtractor>
+        <hashTree/>
+        <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract default_billing" enabled="true">
+          <stringProp name="RegexExtractor.useHeaders">false</stringProp>
+          <stringProp name="RegexExtractor.refname">admin_customer_default_billing</stringProp>
+          <stringProp name="RegexExtractor.regex">"default_billing":"(\d+)"</stringProp>
+          <stringProp name="RegexExtractor.template">$1$</stringProp>
+          <stringProp name="RegexExtractor.default"/>
+          <stringProp name="RegexExtractor.match_number">1</stringProp>
+        </RegexExtractor>
+        <hashTree/>
+        <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract default_shipping" enabled="true">
+          <stringProp name="RegexExtractor.useHeaders">false</stringProp>
+          <stringProp name="RegexExtractor.refname">admin_customer_default_shipping</stringProp>
+          <stringProp name="RegexExtractor.regex">"default_shipping":"(\d+)"</stringProp>
+          <stringProp name="RegexExtractor.template">$1$</stringProp>
+          <stringProp name="RegexExtractor.default"/>
+          <stringProp name="RegexExtractor.match_number">1</stringProp>
+        </RegexExtractor>
+        <hashTree/>
+        <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract gender" enabled="true">
+          <stringProp name="RegexExtractor.useHeaders">false</stringProp>
+          <stringProp name="RegexExtractor.refname">admin_customer_gender</stringProp>
+          <stringProp name="RegexExtractor.regex">"gender":"(\d+)"</stringProp>
+          <stringProp name="RegexExtractor.template">$1$</stringProp>
+          <stringProp name="RegexExtractor.default"/>
+          <stringProp name="RegexExtractor.match_number">1</stringProp>
+        </RegexExtractor>
+        <hashTree/>
+        <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract failures_num" enabled="true">
+          <stringProp name="RegexExtractor.useHeaders">false</stringProp>
+          <stringProp name="RegexExtractor.refname">admin_customer_failures_num</stringProp>
+          <stringProp name="RegexExtractor.regex">"failures_num":"(\d+)"</stringProp>
+          <stringProp name="RegexExtractor.template">$1$</stringProp>
+          <stringProp name="RegexExtractor.default"/>
+          <stringProp name="RegexExtractor.match_number">1</stringProp>
+        </RegexExtractor>
+        <hashTree/>
+        <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract address_entity_id" enabled="true">
+          <stringProp name="RegexExtractor.useHeaders">false</stringProp>
+          <stringProp name="RegexExtractor.refname">admin_customer_address_entity_id</stringProp>
+          <stringProp name="RegexExtractor.regex">"address":\{"\d+":{"entity_id":"(\d+)".+?"parent_id":"${admin_customer_entity_id}"</stringProp>
+          <stringProp name="RegexExtractor.template">$1$</stringProp>
+          <stringProp name="RegexExtractor.default"/>
+          <stringProp name="RegexExtractor.match_number">1</stringProp>
+        </RegexExtractor>
+        <hashTree/>
+       <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract address_created_at" enabled="true">
+          <stringProp name="RegexExtractor.useHeaders">false</stringProp>
+          <stringProp name="RegexExtractor.refname">admin_customer_address_created_at</stringProp>
+          <stringProp name="RegexExtractor.regex">"address":\{"\d+":{.+?"parent_id":"${admin_customer_entity_id}".+?"created_at":"([^"]+)"</stringProp>
+          <stringProp name="RegexExtractor.template">$1$</stringProp>
+          <stringProp name="RegexExtractor.default"/>
+          <stringProp name="RegexExtractor.match_number">1</stringProp>
+        </RegexExtractor>
+        <hashTree/>
+        <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract address_updated_at" enabled="true">
+          <stringProp name="RegexExtractor.useHeaders">false</stringProp>
+          <stringProp name="RegexExtractor.refname">admin_customer_address_updated_at</stringProp>
+          <stringProp name="RegexExtractor.regex">"address":\{"\d+":{.+?"parent_id":"${admin_customer_entity_id}".+?"updated_at":"([^"]+)"</stringProp>
+          <stringProp name="RegexExtractor.template">$1$</stringProp>
+          <stringProp name="RegexExtractor.default"/>
+          <stringProp name="RegexExtractor.match_number">1</stringProp>
+        </RegexExtractor>
+        <hashTree/>
+        <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract address_is_active" enabled="true">
+          <stringProp name="RegexExtractor.useHeaders">false</stringProp>
+          <stringProp name="RegexExtractor.refname">admin_customer_address_is_active</stringProp>
+          <stringProp name="RegexExtractor.regex">"address":\{"\d+":{.+?"parent_id":"${admin_customer_entity_id}".+?"is_active":"(\d+)"</stringProp>
+          <stringProp name="RegexExtractor.template">$1$</stringProp>
+          <stringProp name="RegexExtractor.default"/>
+          <stringProp name="RegexExtractor.match_number">1</stringProp>
+        </RegexExtractor>
+        <hashTree/>
+        <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract address_city" enabled="true">
+          <stringProp name="RegexExtractor.useHeaders">false</stringProp>
+          <stringProp name="RegexExtractor.refname">admin_customer_address_city</stringProp>
+          <stringProp name="RegexExtractor.regex">"address":\{"\d+":{.+?"parent_id":"${admin_customer_entity_id}".+?"city":"([^"]+)"</stringProp>
+          <stringProp name="RegexExtractor.template">$1$</stringProp>
+          <stringProp name="RegexExtractor.default"/>
+          <stringProp name="RegexExtractor.match_number">1</stringProp>
+        </RegexExtractor>
         <hashTree/>
-        <BeanShellSampler guiclass="BeanShellSamplerGui" testclass="BeanShellSampler" testname="SetUp - Set Label" enabled="true">
-            <stringProp name="BeanShellSampler.query">
-                vars.put("testLabel", "Browse Product Grid");
-            </stringProp>
-            <boolProp name="BeanShellSampler.resetInterpreter">true</boolProp>
-        </BeanShellSampler>
+        <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract address_country_id" enabled="true">
+          <stringProp name="RegexExtractor.useHeaders">false</stringProp>
+          <stringProp name="RegexExtractor.refname">admin_customer_address_country_id</stringProp>
+          <stringProp name="RegexExtractor.regex">"address":\{"\d+":{.+?"parent_id":"${admin_customer_entity_id}".+?"country_id":"([^"]+)"</stringProp>
+          <stringProp name="RegexExtractor.template">$1$</stringProp>
+          <stringProp name="RegexExtractor.default"/>
+          <stringProp name="RegexExtractor.match_number">1</stringProp>
+        </RegexExtractor>
         <hashTree/>
-    
-        <JSR223PostProcessor guiclass="TestBeanGUI" testclass="JSR223PostProcessor" testname="Get admin form key PostProcessor" enabled="true">
-        <stringProp name="script">
-        function getFormKeyFromResponse()
-        {
-            var url = prev.getUrlAsString(),
-            responseCode =  prev.getResponseCode(),
-            formKey = null;
-            searchPattern = /var FORM_KEY = '(.+)'/;
-            if (responseCode == "200" &amp;&amp; url) {
-                response = prev.getResponseDataAsString();
-                formKey = response  &amp;&amp; response.match(searchPattern) ? response.match(searchPattern)[1] : null;
-            }
-            return formKey;
-        }
-
-        formKey = vars.get("form_key_storage");
-
-	   currentFormKey = getFormKeyFromResponse();
-
-	   if (currentFormKey != null &amp;&amp; currentFormKey != formKey) {
-		  vars.put("form_key_storage", currentFormKey);
-	   }
-        </stringProp>
-        <stringProp name="scriptLanguage">javascript</stringProp>
-        <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin/handle_admin_form_key.jmx</stringProp></JSR223PostProcessor>
+        <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract address_firstname" enabled="true">
+          <stringProp name="RegexExtractor.useHeaders">false</stringProp>
+          <stringProp name="RegexExtractor.refname">admin_customer_address_firstname</stringProp>
+          <stringProp name="RegexExtractor.regex">"address":\{"\d+":{.+?"parent_id":"${admin_customer_entity_id}".+?"firstname":"([^"]+)"</stringProp>
+          <stringProp name="RegexExtractor.template">$1$</stringProp>
+          <stringProp name="RegexExtractor.default"/>
+          <stringProp name="RegexExtractor.match_number">1</stringProp>
+        </RegexExtractor>
         <hashTree/>
-        <JSR223PreProcessor guiclass="TestBeanGUI" testclass="JSR223PreProcessor" testname="Set admin form key PreProcessor" enabled="true">
-            <stringProp name="script">
-                formKey =  vars.get("form_key_storage");
-                if (formKey
-                    &amp;&amp; sampler.getClass().getName() == 'org.apache.jmeter.protocol.http.sampler.HTTPSamplerProxy'
-                    &amp;&amp; sampler.getMethod() == "POST")
-                    {
-                        arguments = sampler.getArguments();
-                        for (i=0; i&lt;arguments.getArgumentCount(); i++)
-                        {
-                            argument = arguments.getArgument(i);
-                            if (argument.getName() == 'form_key' &amp;&amp; argument.getValue() != formKey) {
-                            log.info("admin form key updated: " + argument.getValue() + " =&gt; " + formKey);
-                            argument.setValue(formKey);
-                        }
-                    }
-                }
-            </stringProp>
-            <stringProp name="scriptLanguage">javascript</stringProp>
-        </JSR223PreProcessor>
+        <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract address_lastname" enabled="true">
+          <stringProp name="RegexExtractor.useHeaders">false</stringProp>
+          <stringProp name="RegexExtractor.refname">admin_customer_address_lastname</stringProp>
+          <stringProp name="RegexExtractor.regex">"address":\{"\d+":{.+?"parent_id":"${admin_customer_entity_id}".+?"lastname":"([^"]+)"</stringProp>
+          <stringProp name="RegexExtractor.template">$1$</stringProp>
+          <stringProp name="RegexExtractor.default"/>
+          <stringProp name="RegexExtractor.match_number">1</stringProp>
+        </RegexExtractor>
         <hashTree/>
-    
-    <CookieManager guiclass="CookiePanel" testclass="CookieManager" testname="HTTP Cookie Manager" enabled="true">
-      <collectionProp name="CookieManager.cookies"/>
-      <boolProp name="CookieManager.clearEachIteration">false</boolProp>
-    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/http_cookie_manager_without_clear_each_iteration.jmx</stringProp></CookieManager>
-    <hashTree/>
-  
-    <JSR223PostProcessor guiclass="TestBeanGUI" testclass="JSR223PreProcessor" testname="SetUp - Set Arguments" enabled="true">
-      <stringProp name="script">
-        vars.put("gridEntityType" , "Product");
-
-        pagesCount = parseInt(vars.get("products_page_size")) || 20;
-        vars.put("grid_entity_page_size" , pagesCount);
-        vars.put("grid_namespace" , "product_listing");
-        vars.put("grid_admin_browse_filter_text" , vars.get("admin_browse_product_filter_text"));
-        vars.put("grid_filter_field", "name");
-
-        // set sort fields and sort directions
-        vars.put("grid_sort_field_1", "name");
-        vars.put("grid_sort_field_2", "price");
-        vars.put("grid_sort_field_3", "attribute_set_id");
-        vars.put("grid_sort_order_1", "asc");
-        vars.put("grid_sort_order_2", "desc");
-      </stringProp>
-      <stringProp name="scriptLanguage">javascript</stringProp>
-    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_browse_products_grid/setup.jmx</stringProp></JSR223PostProcessor>
-    <hashTree/>
-  
-    <OnceOnlyController guiclass="OnceOnlyControllerGui" testclass="OnceOnlyController" testname="Once Only Controller" enabled="true">
-  <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/once_only_controller.jmx</stringProp>
-</OnceOnlyController>
-    <hashTree>
-    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="SetUp - Login" enabled="true">
-      <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
-        <collectionProp name="Arguments.arguments"/>
-      </elementProp>
-      <stringProp name="HTTPSampler.domain"/>
-      <stringProp name="HTTPSampler.port"/>
-      <stringProp name="HTTPSampler.connect_timeout"/>
-      <stringProp name="HTTPSampler.response_timeout"/>
-      <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
-      <stringProp name="HTTPSampler.contentEncoding"/>
-      <stringProp name="HTTPSampler.path">${base_path}${admin_path}</stringProp>
-      <stringProp name="HTTPSampler.method">GET</stringProp>
-      <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
-      <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
-      <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
-      <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
-      <boolProp name="HTTPSampler.monitor">false</boolProp>
-      <stringProp name="HTTPSampler.embedded_url_re"/>
-    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_login/admin_login.jmx</stringProp></HTTPSamplerProxy>
-    <hashTree>
-      <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert login form shown" enabled="true">
-        <collectionProp name="Asserion.test_strings">
-          <stringProp name="-1397214398">Welcome</stringProp>
-          <stringProp name="-515240035">&lt;title&gt;Magento Admin&lt;/title&gt;</stringProp>
-        </collectionProp>
-        <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
-        <boolProp name="Assertion.assume_success">false</boolProp>
-        <intProp name="Assertion.test_type">2</intProp>
-      </ResponseAssertion>
-      <hashTree/>
-      <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract form key" enabled="true">
-        <stringProp name="RegexExtractor.useHeaders">false</stringProp>
-        <stringProp name="RegexExtractor.refname">admin_form_key</stringProp>
-        <stringProp name="RegexExtractor.regex">&lt;input name="form_key" type="hidden" value="([^'"]+)" /&gt;</stringProp>
-        <stringProp name="RegexExtractor.template">$1$</stringProp>
-        <stringProp name="RegexExtractor.default"/>
-        <stringProp name="RegexExtractor.match_number">1</stringProp>
-      </RegexExtractor>
-      <hashTree/>
-      <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert form_key extracted" enabled="true">
-        <collectionProp name="Asserion.test_strings">
-          <stringProp name="2845929">^.+$</stringProp>
-        </collectionProp>
-        <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
-        <boolProp name="Assertion.assume_success">false</boolProp>
-        <intProp name="Assertion.test_type">1</intProp>
-        <stringProp name="Assertion.scope">variable</stringProp>
-        <stringProp name="Scope.variable">admin_form_key</stringProp>
-      </ResponseAssertion>
-      <hashTree/>
-    </hashTree>
-  
-    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="SetUp - Login Submit Form" enabled="true">
-      <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
-        <collectionProp name="Arguments.arguments">
-          <elementProp name="dummy" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value"/>
-            <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">dummy</stringProp>
-          </elementProp>
-          <elementProp name="form_key" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">${admin_form_key}</stringProp>
-            <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">form_key</stringProp>
-          </elementProp>
-          <elementProp name="login[password]" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">${admin_password}</stringProp>
-            <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">login[password]</stringProp>
-          </elementProp>
-          <elementProp name="login[username]" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">${admin_user}</stringProp>
-            <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">login[username]</stringProp>
-          </elementProp>
-        </collectionProp>
-      </elementProp>
-      <stringProp name="HTTPSampler.domain"/>
-      <stringProp name="HTTPSampler.port"/>
-      <stringProp name="HTTPSampler.connect_timeout"/>
-      <stringProp name="HTTPSampler.response_timeout"/>
-      <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
-      <stringProp name="HTTPSampler.contentEncoding"/>
-      <stringProp name="HTTPSampler.path">${base_path}${admin_path}/admin/dashboard/</stringProp>
-      <stringProp name="HTTPSampler.method">POST</stringProp>
-      <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
-      <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
-      <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
-      <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
-      <stringProp name="HTTPSampler.implementation">Java</stringProp>
-      <boolProp name="HTTPSampler.monitor">false</boolProp>
-      <stringProp name="HTTPSampler.embedded_url_re"/>
-      <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_login/admin_login_submit_form.jmx</stringProp>
-    </HTTPSamplerProxy>
-    <hashTree/>
-  
-    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="SetUp - Set ${gridEntityType} Pages Count" enabled="true">
-      <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
-        <collectionProp name="Arguments.arguments">
-          <elementProp name="namespace" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">${grid_namespace}</stringProp>
-            <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">namespace</stringProp>
-            <stringProp name="Argument.desc">true</stringProp>
-          </elementProp>
-          <elementProp name="search" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value"/>
-            <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">search</stringProp>
-            <stringProp name="Argument.desc">true</stringProp>
-          </elementProp>
-          <elementProp name="filters[placeholder]" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">true</stringProp>
-            <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">filters[placeholder]</stringProp>
-            <stringProp name="Argument.desc">true</stringProp>
-          </elementProp>
-          <elementProp name="paging[pageSize]" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">${grid_entity_page_size}</stringProp>
-            <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">paging[pageSize]</stringProp>
-            <stringProp name="Argument.desc">true</stringProp>
-          </elementProp>
-          <elementProp name="paging[current]" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">1</stringProp>
-            <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">paging[current]</stringProp>
-            <stringProp name="Argument.desc">true</stringProp>
-          </elementProp>
-          <elementProp name="sorting[field]" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">entity_id</stringProp>
-            <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">sorting[field]</stringProp>
-            <stringProp name="Argument.desc">true</stringProp>
-          </elementProp>
-          <elementProp name="sorting[direction]" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">asc</stringProp>
-            <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">sorting[direction]</stringProp>
-            <stringProp name="Argument.desc">true</stringProp>
-          </elementProp>
-          <elementProp name="isAjax" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">true</stringProp>
-            <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">isAjax</stringProp>
-            <stringProp name="Argument.desc">true</stringProp>
-          </elementProp>
-        </collectionProp>
-      </elementProp>
-      <stringProp name="HTTPSampler.domain"/>
-      <stringProp name="HTTPSampler.port"/>
-      <stringProp name="HTTPSampler.connect_timeout"/>
-      <stringProp name="HTTPSampler.response_timeout"/>
-      <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
-      <stringProp name="HTTPSampler.contentEncoding"/>
-      <stringProp name="HTTPSampler.path">${base_path}${admin_path}/mui/index/render/</stringProp>
-      <stringProp name="HTTPSampler.method">GET</stringProp>
-      <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
-      <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
-      <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
-      <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
-      <boolProp name="HTTPSampler.monitor">false</boolProp>
-      <stringProp name="HTTPSampler.embedded_url_re"/>
-    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_grid_browsing/set_pages_count.jmx</stringProp></HTTPSamplerProxy>
-    <hashTree>
-      <com.atlantbh.jmeter.plugins.jsonutils.jsonpathassertion.JSONPathAssertion guiclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathassertion.gui.JSONPathAssertionGui" testclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathassertion.JSONPathAssertion" testname="Assert total records is not 0" enabled="true">
-        <stringProp name="JSON_PATH">$.totalRecords</stringProp>
-        <stringProp name="EXPECTED_VALUE">0</stringProp>
-        <boolProp name="JSONVALIDATION">true</boolProp>
-        <boolProp name="EXPECT_NULL">false</boolProp>
-        <boolProp name="INVERT">true</boolProp>
-      </com.atlantbh.jmeter.plugins.jsonutils.jsonpathassertion.JSONPathAssertion>
-      <hashTree/>
-      <com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor guiclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.gui.JSONPathExtractorGui" testclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor" testname="Extract total records" enabled="true">
-        <stringProp name="VAR">entity_total_records</stringProp>
-        <stringProp name="JSONPATH">$.totalRecords</stringProp>
-        <stringProp name="DEFAULT"/>
-        <stringProp name="VARIABLE"/>
-        <stringProp name="SUBJECT">BODY</stringProp>
-      </com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor>
-      <hashTree/>
-      <JSR223PostProcessor guiclass="TestBeanGUI" testclass="JSR223PreProcessor" testname="SetUp - Calculate ${gridEntityType} pages count" enabled="true">
-        <stringProp name="cacheKey"/>
-        <stringProp name="filename"/>
-        <stringProp name="parameters"/>
-        <stringProp name="script">
-          var pageSize = parseInt(vars.get("grid_entity_page_size")) || 20;
-          var totalsRecord = parseInt(vars.get("entity_total_records"));
-          var pageCount = Math.round(totalsRecord/pageSize);
-
-          vars.put("grid_pages_count", pageCount);
-        </stringProp>
-        <stringProp name="scriptLanguage">javascript</stringProp>
-      </JSR223PostProcessor>
-      <hashTree/>
-    </hashTree>
-  
-    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="SetUp - Set ${gridEntityType} Filtered Pages Count" enabled="true">
-      <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
-        <collectionProp name="Arguments.arguments">
-          <elementProp name="namespace" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">${grid_namespace}</stringProp>
-            <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">namespace</stringProp>
-            <stringProp name="Argument.desc">true</stringProp>
-          </elementProp>
-          <elementProp name="search" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value"/>
-            <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">search</stringProp>
-            <stringProp name="Argument.desc">true</stringProp>
-          </elementProp>
-          <elementProp name="filters[placeholder]" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">${grid_admin_browse_filter_text}</stringProp>
-            <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">filters[placeholder]</stringProp>
-            <stringProp name="Argument.desc">true</stringProp>
-          </elementProp>
-          <elementProp name="paging[pageSize]" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">${grid_entity_page_size}</stringProp>
-            <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">paging[pageSize]</stringProp>
-            <stringProp name="Argument.desc">true</stringProp>
-          </elementProp>
-          <elementProp name="paging[current]" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">1</stringProp>
-            <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">paging[current]</stringProp>
-            <stringProp name="Argument.desc">true</stringProp>
-          </elementProp>
-          <elementProp name="sorting[field]" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">entity_id</stringProp>
-            <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">sorting[field]</stringProp>
-            <stringProp name="Argument.desc">true</stringProp>
-          </elementProp>
-          <elementProp name="sorting[direction]" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">asc</stringProp>
-            <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">sorting[direction]</stringProp>
-            <stringProp name="Argument.desc">true</stringProp>
-          </elementProp>
-          <elementProp name="isAjax" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">true</stringProp>
-            <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">isAjax</stringProp>
-            <stringProp name="Argument.desc">true</stringProp>
-          </elementProp>
-        </collectionProp>
-      </elementProp>
-      <stringProp name="HTTPSampler.domain"/>
-      <stringProp name="HTTPSampler.port"/>
-      <stringProp name="HTTPSampler.connect_timeout"/>
-      <stringProp name="HTTPSampler.response_timeout"/>
-      <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
-      <stringProp name="HTTPSampler.contentEncoding"/>
-      <stringProp name="HTTPSampler.path">${base_path}${admin_path}/mui/index/render/</stringProp>
-      <stringProp name="HTTPSampler.method">GET</stringProp>
-      <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
-      <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
-      <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
-      <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
-      <boolProp name="HTTPSampler.monitor">false</boolProp>
-      <stringProp name="HTTPSampler.embedded_url_re"/>
-    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_grid_browsing/set_filtered_pages_count.jmx</stringProp></HTTPSamplerProxy>
-    <hashTree>
-      <com.atlantbh.jmeter.plugins.jsonutils.jsonpathassertion.JSONPathAssertion guiclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathassertion.gui.JSONPathAssertionGui" testclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathassertion.JSONPathAssertion" testname="Assert total records is not 0" enabled="true">
-        <stringProp name="JSON_PATH">$.totalRecords</stringProp>
-        <stringProp name="EXPECTED_VALUE">0</stringProp>
-        <boolProp name="JSONVALIDATION">true</boolProp>
-        <boolProp name="EXPECT_NULL">false</boolProp>
-        <boolProp name="INVERT">true</boolProp>
-        <boolProp name="ISREGEX">true</boolProp>
-      </com.atlantbh.jmeter.plugins.jsonutils.jsonpathassertion.JSONPathAssertion>
-      <hashTree/>
-      <com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor guiclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.gui.JSONPathExtractorGui" testclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor" testname="Extract total records" enabled="true">
-        <stringProp name="VAR">entity_total_records</stringProp>
-        <stringProp name="JSONPATH">$.totalRecords</stringProp>
-        <stringProp name="DEFAULT"/>
-        <stringProp name="VARIABLE"/>
-        <stringProp name="SUBJECT">BODY</stringProp>
-      </com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor>
-      <hashTree/>
-      <JSR223PostProcessor guiclass="TestBeanGUI" testclass="JSR223PreProcessor" testname="SetUp - Calculate ${gridEntityType} filtered pages count" enabled="true">
-        <stringProp name="parameters"/>
-        <stringProp name="filename"/>
-        <stringProp name="script">
-          var pageSize = parseInt(vars.get("grid_entity_page_size")) || 20;
-var totalsRecord = parseInt(vars.get("entity_total_records"));
-var pageCount = Math.round(totalsRecord/pageSize);
+        <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract address_postcode" enabled="true">
+          <stringProp name="RegexExtractor.useHeaders">false</stringProp>
+          <stringProp name="RegexExtractor.refname">admin_customer_address_postcode</stringProp>
+          <stringProp name="RegexExtractor.regex">"address":\{"\d+":{.+?"parent_id":"${admin_customer_entity_id}".+?"postcode":"([^"]+)"</stringProp>
+          <stringProp name="RegexExtractor.template">$1$</stringProp>
+          <stringProp name="RegexExtractor.default"/>
+          <stringProp name="RegexExtractor.match_number">1</stringProp>
+        </RegexExtractor>
+        <hashTree/>
+        <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract address_region" enabled="true">
+          <stringProp name="RegexExtractor.useHeaders">false</stringProp>
+          <stringProp name="RegexExtractor.refname">admin_customer_address_region</stringProp>
+          <stringProp name="RegexExtractor.regex">"address":\{"\d+":{.+?"parent_id":"${admin_customer_entity_id}".+?"region":"([^"]+)"</stringProp>
+          <stringProp name="RegexExtractor.template">$1$</stringProp>
+          <stringProp name="RegexExtractor.default"/>
+          <stringProp name="RegexExtractor.match_number">1</stringProp>
+        </RegexExtractor>
+        <hashTree/>
+        <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract address_region_id" enabled="true">
+          <stringProp name="RegexExtractor.useHeaders">false</stringProp>
+          <stringProp name="RegexExtractor.refname">admin_customer_address_region_id</stringProp>
+          <stringProp name="RegexExtractor.regex">"address":\{"\d+":{.+?"parent_id":"${admin_customer_entity_id}".+?"region_id":"([^"]+)"</stringProp>
+          <stringProp name="RegexExtractor.template">$1$</stringProp>
+          <stringProp name="RegexExtractor.default"/>
+          <stringProp name="RegexExtractor.match_number">1</stringProp>
+        </RegexExtractor>
+        <hashTree/>
+        <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract address street" enabled="true">
+          <stringProp name="RegexExtractor.useHeaders">false</stringProp>
+          <stringProp name="RegexExtractor.refname">admin_customer_address_street</stringProp>
+          <stringProp name="RegexExtractor.regex">"address":\{"\d+":{.+?"parent_id":"${admin_customer_entity_id}".+?"street":\["([^"]+)"\]</stringProp>
+          <stringProp name="RegexExtractor.template">$1$</stringProp>
+          <stringProp name="RegexExtractor.default"/>
+          <stringProp name="RegexExtractor.match_number">1</stringProp>
+        </RegexExtractor>
+        <hashTree/>
+        <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract address_telephone" enabled="true">
+          <stringProp name="RegexExtractor.useHeaders">false</stringProp>
+          <stringProp name="RegexExtractor.refname">admin_customer_address_telephone</stringProp>
+          <stringProp name="RegexExtractor.regex">"address":\{"\d+":{.+?"parent_id":"${admin_customer_entity_id}".+?"telephone":"([^"]+)"</stringProp>
+          <stringProp name="RegexExtractor.template">$1$</stringProp>
+          <stringProp name="RegexExtractor.default"/>
+          <stringProp name="RegexExtractor.match_number">1</stringProp>
+        </RegexExtractor>
+        <hashTree/>
+        <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract address_customer_id" enabled="true">
+          <stringProp name="RegexExtractor.useHeaders">false</stringProp>
+          <stringProp name="RegexExtractor.refname">admin_customer_address_customer_id</stringProp>
+          <stringProp name="RegexExtractor.regex">"address":\{"\d+":{.+?"parent_id":"${admin_customer_entity_id}".+?"customer_id":"([^"]+)"</stringProp>
+          <stringProp name="RegexExtractor.template">$1$</stringProp>
+          <stringProp name="RegexExtractor.default"/>
+          <stringProp name="RegexExtractor.match_number">1</stringProp>
+        </RegexExtractor>
+        <hashTree/>
+        <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert customer entity_id" enabled="true">
+          <collectionProp name="Asserion.test_strings">
+            <stringProp name="89649215">^\d+$</stringProp>
+          </collectionProp>
+          <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
+          <boolProp name="Assertion.assume_success">false</boolProp>
+          <intProp name="Assertion.test_type">1</intProp>
+          <stringProp name="Assertion.scope">variable</stringProp>
+          <stringProp name="Scope.variable">admin_customer_entity_id</stringProp>
+        </ResponseAssertion>
+        <hashTree/>
+        <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert website_id" enabled="true">
+          <collectionProp name="Asserion.test_strings">
+            <stringProp name="89649215">^\d+$</stringProp>
+          </collectionProp>
+          <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
+          <boolProp name="Assertion.assume_success">false</boolProp>
+          <intProp name="Assertion.test_type">1</intProp>
+          <stringProp name="Assertion.scope">variable</stringProp>
+          <stringProp name="Scope.variable">admin_customer_website_id</stringProp>
+        </ResponseAssertion>
+        <hashTree/>
+        <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert customer firstname" enabled="true">
+          <collectionProp name="Asserion.test_strings">
+            <stringProp name="2845929">^.+$</stringProp>
+          </collectionProp>
+          <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
+          <boolProp name="Assertion.assume_success">false</boolProp>
+          <intProp name="Assertion.test_type">1</intProp>
+          <stringProp name="Assertion.scope">variable</stringProp>
+          <stringProp name="Scope.variable">admin_customer_firstname</stringProp>
+        </ResponseAssertion>
+        <hashTree/>
+        <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert customer lastname" enabled="true">
+          <collectionProp name="Asserion.test_strings">
+            <stringProp name="2845929">^.+$</stringProp>
+          </collectionProp>
+          <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
+          <boolProp name="Assertion.assume_success">false</boolProp>
+          <intProp name="Assertion.test_type">1</intProp>
+          <stringProp name="Assertion.scope">variable</stringProp>
+          <stringProp name="Scope.variable">admin_customer_lastname</stringProp>
+        </ResponseAssertion>
+        <hashTree/>
+        <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert customer email" enabled="true">
+          <collectionProp name="Asserion.test_strings">
+            <stringProp name="2845929">^.+$</stringProp>
+          </collectionProp>
+          <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
+          <boolProp name="Assertion.assume_success">false</boolProp>
+          <intProp name="Assertion.test_type">1</intProp>
+          <stringProp name="Assertion.scope">variable</stringProp>
+          <stringProp name="Scope.variable">admin_customer_email</stringProp>
+        </ResponseAssertion>
+        <hashTree/>
+        <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert customer group_id" enabled="true">
+          <collectionProp name="Asserion.test_strings">
+            <stringProp name="89649215">^\d+$</stringProp>
+          </collectionProp>
+          <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
+          <boolProp name="Assertion.assume_success">false</boolProp>
+          <intProp name="Assertion.test_type">1</intProp>
+          <stringProp name="Assertion.scope">variable</stringProp>
+          <stringProp name="Scope.variable">admin_customer_group_id</stringProp>
+        </ResponseAssertion>
+        <hashTree/>
+        <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert customer store_id" enabled="true">
+          <collectionProp name="Asserion.test_strings">
+            <stringProp name="89649215">^\d+$</stringProp>
+          </collectionProp>
+          <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
+          <boolProp name="Assertion.assume_success">false</boolProp>
+          <intProp name="Assertion.test_type">1</intProp>
+          <stringProp name="Assertion.scope">variable</stringProp>
+          <stringProp name="Scope.variable">admin_customer_store_id</stringProp>
+        </ResponseAssertion>
+        <hashTree/>
+        <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert customer created_at" enabled="true">
+          <collectionProp name="Asserion.test_strings">
+            <stringProp name="2845929">^.+$</stringProp>
+          </collectionProp>
+          <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
+          <boolProp name="Assertion.assume_success">false</boolProp>
+          <intProp name="Assertion.test_type">1</intProp>
+          <stringProp name="Assertion.scope">variable</stringProp>
+          <stringProp name="Scope.variable">admin_customer_created_at</stringProp>
+        </ResponseAssertion>
+        <hashTree/>
+        <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert customer updated_at" enabled="true">
+          <collectionProp name="Asserion.test_strings">
+            <stringProp name="2845929">^.+$</stringProp>
+          </collectionProp>
+          <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
+          <boolProp name="Assertion.assume_success">false</boolProp>
+          <intProp name="Assertion.test_type">1</intProp>
+          <stringProp name="Assertion.scope">variable</stringProp>
+          <stringProp name="Scope.variable">admin_customer_updated_at</stringProp>
+        </ResponseAssertion>
+        <hashTree/>
+        <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert customer is_active" enabled="true">
+          <collectionProp name="Asserion.test_strings">
+            <stringProp name="89649215">^\d+$</stringProp>
+          </collectionProp>
+          <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
+          <boolProp name="Assertion.assume_success">false</boolProp>
+          <intProp name="Assertion.test_type">1</intProp>
+          <stringProp name="Assertion.scope">variable</stringProp>
+          <stringProp name="Scope.variable">admin_customer_is_active</stringProp>
+        </ResponseAssertion>
+        <hashTree/>
+        <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert customer disable_auto_group_change" enabled="true">
+          <collectionProp name="Asserion.test_strings">
+            <stringProp name="89649215">^\d+$</stringProp>
+          </collectionProp>
+          <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
+          <boolProp name="Assertion.assume_success">false</boolProp>
+          <intProp name="Assertion.test_type">1</intProp>
+          <stringProp name="Assertion.scope">variable</stringProp>
+          <stringProp name="Scope.variable">admin_customer_disable_auto_group_change</stringProp>
+        </ResponseAssertion>
+        <hashTree/>
+        <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert customer created_in" enabled="true">
+          <collectionProp name="Asserion.test_strings">
+            <stringProp name="2845929">^.+$</stringProp>
+          </collectionProp>
+          <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
+          <boolProp name="Assertion.assume_success">false</boolProp>
+          <intProp name="Assertion.test_type">1</intProp>
+          <stringProp name="Assertion.scope">variable</stringProp>
+          <stringProp name="Scope.variable">admin_customer_created_in</stringProp>
+        </ResponseAssertion>
+        <hashTree/>
+        <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert customer dob" enabled="true">
+          <collectionProp name="Asserion.test_strings">
+            <stringProp name="221072919">^\d+/\d+/\d+$</stringProp>
+          </collectionProp>
+          <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
+          <boolProp name="Assertion.assume_success">false</boolProp>
+          <intProp name="Assertion.test_type">1</intProp>
+          <stringProp name="Assertion.scope">variable</stringProp>
+          <stringProp name="Scope.variable">admin_customer_dob</stringProp>
+        </ResponseAssertion>
+        <hashTree/>
+        <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert customer default_billing" enabled="true">
+          <collectionProp name="Asserion.test_strings">
+            <stringProp name="89649215">^\d+$</stringProp>
+          </collectionProp>
+          <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
+          <boolProp name="Assertion.assume_success">false</boolProp>
+          <intProp name="Assertion.test_type">1</intProp>
+          <stringProp name="Assertion.scope">variable</stringProp>
+          <stringProp name="Scope.variable">admin_customer_default_billing</stringProp>
+        </ResponseAssertion>
+        <hashTree/>
+        <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert customer default_shipping" enabled="true">
+          <collectionProp name="Asserion.test_strings">
+            <stringProp name="89649215">^\d+$</stringProp>
+          </collectionProp>
+          <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
+          <boolProp name="Assertion.assume_success">false</boolProp>
+          <intProp name="Assertion.test_type">1</intProp>
+          <stringProp name="Assertion.scope">variable</stringProp>
+          <stringProp name="Scope.variable">admin_customer_default_shipping</stringProp>
+        </ResponseAssertion>
+        <hashTree/>
+        <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert customer gender" enabled="true">
+          <collectionProp name="Asserion.test_strings">
+            <stringProp name="89649215">^\d+$</stringProp>
+          </collectionProp>
+          <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
+          <boolProp name="Assertion.assume_success">false</boolProp>
+          <intProp name="Assertion.test_type">1</intProp>
+          <stringProp name="Assertion.scope">variable</stringProp>
+          <stringProp name="Scope.variable">admin_customer_gender</stringProp>
+        </ResponseAssertion>
+        <hashTree/>
+        <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert customer failures_num" enabled="true">
+          <collectionProp name="Asserion.test_strings">
+            <stringProp name="89649215">^\d+$</stringProp>
+          </collectionProp>
+          <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
+          <boolProp name="Assertion.assume_success">false</boolProp>
+          <intProp name="Assertion.test_type">1</intProp>
+          <stringProp name="Assertion.scope">variable</stringProp>
+          <stringProp name="Scope.variable">admin_customer_failures_num</stringProp>
+        </ResponseAssertion>
+        <hashTree/>
+        <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert address_entity_id" enabled="true">
+          <collectionProp name="Asserion.test_strings">
+            <stringProp name="89649215">^\d+$</stringProp>
+          </collectionProp>
+          <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
+          <boolProp name="Assertion.assume_success">false</boolProp>
+          <intProp name="Assertion.test_type">1</intProp>
+          <stringProp name="Assertion.scope">variable</stringProp>
+          <stringProp name="Scope.variable">admin_customer_address_entity_id</stringProp>
+        </ResponseAssertion>
+        <hashTree/>
+        <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert address_created_at" enabled="true">
+          <collectionProp name="Asserion.test_strings">
+            <stringProp name="2845929">^.+$</stringProp>
+          </collectionProp>
+          <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
+          <boolProp name="Assertion.assume_success">false</boolProp>
+          <intProp name="Assertion.test_type">1</intProp>
+          <stringProp name="Assertion.scope">variable</stringProp>
+          <stringProp name="Scope.variable">admin_customer_address_created_at</stringProp>
+        </ResponseAssertion>
+        <hashTree/>
+        <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert address_updated_at" enabled="true">
+          <collectionProp name="Asserion.test_strings">
+            <stringProp name="2845929">^.+$</stringProp>
+          </collectionProp>
+          <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
+          <boolProp name="Assertion.assume_success">false</boolProp>
+          <intProp name="Assertion.test_type">1</intProp>
+          <stringProp name="Assertion.scope">variable</stringProp>
+          <stringProp name="Scope.variable">admin_customer_address_updated_at</stringProp>
+        </ResponseAssertion>
+        <hashTree/>
+        <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert address_is_active" enabled="true">
+          <collectionProp name="Asserion.test_strings">
+            <stringProp name="89649215">^\d+$</stringProp>
+          </collectionProp>
+          <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
+          <boolProp name="Assertion.assume_success">false</boolProp>
+          <intProp name="Assertion.test_type">1</intProp>
+          <stringProp name="Assertion.scope">variable</stringProp>
+          <stringProp name="Scope.variable">admin_customer_address_is_active</stringProp>
+        </ResponseAssertion>
+        <hashTree/>
+        <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert address_city" enabled="true">
+          <collectionProp name="Asserion.test_strings">
+            <stringProp name="2845929">^.+$</stringProp>
+          </collectionProp>
+          <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
+          <boolProp name="Assertion.assume_success">false</boolProp>
+          <intProp name="Assertion.test_type">1</intProp>
+          <stringProp name="Assertion.scope">variable</stringProp>
+          <stringProp name="Scope.variable">admin_customer_address_city</stringProp>
+        </ResponseAssertion>
+        <hashTree/>
+        <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert address_country_id" enabled="true">
+          <collectionProp name="Asserion.test_strings">
+            <stringProp name="2845929">^.+$</stringProp>
+          </collectionProp>
+          <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
+          <boolProp name="Assertion.assume_success">false</boolProp>
+          <intProp name="Assertion.test_type">1</intProp>
+          <stringProp name="Assertion.scope">variable</stringProp>
+          <stringProp name="Scope.variable">admin_customer_address_country_id</stringProp>
+        </ResponseAssertion>
+        <hashTree/>
+        <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert address_firstname" enabled="true">
+          <collectionProp name="Asserion.test_strings">
+            <stringProp name="2845929">^.+$</stringProp>
+          </collectionProp>
+          <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
+          <boolProp name="Assertion.assume_success">false</boolProp>
+          <intProp name="Assertion.test_type">1</intProp>
+          <stringProp name="Assertion.scope">variable</stringProp>
+          <stringProp name="Scope.variable">admin_customer_address_firstname</stringProp>
+        </ResponseAssertion>
+        <hashTree/>
+        <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert address_lastname" enabled="true">
+          <collectionProp name="Asserion.test_strings">
+            <stringProp name="2845929">^.+$</stringProp>
+          </collectionProp>
+          <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
+          <boolProp name="Assertion.assume_success">false</boolProp>
+          <intProp name="Assertion.test_type">1</intProp>
+          <stringProp name="Assertion.scope">variable</stringProp>
+          <stringProp name="Scope.variable">admin_customer_address_lastname</stringProp>
+        </ResponseAssertion>
+        <hashTree/>
+        <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert address_postcode" enabled="true">
+          <collectionProp name="Asserion.test_strings">
+            <stringProp name="2845929">^.+$</stringProp>
+          </collectionProp>
+          <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
+          <boolProp name="Assertion.assume_success">false</boolProp>
+          <intProp name="Assertion.test_type">1</intProp>
+          <stringProp name="Assertion.scope">variable</stringProp>
+          <stringProp name="Scope.variable">admin_customer_address_postcode</stringProp>
+        </ResponseAssertion>
+        <hashTree/>
+        <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert address_region" enabled="true">
+          <collectionProp name="Asserion.test_strings">
+            <stringProp name="2845929">^.+$</stringProp>
+          </collectionProp>
+          <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
+          <boolProp name="Assertion.assume_success">false</boolProp>
+          <intProp name="Assertion.test_type">1</intProp>
+          <stringProp name="Assertion.scope">variable</stringProp>
+          <stringProp name="Scope.variable">admin_customer_address_region</stringProp>
+        </ResponseAssertion>
+        <hashTree/>
+        <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert address_region_id" enabled="true">
+          <collectionProp name="Asserion.test_strings">
+            <stringProp name="89649215">^\d+$</stringProp>
+          </collectionProp>
+          <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
+          <boolProp name="Assertion.assume_success">false</boolProp>
+          <intProp name="Assertion.test_type">1</intProp>
+          <stringProp name="Assertion.scope">variable</stringProp>
+          <stringProp name="Scope.variable">admin_customer_address_region_id</stringProp>
+        </ResponseAssertion>
+        <hashTree/>
+        <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert address_street" enabled="true">
+          <collectionProp name="Asserion.test_strings">
+            <stringProp name="2845929">^.+$</stringProp>
+          </collectionProp>
+          <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
+          <boolProp name="Assertion.assume_success">false</boolProp>
+          <intProp name="Assertion.test_type">1</intProp>
+          <stringProp name="Assertion.scope">variable</stringProp>
+          <stringProp name="Scope.variable">admin_customer_address_street</stringProp>
+        </ResponseAssertion>
+        <hashTree/>
+        <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert address_telephone" enabled="true">
+          <collectionProp name="Asserion.test_strings">
+            <stringProp name="2845929">^.+$</stringProp>
+          </collectionProp>
+          <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
+          <boolProp name="Assertion.assume_success">false</boolProp>
+          <intProp name="Assertion.test_type">1</intProp>
+          <stringProp name="Assertion.scope">variable</stringProp>
+          <stringProp name="Scope.variable">admin_customer_address_telephone</stringProp>
+        </ResponseAssertion>
+        <hashTree/>
+        <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert address_customer_id" enabled="true">
+          <collectionProp name="Asserion.test_strings">
+            <stringProp name="89649215">^\d+$</stringProp>
+          </collectionProp>
+          <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
+          <boolProp name="Assertion.assume_success">false</boolProp>
+          <intProp name="Assertion.test_type">1</intProp>
+          <stringProp name="Assertion.scope">variable</stringProp>
+          <stringProp name="Scope.variable">admin_customer_address_customer_id</stringProp>
+        </ResponseAssertion>
+        <hashTree/>
+        <HeaderManager guiclass="HeaderPanel" testclass="HeaderManager" testname="HTTP Header Manager" enabled="true">
+          <collectionProp name="HeaderManager.headers">
+            <elementProp name="Accept-Language" elementType="Header">
+              <stringProp name="Header.name">Accept-Language</stringProp>
+              <stringProp name="Header.value">en-US,en;q=0.5</stringProp>
+            </elementProp>
+            <elementProp name="Accept" elementType="Header">
+              <stringProp name="Header.name">Accept</stringProp>
+              <stringProp name="Header.value">text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8</stringProp>
+            </elementProp>
+            <elementProp name="User-Agent" elementType="Header">
+              <stringProp name="Header.name">User-Agent</stringProp>
+              <stringProp name="Header.value">Mozilla/5.0 (Windows NT 6.1; WOW64; rv:27.0) Gecko/20100101 Firefox/27.0</stringProp>
+            </elementProp>
+            <elementProp name="Accept-Encoding" elementType="Header">
+              <stringProp name="Header.name">Accept-Encoding</stringProp>
+              <stringProp name="Header.value">gzip, deflate</stringProp>
+            </elementProp>
+          </collectionProp>
+        </HeaderManager>
+        <hashTree/>
+      </hashTree>
+      <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Customer Validate" enabled="true">
+        <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
+          <collectionProp name="Arguments.arguments">
+            <elementProp name="isAjax   " elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">true</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">isAjax   </stringProp>
+            </elementProp>
+            <elementProp name="customer[entity_id]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">${admin_customer_entity_id}</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">customer[entity_id]</stringProp>
+            </elementProp>
+            <elementProp name="customer[website_id]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">${admin_customer_website_id}</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">customer[website_id]</stringProp>
+            </elementProp>
+            <elementProp name="customer[email]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">${admin_customer_email}</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">customer[email]</stringProp>
+            </elementProp>
+            <elementProp name="customer[group_id]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">${admin_customer_group_id}</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">customer[group_id]</stringProp>
+            </elementProp>
+            <elementProp name="customer[store_id]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">${admin_customer_store_id}</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">customer[store_id]</stringProp>
+            </elementProp>
+            <elementProp name="customer[created_at]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">${admin_customer_created_at}</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">customer[created_at]</stringProp>
+            </elementProp>
+            <elementProp name="customer[updated_at]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">${admin_customer_updated_at}</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">customer[updated_at]</stringProp>
+            </elementProp>
+            <elementProp name="customer[is_active]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">${admin_customer_is_active}</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">customer[is_active]</stringProp>
+            </elementProp>
+            <elementProp name="customer[disable_auto_group_change]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">${admin_customer_disable_auto_group_change}</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">customer[disable_auto_group_change]</stringProp>
+            </elementProp>
+            <elementProp name="customer[created_in]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">${admin_customer_created_in}</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">customer[created_in]</stringProp>
+            </elementProp>
+            <elementProp name="customer[prefix]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value"/>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">customer[prefix]</stringProp>
+            </elementProp>
+            <elementProp name="customer[firstname]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">${admin_customer_firstname} 1</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">customer[firstname]</stringProp>
+            </elementProp>
+            <elementProp name="customer[middlename]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value"/>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">customer[middlename]</stringProp>
+            </elementProp>
+            <elementProp name="customer[lastname]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">${admin_customer_lastname} 1</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">customer[lastname]</stringProp>
+            </elementProp>
+            <elementProp name="customer[suffix]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value"/>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">customer[suffix]</stringProp>
+            </elementProp>
+            <elementProp name="customer[dob]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">${admin_customer_dob}</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">customer[dob]</stringProp>
+            </elementProp>
+            <elementProp name="customer[default_billing]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">${admin_customer_default_billing}</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">customer[default_billing]</stringProp>
+            </elementProp>
+            <elementProp name="customer[default_shipping]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">${admin_customer_default_shipping}</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">customer[default_shipping]</stringProp>
+            </elementProp>
+            <elementProp name="customer[taxvat]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value"/>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">customer[taxvat]</stringProp>
+            </elementProp>
+            <elementProp name="customer[gender]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">${admin_customer_gender}</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">customer[gender]</stringProp>
+            </elementProp>
+            <elementProp name="customer[failures_num]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">${admin_customer_failures_num}</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">customer[failures_num]</stringProp>
+            </elementProp>
+            <elementProp name="customer[sendemail_store_id]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">${admin_customer_store_id}</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">customer[sendemail_store_id]</stringProp>
+            </elementProp>
+            <elementProp name="address[${admin_customer_address_entity_id}][entity_id]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">${admin_customer_address_entity_id}</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">address[${admin_customer_address_entity_id}][entity_id]</stringProp>
+            </elementProp>
+            <elementProp name="address[${admin_customer_address_entity_id}][created_at]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">${admin_customer_address_created_at}</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">address[${admin_customer_address_entity_id}][created_at]</stringProp>
+            </elementProp>
+            <elementProp name="address[${admin_customer_address_entity_id}][updated_at]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">${admin_customer_address_updated_at}</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">address[${admin_customer_address_entity_id}][updated_at]</stringProp>
+            </elementProp>
+            <elementProp name="address[${admin_customer_address_entity_id}][is_active]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">${admin_customer_address_is_active}</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">address[${admin_customer_address_entity_id}][is_active]</stringProp>
+            </elementProp>
+            <elementProp name="address[${admin_customer_address_entity_id}][city]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">${admin_customer_address_city}</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">address[${admin_customer_address_entity_id}][city]</stringProp>
+            </elementProp>
+            <elementProp name="address[${admin_customer_address_entity_id}][company]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value"/>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">address[${admin_customer_address_entity_id}][company]</stringProp>
+            </elementProp>
+            <elementProp name="address[${admin_customer_address_entity_id}][country_id]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">${admin_customer_address_country_id}</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">address[${admin_customer_address_entity_id}][country_id]</stringProp>
+            </elementProp>
+            <elementProp name="address[${admin_customer_address_entity_id}][firstname]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">${admin_customer_address_firstname}</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">address[${admin_customer_address_entity_id}][firstname]</stringProp>
+            </elementProp>
+            <elementProp name="address[${admin_customer_address_entity_id}][lastname]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">${admin_customer_address_lastname}</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">address[${admin_customer_address_entity_id}][lastname]</stringProp>
+            </elementProp>
+            <elementProp name="address[${admin_customer_address_entity_id}][middlename]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value"/>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">address[${admin_customer_address_entity_id}][middlename]</stringProp>
+            </elementProp>
+            <elementProp name="address[${admin_customer_address_entity_id}][postcode]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">${admin_customer_address_postcode}</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">address[${admin_customer_address_entity_id}][postcode]</stringProp>
+            </elementProp>
+            <elementProp name="address[${admin_customer_address_entity_id}][prefix]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value"/>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">address[${admin_customer_address_entity_id}][prefix]</stringProp>
+            </elementProp>
+            <elementProp name="address[${admin_customer_address_entity_id}][region]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">${admin_customer_address_region}</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">address[${admin_customer_address_entity_id}][region]</stringProp>
+            </elementProp>
+            <elementProp name="address[${admin_customer_address_entity_id}][region_id]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">${admin_customer_address_region_id}</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">address[${admin_customer_address_entity_id}][region_id]</stringProp>
+            </elementProp>
+            <elementProp name="address[${admin_customer_address_entity_id}][street][0]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">${admin_customer_address_street}</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">address[${admin_customer_address_entity_id}][street][0]</stringProp>
+            </elementProp>
+            <elementProp name="address[${admin_customer_address_entity_id}][street][1]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value"/>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">address[${admin_customer_address_entity_id}][street][1]</stringProp>
+            </elementProp>
+            <elementProp name="address[${admin_customer_address_entity_id}][suffix]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value"/>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">address[${admin_customer_address_entity_id}][suffix]</stringProp>
+            </elementProp>
+            <elementProp name="address[${admin_customer_address_entity_id}][telephone]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">${admin_customer_address_telephone}</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">address[${admin_customer_address_entity_id}][telephone]</stringProp>
+            </elementProp>
+            <elementProp name="address[${admin_customer_address_entity_id}][vat_id]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value"/>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">address[${admin_customer_address_entity_id}][vat_id]</stringProp>
+            </elementProp>
+            <elementProp name="address[${admin_customer_address_entity_id}][customer_id]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">${admin_customer_address_customer_id}</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">address[${admin_customer_address_entity_id}][customer_id]</stringProp>
+            </elementProp>
+            <elementProp name="address[${admin_customer_address_entity_id}][default_billing]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">true</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">address[${admin_customer_address_entity_id}][default_billing]</stringProp>
+            </elementProp>
+            <elementProp name="address[${admin_customer_address_entity_id}][default_shipping]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">true</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">address[${admin_customer_address_entity_id}][default_shipping]</stringProp>
+            </elementProp>
+            <elementProp name="address[new_0][prefix]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value"/>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">address[new_0][prefix]</stringProp>
+            </elementProp>
+            <elementProp name="address[new_0][firstname]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">John</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">address[new_0][firstname]</stringProp>
+            </elementProp>
+            <elementProp name="address[new_0][middlename]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value"/>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">address[new_0][middlename]</stringProp>
+            </elementProp>
+            <elementProp name="address[new_0][lastname]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">Doe</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">address[new_0][lastname]</stringProp>
+            </elementProp>
+            <elementProp name="address[new_0][suffix]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value"/>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">address[new_0][suffix]</stringProp>
+            </elementProp>
+            <elementProp name="address[new_0][company]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">Test Company</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">address[new_0][company]</stringProp>
+            </elementProp>
+            <elementProp name="address[new_0][city]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">Folsom</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">address[new_0][city]</stringProp>
+            </elementProp>
+            <elementProp name="address[new_0][postcode]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">95630</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">address[new_0][postcode]</stringProp>
+            </elementProp>
+            <elementProp name="address[new_0][telephone]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">1234567890</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">address[new_0][telephone]</stringProp>
+            </elementProp>
+            <elementProp name="address[new_0][vat_id]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value"/>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">address[new_0][vat_id]</stringProp>
+            </elementProp>
+            <elementProp name="address[new_0][default_billing]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">false</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">address[new_0][default_billing]</stringProp>
+            </elementProp>
+            <elementProp name="address[new_0][default_shipping]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">false</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">address[new_0][default_shipping]</stringProp>
+            </elementProp>
+            <elementProp name="address[new_0][street][0]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">123 Main</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">address[new_0][street][0]</stringProp>
+            </elementProp>
+            <elementProp name="address[new_0][street][1]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value"/>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">address[new_0][street][1]</stringProp>
+            </elementProp>
+            <elementProp name="address[new_0][region]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value"/>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">address[new_0][region]</stringProp>
+            </elementProp>
+            <elementProp name="address[new_0][country_id]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">US</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">address[new_0][country_id]</stringProp>
+            </elementProp>
+            <elementProp name="address[new_0][region_id]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">12</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">address[new_0][region_id]</stringProp>
+            </elementProp>
+            <elementProp name="form_key" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">${admin_form_key}</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">form_key</stringProp>
+            </elementProp>
+          </collectionProp>
+        </elementProp>
+        <stringProp name="HTTPSampler.domain"/>
+        <stringProp name="HTTPSampler.port"/>
+        <stringProp name="HTTPSampler.connect_timeout"/>
+        <stringProp name="HTTPSampler.response_timeout"/>
+        <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
+        <stringProp name="HTTPSampler.contentEncoding"/>
+        <stringProp name="HTTPSampler.path">${base_path}${admin_path}/customer/index/validate/</stringProp>
+        <stringProp name="HTTPSampler.method">POST</stringProp>
+        <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
+        <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
+        <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
+        <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
+        <boolProp name="HTTPSampler.monitor">false</boolProp>
+        <stringProp name="HTTPSampler.embedded_url_re"/>
+      </HTTPSamplerProxy>
+      <hashTree>
+        <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Response Assertion" enabled="true">
+          <collectionProp name="Asserion.test_strings">
+            <stringProp name="49586">200</stringProp>
+          </collectionProp>
+          <stringProp name="Assertion.test_field">Assertion.response_code</stringProp>
+          <boolProp name="Assertion.assume_success">false</boolProp>
+          <intProp name="Assertion.test_type">16</intProp>
+        </ResponseAssertion>
+        <hashTree/>
+      </hashTree>
+      <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Customer Save" enabled="true">
+        <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
+          <collectionProp name="Arguments.arguments">
+            <elementProp name="isAjax   " elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">true</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">isAjax   </stringProp>
+            </elementProp>
+            <elementProp name="customer[entity_id]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">${admin_customer_entity_id}</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">customer[entity_id]</stringProp>
+            </elementProp>
+            <elementProp name="customer[website_id]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">${admin_customer_website_id}</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">customer[website_id]</stringProp>
+            </elementProp>
+            <elementProp name="customer[email]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">${admin_customer_email}</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">customer[email]</stringProp>
+            </elementProp>
+            <elementProp name="customer[group_id]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">${admin_customer_group_id}</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">customer[group_id]</stringProp>
+            </elementProp>
+            <elementProp name="customer[store_id]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">${admin_customer_store_id}</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">customer[store_id]</stringProp>
+            </elementProp>
+            <elementProp name="customer[created_at]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">${admin_customer_created_at}</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">customer[created_at]</stringProp>
+            </elementProp>
+            <elementProp name="customer[updated_at]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">${admin_customer_updated_at}</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">customer[updated_at]</stringProp>
+            </elementProp>
+            <elementProp name="customer[is_active]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">${admin_customer_is_active}</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">customer[is_active]</stringProp>
+            </elementProp>
+            <elementProp name="customer[disable_auto_group_change]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">${admin_customer_disable_auto_group_change}</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">customer[disable_auto_group_change]</stringProp>
+            </elementProp>
+            <elementProp name="customer[created_in]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">${admin_customer_created_in}</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">customer[created_in]</stringProp>
+            </elementProp>
+            <elementProp name="customer[prefix]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value"/>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">customer[prefix]</stringProp>
+            </elementProp>
+            <elementProp name="customer[firstname]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">${admin_customer_firstname} 1</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">customer[firstname]</stringProp>
+            </elementProp>
+            <elementProp name="customer[middlename]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value"/>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">customer[middlename]</stringProp>
+            </elementProp>
+            <elementProp name="customer[lastname]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">${admin_customer_lastname} 1</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">customer[lastname]</stringProp>
+            </elementProp>
+            <elementProp name="customer[suffix]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value"/>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">customer[suffix]</stringProp>
+            </elementProp>
+            <elementProp name="customer[dob]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">${admin_customer_dob}</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">customer[dob]</stringProp>
+            </elementProp>
+            <elementProp name="customer[default_billing]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">${admin_customer_default_billing}</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">customer[default_billing]</stringProp>
+            </elementProp>
+            <elementProp name="customer[default_shipping]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">${admin_customer_default_shipping}</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">customer[default_shipping]</stringProp>
+            </elementProp>
+            <elementProp name="customer[taxvat]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value"/>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">customer[taxvat]</stringProp>
+            </elementProp>
+            <elementProp name="customer[gender]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">${admin_customer_gender}</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">customer[gender]</stringProp>
+            </elementProp>
+            <elementProp name="customer[failures_num]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">${admin_customer_failures_num}</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">customer[failures_num]</stringProp>
+            </elementProp>
+            <elementProp name="customer[sendemail_store_id]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">${admin_customer_store_id}</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">customer[sendemail_store_id]</stringProp>
+            </elementProp>
+            <elementProp name="address[${admin_customer_address_entity_id}][entity_id]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">${admin_customer_address_entity_id}</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">address[${admin_customer_address_entity_id}][entity_id]</stringProp>
+            </elementProp>
 
-vars.put("grid_pages_count_filtered", pageCount);
-        </stringProp>
-        <stringProp name="scriptLanguage">javascript</stringProp>
-      </JSR223PostProcessor>
+            <elementProp name="address[${admin_customer_address_entity_id}][created_at]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">${admin_customer_address_created_at}</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">address[${admin_customer_address_entity_id}][created_at]</stringProp>
+            </elementProp>
+            <elementProp name="address[${admin_customer_address_entity_id}][updated_at]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">${admin_customer_address_updated_at}</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">address[${admin_customer_address_entity_id}][updated_at]</stringProp>
+            </elementProp>
+            <elementProp name="address[${admin_customer_address_entity_id}][is_active]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">${admin_customer_address_is_active}</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">address[${admin_customer_address_entity_id}][is_active]</stringProp>
+            </elementProp>
+            <elementProp name="address[${admin_customer_address_entity_id}][city]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">${admin_customer_address_city}</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">address[${admin_customer_address_entity_id}][city]</stringProp>
+            </elementProp>
+            <elementProp name="address[${admin_customer_address_entity_id}][company]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value"/>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">address[${admin_customer_address_entity_id}][company]</stringProp>
+            </elementProp>
+            <elementProp name="address[${admin_customer_address_entity_id}][country_id]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">${admin_customer_address_country_id}</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">address[${admin_customer_address_entity_id}][country_id]</stringProp>
+            </elementProp>
+            <elementProp name="address[${admin_customer_address_entity_id}][firstname]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">${admin_customer_address_firstname}</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">address[${admin_customer_address_entity_id}][firstname]</stringProp>
+            </elementProp>
+            <elementProp name="address[${admin_customer_address_entity_id}][lastname]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">${admin_customer_address_lastname}</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">address[${admin_customer_address_entity_id}][lastname]</stringProp>
+            </elementProp>
+            <elementProp name="address[${admin_customer_address_entity_id}][middlename]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value"/>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">address[${admin_customer_address_entity_id}][middlename]</stringProp>
+            </elementProp>
+            <elementProp name="address[${admin_customer_address_entity_id}][postcode]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">${admin_customer_address_postcode}</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">address[${admin_customer_address_entity_id}][postcode]</stringProp>
+            </elementProp>
+            <elementProp name="address[${admin_customer_address_entity_id}][prefix]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value"/>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">address[${admin_customer_address_entity_id}][prefix]</stringProp>
+            </elementProp>
+            <elementProp name="address[${admin_customer_address_entity_id}][region]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">${admin_customer_address_region}</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">address[${admin_customer_address_entity_id}][region]</stringProp>
+            </elementProp>
+            <elementProp name="address[${admin_customer_address_entity_id}][region_id]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">${admin_customer_address_region_id}</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">address[${admin_customer_address_entity_id}][region_id]</stringProp>
+            </elementProp>
+            <elementProp name="address[${admin_customer_address_entity_id}][street][0]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">${admin_customer_address_street}</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">address[${admin_customer_address_entity_id}][street][0]</stringProp>
+            </elementProp>
+            <elementProp name="address[${admin_customer_address_entity_id}][street][1]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value"/>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">address[${admin_customer_address_entity_id}][street][1]</stringProp>
+            </elementProp>
+            <elementProp name="address[${admin_customer_address_entity_id}][suffix]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value"/>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">address[${admin_customer_address_entity_id}][suffix]</stringProp>
+            </elementProp>
+            <elementProp name="address[${admin_customer_address_entity_id}][telephone]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">${admin_customer_address_telephone}</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">address[${admin_customer_address_entity_id}][telephone]</stringProp>
+            </elementProp>
+            <elementProp name="address[${admin_customer_address_entity_id}][vat_id]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value"/>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">address[${admin_customer_address_entity_id}][vat_id]</stringProp>
+            </elementProp>
+            <elementProp name="address[${admin_customer_address_entity_id}][customer_id]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">${admin_customer_address_customer_id}</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">address[${admin_customer_address_entity_id}][customer_id]</stringProp>
+            </elementProp>
+            <elementProp name="address[${admin_customer_address_entity_id}][default_billing]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">true</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">address[${admin_customer_address_entity_id}][default_billing]</stringProp>
+            </elementProp>
+            <elementProp name="address[${admin_customer_address_entity_id}][default_shipping]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">true</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">address[${admin_customer_address_entity_id}][default_shipping]</stringProp>
+            </elementProp>
+            <elementProp name="address[new_0][prefix]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value"/>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">address[new_0][prefix]</stringProp>
+            </elementProp>
+            <elementProp name="address[new_0][firstname]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">John</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">address[new_0][firstname]</stringProp>
+            </elementProp>
+            <elementProp name="address[new_0][middlename]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value"/>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">address[new_0][middlename]</stringProp>
+            </elementProp>
+            <elementProp name="address[new_0][lastname]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">Doe</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">address[new_0][lastname]</stringProp>
+            </elementProp>
+            <elementProp name="address[new_0][suffix]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value"/>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">address[new_0][suffix]</stringProp>
+            </elementProp>
+            <elementProp name="address[new_0][company]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">Test Company</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">address[new_0][company]</stringProp>
+            </elementProp>
+            <elementProp name="address[new_0][city]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">Folsom</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">address[new_0][city]</stringProp>
+            </elementProp>
+            <elementProp name="address[new_0][postcode]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">95630</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">address[new_0][postcode]</stringProp>
+            </elementProp>
+            <elementProp name="address[new_0][telephone]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">1234567890</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">address[new_0][telephone]</stringProp>
+            </elementProp>
+            <elementProp name="address[new_0][vat_id]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value"/>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">address[new_0][vat_id]</stringProp>
+            </elementProp>
+            <elementProp name="address[new_0][default_billing]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">false</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">address[new_0][default_billing]</stringProp>
+            </elementProp>
+            <elementProp name="address[new_0][default_shipping]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">false</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">address[new_0][default_shipping]</stringProp>
+            </elementProp>
+            <elementProp name="address[new_0][street][0]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">123 Main</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">address[new_0][street][0]</stringProp>
+            </elementProp>
+            <elementProp name="address[new_0][street][1]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value"/>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">address[new_0][street][1]</stringProp>
+            </elementProp>
+            <elementProp name="address[new_0][region]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value"/>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">address[new_0][region]</stringProp>
+            </elementProp>
+            <elementProp name="address[new_0][country_id]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">US</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">address[new_0][country_id]</stringProp>
+            </elementProp>
+            <elementProp name="address[new_0][region_id]" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">12</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">address[new_0][region_id]</stringProp>
+            </elementProp>
+            <elementProp name="form_key" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">true</boolProp>
+              <stringProp name="Argument.value">${admin_form_key}</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+              <boolProp name="HTTPArgument.use_equals">true</boolProp>
+              <stringProp name="Argument.name">form_key</stringProp>
+            </elementProp>
+          </collectionProp>
+        </elementProp>
+        <stringProp name="HTTPSampler.domain"/>
+        <stringProp name="HTTPSampler.port"/>
+        <stringProp name="HTTPSampler.connect_timeout"/>
+        <stringProp name="HTTPSampler.response_timeout"/>
+        <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
+        <stringProp name="HTTPSampler.contentEncoding"/>
+        <stringProp name="HTTPSampler.path">${base_path}${admin_path}/customer/index/save/</stringProp>
+        <stringProp name="HTTPSampler.method">POST</stringProp>
+        <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
+        <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
+        <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
+        <boolProp name="HTTPSampler.DO_MULTIPART_POST">true</boolProp>
+        <boolProp name="HTTPSampler.monitor">false</boolProp>
+        <stringProp name="HTTPSampler.embedded_url_re"/>
+      </HTTPSamplerProxy>
+      <hashTree>
+        <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Assert customer saved" enabled="true">
+          <collectionProp name="Asserion.test_strings">
+            <stringProp name="292987815">You saved the customer.</stringProp>
+          </collectionProp>
+          <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
+          <boolProp name="Assertion.assume_success">false</boolProp>
+          <intProp name="Assertion.test_type">2</intProp>
+        </ResponseAssertion>
+        <hashTree/>
+      </hashTree>
+      <TestAction guiclass="TestActionGui" testclass="TestAction" testname="Pause" enabled="true">
+        <intProp name="ActionProcessor.action">1</intProp>
+        <intProp name="ActionProcessor.target">0</intProp>
+        <stringProp name="ActionProcessor.duration">${__javaScript(Math.round(${adminCustomerManagementDelay}*1000))}</stringProp>
+      </TestAction>
       <hashTree/>
     </hashTree>
   </hashTree>
   
-    <GenericController guiclass="LogicControllerGui" testclass="GenericController" testname="Simple Controller" enabled="true">
-  <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/simple_controller.jmx</stringProp>
-</GenericController>
-    <hashTree>
-    <CounterConfig guiclass="CounterConfigGui" testclass="CounterConfig" testname="SetUp - Select ${gridEntityType} Page Number" enabled="true">
-      <stringProp name="CounterConfig.start">1</stringProp>
-      <stringProp name="CounterConfig.end">${grid_pages_count}</stringProp>
-      <stringProp name="CounterConfig.incr">1</stringProp>
-      <stringProp name="CounterConfig.name">page_number</stringProp>
-      <stringProp name="CounterConfig.format"/>
-      <boolProp name="CounterConfig.per_user">true</boolProp>
-      <boolProp name="CounterConfig.reset_on_tg_iteration">false</boolProp>
-    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_grid_browsing/select_page_number.jmx</stringProp></CounterConfig>
-    <hashTree/>
-  
-    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="View ${gridEntityType} page" enabled="true">
-      <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
-        <collectionProp name="Arguments.arguments">
-          <elementProp name="namespace" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">${grid_namespace}</stringProp>
-            <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">namespace</stringProp>
-            <stringProp name="Argument.desc">true</stringProp>
-          </elementProp>
-          <elementProp name="search" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value"/>
-            <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">search</stringProp>
-            <stringProp name="Argument.desc">true</stringProp>
-          </elementProp>
-          <elementProp name="filters[placeholder]" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">true</stringProp>
-            <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">filters[placeholder]</stringProp>
-            <stringProp name="Argument.desc">true</stringProp>
-          </elementProp>
-          <elementProp name="paging[pageSize]" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">${grid_entity_page_size}</stringProp>
-            <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">paging[pageSize]</stringProp>
-            <stringProp name="Argument.desc">true</stringProp>
-          </elementProp>
-          <elementProp name="paging[current]" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">${page_number}</stringProp>
-            <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">paging[current]</stringProp>
-            <stringProp name="Argument.desc">true</stringProp>
-          </elementProp>
-          <elementProp name="sorting[field]" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">entity_id</stringProp>
-            <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">sorting[field]</stringProp>
-            <stringProp name="Argument.desc">true</stringProp>
-          </elementProp>
-          <elementProp name="sorting[direction]" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">asc</stringProp>
-            <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">sorting[direction]</stringProp>
-            <stringProp name="Argument.desc">true</stringProp>
-          </elementProp>
-          <elementProp name="isAjax" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">true</stringProp>
-            <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">isAjax</stringProp>
-            <stringProp name="Argument.desc">true</stringProp>
-          </elementProp>
-        </collectionProp>
-      </elementProp>
-      <stringProp name="HTTPSampler.domain"/>
-      <stringProp name="HTTPSampler.port"/>
-      <stringProp name="HTTPSampler.connect_timeout"/>
-      <stringProp name="HTTPSampler.response_timeout"/>
-      <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
-      <stringProp name="HTTPSampler.contentEncoding"/>
-      <stringProp name="HTTPSampler.path">${base_path}${admin_path}/mui/index/render/</stringProp>
-      <stringProp name="HTTPSampler.method">GET</stringProp>
-      <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
-      <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
-      <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
-      <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
-      <boolProp name="HTTPSampler.monitor">false</boolProp>
-      <stringProp name="HTTPSampler.embedded_url_re"/>
-    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_grid_browsing/admin_browse_grid.jmx</stringProp></HTTPSamplerProxy>
-    <hashTree>
-      <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Response Assertion" enabled="true">
-        <collectionProp name="Asserion.test_strings">
-          <stringProp name="1637639774">\"totalRecords\":[^0]\d*</stringProp>
-        </collectionProp>
-        <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
-        <boolProp name="Assertion.assume_success">false</boolProp>
-        <intProp name="Assertion.test_type">2</intProp>
-      </ResponseAssertion>
-      <hashTree/>
-    </hashTree>
-  
-    <CounterConfig guiclass="CounterConfigGui" testclass="CounterConfig" testname="SetUp - Select Filtered ${gridEntityType} Page Number" enabled="true">
-      <stringProp name="CounterConfig.start">1</stringProp>
-      <stringProp name="CounterConfig.end">${grid_pages_count_filtered}</stringProp>
-      <stringProp name="CounterConfig.incr">1</stringProp>
-      <stringProp name="CounterConfig.name">page_number</stringProp>
-      <stringProp name="CounterConfig.format"/>
-      <boolProp name="CounterConfig.per_user">true</boolProp>
-      <boolProp name="CounterConfig.reset_on_tg_iteration">false</boolProp>
-    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_grid_browsing/select_filtered_page_number.jmx</stringProp></CounterConfig>
-    <hashTree/>
-  
-    <TestFragmentController guiclass="TestFragmentControllerGui" testclass="TestFragmentController" testname="View ${gridEntityType} page - Filtering + Sorting" enabled="true">
-  <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_grid_browsing/admin_browse_grid_sort_and_filter.jmx</stringProp>
-</TestFragmentController>
-    <hashTree>
-      <ForeachController guiclass="ForeachControlPanel" testclass="ForeachController" testname="ForEach Sort Field Defined" enabled="true">
-        <stringProp name="ForeachController.inputVal">grid_sort_field</stringProp>
-        <stringProp name="ForeachController.returnVal">grid_sort_field</stringProp>
-        <boolProp name="ForeachController.useSeparator">true</boolProp>
-        <stringProp name="ForeachController.startIndex">0</stringProp>
-        <stringProp name="ForeachController.endIndex">3</stringProp>
-      </ForeachController>
-      <hashTree>
-        <ForeachController guiclass="ForeachControlPanel" testclass="ForeachController" testname="ForEach Sort Order Defined" enabled="true">
-          <stringProp name="ForeachController.inputVal">grid_sort_order</stringProp>
-          <stringProp name="ForeachController.returnVal">grid_sort_order</stringProp>
-          <boolProp name="ForeachController.useSeparator">true</boolProp>
-          <stringProp name="ForeachController.startIndex">0</stringProp>
-          <stringProp name="ForeachController.endIndex">2</stringProp>
-        </ForeachController>
-        <hashTree>
-          <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="View ${gridEntityType} page - Filtering + Sort By ${grid_sort_field} ${grid_sort_order}" enabled="true">
-            <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
-              <collectionProp name="Arguments.arguments">
-                <elementProp name="namespace" elementType="HTTPArgument">
-                  <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                  <stringProp name="Argument.value">${grid_namespace}</stringProp>
-                  <stringProp name="Argument.metadata">=</stringProp>
-                  <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                  <stringProp name="Argument.name">namespace</stringProp>
-                  <stringProp name="Argument.desc">false</stringProp>
-                </elementProp>
-                <elementProp name="filters[${grid_filter_field}]" elementType="HTTPArgument">
-                  <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                  <stringProp name="Argument.value">${grid_admin_browse_filter_text}</stringProp>
-                  <stringProp name="Argument.metadata">=</stringProp>
-                  <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                  <stringProp name="Argument.name">filters[${grid_filter_field}]</stringProp>
-                  <stringProp name="Argument.desc">false</stringProp>
-                </elementProp>
-                <elementProp name="filters[placeholder]" elementType="HTTPArgument">
-                  <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">true</stringProp>
-                  <stringProp name="Argument.metadata">=</stringProp>
-                  <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                  <stringProp name="Argument.name">filters[placeholder]</stringProp>
-                  <stringProp name="Argument.desc">false</stringProp>
-                </elementProp>
-                <elementProp name="paging[pageSize]" elementType="HTTPArgument">
-                  <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                  <stringProp name="Argument.value">${grid_entity_page_size}</stringProp>
-                  <stringProp name="Argument.metadata">=</stringProp>
-                  <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                  <stringProp name="Argument.name">paging[pageSize]</stringProp>
-                  <stringProp name="Argument.desc">false</stringProp>
-                </elementProp>
-                <elementProp name="paging[current]" elementType="HTTPArgument">
-                  <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                  <stringProp name="Argument.value">${page_number}</stringProp>
-                  <stringProp name="Argument.metadata">=</stringProp>
-                  <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                  <stringProp name="Argument.name">paging[current]</stringProp>
-                  <stringProp name="Argument.desc">false</stringProp>
-                </elementProp>
-                <elementProp name="sorting[field]" elementType="HTTPArgument">
-                  <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                  <stringProp name="Argument.value">${grid_sort_field}</stringProp>
-                  <stringProp name="Argument.metadata">=</stringProp>
-                  <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                  <stringProp name="Argument.name">sorting[field]</stringProp>
-                  <stringProp name="Argument.desc">false</stringProp>
-                </elementProp>
-                <elementProp name="sorting[direction]" elementType="HTTPArgument">
-                  <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                  <stringProp name="Argument.value">${grid_sort_order}</stringProp>
-                  <stringProp name="Argument.metadata">=</stringProp>
-                  <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                  <stringProp name="Argument.name">sorting[direction]</stringProp>
-                  <stringProp name="Argument.desc">false</stringProp>
-                </elementProp>
-                <elementProp name="isAjax" elementType="HTTPArgument">
-                  <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                  <stringProp name="Argument.value">true</stringProp>
-                  <stringProp name="Argument.metadata">=</stringProp>
-                  <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                  <stringProp name="Argument.name">isAjax</stringProp>
-                  <stringProp name="Argument.desc">false</stringProp>
-                </elementProp>
-              </collectionProp>
-            </elementProp>
-            <stringProp name="HTTPSampler.domain"/>
-            <stringProp name="HTTPSampler.port"/>
-            <stringProp name="HTTPSampler.connect_timeout"/>
-            <stringProp name="HTTPSampler.response_timeout"/>
-            <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
-            <stringProp name="HTTPSampler.contentEncoding"/>
-            <stringProp name="HTTPSampler.path">${base_path}${admin_path}/mui/index/render/</stringProp>
-            <stringProp name="HTTPSampler.method">GET</stringProp>
-            <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
-            <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
-            <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
-            <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
-            <boolProp name="HTTPSampler.monitor">false</boolProp>
-            <stringProp name="HTTPSampler.embedded_url_re"/>
-          </HTTPSamplerProxy>
-          <hashTree>
-            <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Response Assertion" enabled="true">
-              <collectionProp name="Asserion.test_strings">
-                <stringProp name="1637639774">\"totalRecords\":[^0]\d*</stringProp>
-              </collectionProp>
-              <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
-              <boolProp name="Assertion.assume_success">false</boolProp>
-              <intProp name="Assertion.test_type">2</intProp>
-            </ResponseAssertion>
-            <hashTree/>
-          </hashTree>
-        </hashTree>
-      </hashTree>
-    </hashTree>
+    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Logout" enabled="true">
+      <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
+        <collectionProp name="Arguments.arguments"/>
+      </elementProp>
+      <stringProp name="HTTPSampler.domain"/>
+      <stringProp name="HTTPSampler.port"/>
+      <stringProp name="HTTPSampler.connect_timeout"/>
+      <stringProp name="HTTPSampler.response_timeout"/>
+      <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
+      <stringProp name="HTTPSampler.contentEncoding"/>
+      <stringProp name="HTTPSampler.path">${base_path}${admin_path}/admin/auth/logout/</stringProp>
+      <stringProp name="HTTPSampler.method">GET</stringProp>
+      <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
+      <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
+      <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
+      <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
+      <boolProp name="HTTPSampler.monitor">false</boolProp>
+      <stringProp name="HTTPSampler.embedded_url_re"/>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/setup/admin_logout.jmx</stringProp></HTTPSamplerProxy>
+    <hashTree>
+    
+    <BeanShellPostProcessor guiclass="TestBeanGUI" testclass="BeanShellPostProcessor" testname="Return Admin to Pool" enabled="true">
+        <boolProp name="resetInterpreter">false</boolProp>
+        <stringProp name="parameters"/>
+        <stringProp name="filename"/>
+        <stringProp name="script">
+adminUserList = props.get("adminUserList");
+adminUserList.add(vars.get("admin_user"));
+        </stringProp>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/common/return_admin_email_to_pool.jmx</stringProp></BeanShellPostProcessor>
+    <hashTree/>
   </hashTree>
   </hashTree>
 
   
-    <ThroughputController guiclass="ThroughputControllerGui" testclass="ThroughputController" testname="Browse Order Grid" enabled="true">
+    <ThroughputController guiclass="ThroughputControllerGui" testclass="ThroughputController" testname="Admin Edit Order" enabled="true">
       <intProp name="ThroughputController.style">1</intProp>
       <boolProp name="ThroughputController.perThread">false</boolProp>
       <intProp name="ThroughputController.maxThroughput">1</intProp>
-      <stringProp name="ThroughputController.percentThroughput">${browseOrderGridPercentage}</stringProp>
+      <stringProp name="ThroughputController.percentThroughput">${adminEditOrderPercentage}</stringProp>
     <stringProp name="TestPlan.comments">mpaf/tool/fragments/_system/scenario_controller_tmpl.jmx</stringProp></ThroughputController>
     <hashTree>
         <JSR223PreProcessor guiclass="TestBeanGUI" testclass="JSR223PreProcessor" testname="Set Test Label" enabled="true">
@@ -33506,7 +34018,7 @@ if (testLabel
         <hashTree/>
         <BeanShellSampler guiclass="BeanShellSamplerGui" testclass="BeanShellSampler" testname="SetUp - Set Label" enabled="true">
             <stringProp name="BeanShellSampler.query">
-                vars.put("testLabel", "Browse Order Grid");
+                vars.put("testLabel", "Admin Edit Order");
             </stringProp>
             <boolProp name="BeanShellSampler.resetInterpreter">true</boolProp>
         </BeanShellSampler>
@@ -33566,31 +34078,36 @@ if (testLabel
     <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/http_cookie_manager_without_clear_each_iteration.jmx</stringProp></CookieManager>
     <hashTree/>
   
-    <JSR223PostProcessor guiclass="TestBeanGUI" testclass="JSR223PreProcessor" testname="SetUp - Set Arguments" enabled="true">
-      <stringProp name="script">
-        vars.put("gridEntityType" , "Order");
-
-        pagesCount = parseInt(vars.get("orders_page_size")) || 20;
-        vars.put("grid_entity_page_size" , pagesCount);
-        vars.put("grid_namespace" , "sales_order_grid");
-        vars.put("grid_admin_browse_filter_text" , vars.get("admin_browse_orders_filter_text"));
-        vars.put("grid_filter_field", "status");
-
-        // set sort fields and sort directions
-        vars.put("grid_sort_field_1", "increment_id");
-        vars.put("grid_sort_field_2", "created_at");
-        vars.put("grid_sort_field_3", "billing_name");
-        vars.put("grid_sort_order_1", "asc");
-        vars.put("grid_sort_order_2", "desc");
+    <GenericController guiclass="LogicControllerGui" testclass="GenericController" testname="Admin Login" enabled="true">
+  <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/simple_controller.jmx</stringProp>
+</GenericController>
+    <hashTree>
+    <CriticalSectionController guiclass="CriticalSectionControllerGui" testclass="CriticalSectionController" testname="Admin Login Lock" enabled="true">
+        <stringProp name="CriticalSectionController.lockName">get-admin-email</stringProp>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/lock_controller.jmx</stringProp></CriticalSectionController>
+    <hashTree>
+    
+    <BeanShellSampler guiclass="BeanShellSamplerGui" testclass="BeanShellSampler" testname="SetUp - Get Admin Email" enabled="true">
+      <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/get_admin_email.jmx</stringProp>
+      <stringProp name="BeanShellSampler.query">
+adminUserList = props.get("adminUserList");
+adminUser = adminUserList.poll();
+if (adminUser == null) {
+  SampleResult.setResponseMessage("adminUser list is empty");
+  SampleResult.setResponseData("adminUser list is empty","UTF-8");
+  IsSuccess=false;
+  SampleResult.setSuccessful(false);
+  SampleResult.setStopThread(true);
+}
+vars.put("admin_user", adminUser);
       </stringProp>
-      <stringProp name="scriptLanguage">javascript</stringProp>
-    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_browse_orders_grid/setup.jmx</stringProp></JSR223PostProcessor>
+      <stringProp name="BeanShellSampler.filename"/>
+      <stringProp name="BeanShellSampler.parameters"/>
+      <boolProp name="BeanShellSampler.resetInterpreter">true</boolProp>
+    </BeanShellSampler>
     <hashTree/>
+  </hashTree>
   
-    <OnceOnlyController guiclass="OnceOnlyControllerGui" testclass="OnceOnlyController" testname="Once Only Controller" enabled="true">
-  <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/once_only_controller.jmx</stringProp>
-</OnceOnlyController>
-    <hashTree>
     <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="SetUp - Login" enabled="true">
       <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
         <collectionProp name="Arguments.arguments"/>
@@ -33693,74 +34210,421 @@ if (testLabel
       <stringProp name="HTTPSampler.embedded_url_re"/>
       <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_login/admin_login_submit_form.jmx</stringProp>
     </HTTPSamplerProxy>
-    <hashTree/>
+    <hashTree>
+        <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract form key" enabled="true">
+            <stringProp name="RegexExtractor.useHeaders">false</stringProp>
+            <stringProp name="RegexExtractor.refname">admin_form_key</stringProp>
+            <stringProp name="RegexExtractor.regex">&lt;input name="form_key" type="hidden" value="([^'"]+)" /&gt;</stringProp>
+            <stringProp name="RegexExtractor.template">$1$</stringProp>
+            <stringProp name="RegexExtractor.default"/>
+            <stringProp name="RegexExtractor.match_number">1</stringProp>
+        <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_login/admin_retrieve_form_key.jmx</stringProp></RegexExtractor>
+        <hashTree/>
+    </hashTree>
+  </hashTree>
   
-    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="SetUp - Set ${gridEntityType} Pages Count" enabled="true">
+    <GenericController guiclass="LogicControllerGui" testclass="GenericController" testname="Simple Controller" enabled="true">
+  <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/simple_controller.jmx</stringProp>
+</GenericController>
+    <hashTree>
+  <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Orders page" enabled="true">
+    <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
+      <collectionProp name="Arguments.arguments"/>
+    </elementProp>
+    <stringProp name="HTTPSampler.domain"/>
+    <stringProp name="HTTPSampler.port"/>
+    <stringProp name="HTTPSampler.connect_timeout"/>
+    <stringProp name="HTTPSampler.response_timeout"/>
+    <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
+    <stringProp name="HTTPSampler.contentEncoding"/>
+    <stringProp name="HTTPSampler.path">${base_path}${admin_path}/sales/order/</stringProp>
+    <stringProp name="HTTPSampler.method">GET</stringProp>
+    <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
+    <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
+    <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
+    <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
+    <boolProp name="HTTPSampler.monitor">false</boolProp>
+    <stringProp name="HTTPSampler.embedded_url_re"/>
+  <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_create_process_returns/orders_page.jmx</stringProp></HTTPSamplerProxy>
+  <hashTree>
+    <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Response Assertion" enabled="true">
+      <collectionProp name="Asserion.test_strings">
+        <stringProp name="1204796042">Create New Order</stringProp>
+      </collectionProp>
+      <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
+      <boolProp name="Assertion.assume_success">false</boolProp>
+      <intProp name="Assertion.test_type">2</intProp>
+    </ResponseAssertion>
+    <hashTree/>
+  </hashTree>
+
+  <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Open Orders" enabled="true">
+    <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
+      <collectionProp name="Arguments.arguments">
+        <elementProp name="namespace" elementType="HTTPArgument">
+          <boolProp name="HTTPArgument.always_encode">true</boolProp>
+          <stringProp name="Argument.value">sales_order_grid</stringProp>
+          <stringProp name="Argument.metadata">=</stringProp>
+          <boolProp name="HTTPArgument.use_equals">true</boolProp>
+          <stringProp name="Argument.name">namespace</stringProp>
+        </elementProp>
+        <elementProp name="search" elementType="HTTPArgument">
+          <boolProp name="HTTPArgument.always_encode">true</boolProp>
+          <stringProp name="Argument.value"/>
+          <stringProp name="Argument.metadata">=</stringProp>
+          <boolProp name="HTTPArgument.use_equals">true</boolProp>
+          <stringProp name="Argument.name">search</stringProp>
+        </elementProp>
+        <elementProp name="filters[placeholder]" elementType="HTTPArgument">
+          <boolProp name="HTTPArgument.always_encode">true</boolProp>
+          <stringProp name="Argument.value">true</stringProp>
+          <stringProp name="Argument.metadata">=</stringProp>
+          <boolProp name="HTTPArgument.use_equals">true</boolProp>
+          <stringProp name="Argument.name">filters[placeholder]</stringProp>
+        </elementProp>
+        <elementProp name="paging[pageSize]" elementType="HTTPArgument">
+          <boolProp name="HTTPArgument.always_encode">true</boolProp>
+          <stringProp name="Argument.value">200</stringProp>
+          <stringProp name="Argument.metadata">=</stringProp>
+          <boolProp name="HTTPArgument.use_equals">true</boolProp>
+          <stringProp name="Argument.name">paging[pageSize]</stringProp>
+        </elementProp>
+        <elementProp name="paging[current]" elementType="HTTPArgument">
+          <boolProp name="HTTPArgument.always_encode">true</boolProp>
+          <stringProp name="Argument.value">1</stringProp>
+          <stringProp name="Argument.metadata">=</stringProp>
+          <boolProp name="HTTPArgument.use_equals">true</boolProp>
+          <stringProp name="Argument.name">paging[current]</stringProp>
+        </elementProp>
+        <elementProp name="sorting[field]" elementType="HTTPArgument">
+          <boolProp name="HTTPArgument.always_encode">true</boolProp>
+          <stringProp name="Argument.value">increment_id</stringProp>
+          <stringProp name="Argument.metadata">=</stringProp>
+          <boolProp name="HTTPArgument.use_equals">true</boolProp>
+          <stringProp name="Argument.name">sorting[field]</stringProp>
+        </elementProp>
+        <elementProp name="sorting[direction]" elementType="HTTPArgument">
+          <boolProp name="HTTPArgument.always_encode">true</boolProp>
+          <stringProp name="Argument.value">desc</stringProp>
+          <stringProp name="Argument.metadata">=</stringProp>
+          <boolProp name="HTTPArgument.use_equals">true</boolProp>
+          <stringProp name="Argument.name">sorting[direction]</stringProp>
+        </elementProp>
+        <elementProp name="isAjax" elementType="HTTPArgument">
+          <boolProp name="HTTPArgument.always_encode">true</boolProp>
+          <stringProp name="Argument.value">true</stringProp>
+          <stringProp name="Argument.metadata">=</stringProp>
+          <boolProp name="HTTPArgument.use_equals">true</boolProp>
+          <stringProp name="Argument.name">isAjax</stringProp>
+        </elementProp>
+        <elementProp name="form_key" elementType="HTTPArgument">
+          <boolProp name="HTTPArgument.always_encode">true</boolProp>
+          <stringProp name="Argument.value">${admin_form_key}</stringProp>
+          <stringProp name="Argument.metadata">=</stringProp>
+          <boolProp name="HTTPArgument.use_equals">true</boolProp>
+          <stringProp name="Argument.name">form_key</stringProp>
+          <stringProp name="Argument.desc">false</stringProp>
+        </elementProp>
+        <elementProp name="filters[status]" elementType="HTTPArgument">
+          <boolProp name="HTTPArgument.always_encode">true</boolProp>
+          <stringProp name="Argument.value">pending</stringProp>
+          <stringProp name="Argument.metadata">=</stringProp>
+          <boolProp name="HTTPArgument.use_equals">true</boolProp>
+          <stringProp name="Argument.name">filters[status]</stringProp>
+          <stringProp name="Argument.desc">true</stringProp>
+        </elementProp>
+        <elementProp name="_" elementType="HTTPArgument">
+          <boolProp name="HTTPArgument.always_encode">true</boolProp>
+          <stringProp name="Argument.value">${__time()}${__Random(1,1000000)}</stringProp>
+          <stringProp name="Argument.metadata">=</stringProp>
+          <boolProp name="HTTPArgument.use_equals">true</boolProp>
+          <stringProp name="Argument.name">_</stringProp>
+        </elementProp>
+      </collectionProp>
+    </elementProp>
+    <stringProp name="HTTPSampler.domain"/>
+    <stringProp name="HTTPSampler.port"/>
+    <stringProp name="HTTPSampler.connect_timeout"/>
+    <stringProp name="HTTPSampler.response_timeout"/>
+    <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
+    <stringProp name="HTTPSampler.contentEncoding"/>
+    <stringProp name="HTTPSampler.path">${base_path}${admin_path}/mui/index/render/</stringProp>
+    <stringProp name="HTTPSampler.method">GET</stringProp>
+    <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
+    <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
+    <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
+    <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
+    <boolProp name="HTTPSampler.monitor">false</boolProp>
+    <stringProp name="HTTPSampler.embedded_url_re"/>
+  <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_create_process_returns/open_orders.jmx</stringProp></HTTPSamplerProxy>
+  <hashTree>
+    <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Response Assertion" enabled="true">
+      <collectionProp name="Asserion.test_strings">
+        <stringProp name="1637639774">totalRecords</stringProp>
+      </collectionProp>
+      <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
+      <boolProp name="Assertion.assume_success">false</boolProp>
+      <intProp name="Assertion.test_type">2</intProp>
+    </ResponseAssertion>
+    <hashTree/>
+  </hashTree>
+
+  <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Search Pending Orders" enabled="true">
+    <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
+      <collectionProp name="Arguments.arguments">
+        <elementProp name="form_key" elementType="HTTPArgument">
+          <boolProp name="HTTPArgument.always_encode">true</boolProp>
+          <stringProp name="Argument.value">${admin_form_key}</stringProp>
+          <stringProp name="Argument.metadata">=</stringProp>
+          <boolProp name="HTTPArgument.use_equals">true</boolProp>
+          <stringProp name="Argument.name">form_key</stringProp>
+        </elementProp>
+        <elementProp name="namespace" elementType="HTTPArgument">
+          <boolProp name="HTTPArgument.always_encode">true</boolProp>
+          <stringProp name="Argument.value">sales_order_grid</stringProp>
+          <stringProp name="Argument.metadata">=</stringProp>
+          <boolProp name="HTTPArgument.use_equals">true</boolProp>
+          <stringProp name="Argument.name">namespace</stringProp>
+          <stringProp name="Argument.desc">true</stringProp>
+        </elementProp>
+        <elementProp name="search" elementType="HTTPArgument">
+          <boolProp name="HTTPArgument.always_encode">true</boolProp>
+          <stringProp name="Argument.value"/>
+          <stringProp name="Argument.metadata">=</stringProp>
+          <boolProp name="HTTPArgument.use_equals">true</boolProp>
+          <stringProp name="Argument.name">search</stringProp>
+          <stringProp name="Argument.desc">true</stringProp>
+        </elementProp>
+        <elementProp name="filters[placeholder]" elementType="HTTPArgument">
+          <boolProp name="HTTPArgument.always_encode">true</boolProp>
+          <stringProp name="Argument.value">true</stringProp>
+          <stringProp name="Argument.metadata">=</stringProp>
+          <boolProp name="HTTPArgument.use_equals">true</boolProp>
+          <stringProp name="Argument.name">filters[placeholder]</stringProp>
+          <stringProp name="Argument.desc">true</stringProp>
+        </elementProp>
+        <elementProp name="paging[pageSize]" elementType="HTTPArgument">
+          <boolProp name="HTTPArgument.always_encode">true</boolProp>
+          <stringProp name="Argument.value">200</stringProp>
+          <stringProp name="Argument.metadata">=</stringProp>
+          <boolProp name="HTTPArgument.use_equals">true</boolProp>
+          <stringProp name="Argument.name">paging[pageSize]</stringProp>
+          <stringProp name="Argument.desc">true</stringProp>
+        </elementProp>
+        <elementProp name="paging[current]" elementType="HTTPArgument">
+          <boolProp name="HTTPArgument.always_encode">true</boolProp>
+          <stringProp name="Argument.value">1</stringProp>
+          <stringProp name="Argument.metadata">=</stringProp>
+          <boolProp name="HTTPArgument.use_equals">true</boolProp>
+          <stringProp name="Argument.name">paging[current]</stringProp>
+          <stringProp name="Argument.desc">true</stringProp>
+        </elementProp>
+        <elementProp name="sorting[field]" elementType="HTTPArgument">
+          <boolProp name="HTTPArgument.always_encode">true</boolProp>
+          <stringProp name="Argument.value">increment_id</stringProp>
+          <stringProp name="Argument.metadata">=</stringProp>
+          <boolProp name="HTTPArgument.use_equals">true</boolProp>
+          <stringProp name="Argument.name">sorting[field]</stringProp>
+          <stringProp name="Argument.desc">true</stringProp>
+        </elementProp>
+        <elementProp name="sorting[direction]" elementType="HTTPArgument">
+          <boolProp name="HTTPArgument.always_encode">true</boolProp>
+          <stringProp name="Argument.value">asc</stringProp>
+          <stringProp name="Argument.metadata">=</stringProp>
+          <boolProp name="HTTPArgument.use_equals">true</boolProp>
+          <stringProp name="Argument.name">sorting[direction]</stringProp>
+          <stringProp name="Argument.desc">true</stringProp>
+        </elementProp>
+        <elementProp name="isAjax" elementType="HTTPArgument">
+          <boolProp name="HTTPArgument.always_encode">true</boolProp>
+          <stringProp name="Argument.value">true</stringProp>
+          <stringProp name="Argument.metadata">=</stringProp>
+          <boolProp name="HTTPArgument.use_equals">true</boolProp>
+          <stringProp name="Argument.name">isAjax</stringProp>
+          <stringProp name="Argument.desc">true</stringProp>
+        </elementProp>
+        <elementProp name="filters[status]" elementType="HTTPArgument">
+          <boolProp name="HTTPArgument.always_encode">true</boolProp>
+          <stringProp name="Argument.value">pending</stringProp>
+          <stringProp name="Argument.metadata">=</stringProp>
+          <boolProp name="HTTPArgument.use_equals">true</boolProp>
+          <stringProp name="Argument.name">filters[status]</stringProp>
+        </elementProp>
+        <elementProp name="_" elementType="HTTPArgument">
+          <boolProp name="HTTPArgument.always_encode">true</boolProp>
+          <stringProp name="Argument.value">${__time()}${__Random(1,1000000)}</stringProp>
+          <stringProp name="Argument.metadata">=</stringProp>
+          <boolProp name="HTTPArgument.use_equals">true</boolProp>
+          <stringProp name="Argument.name">_</stringProp>
+        </elementProp>
+      </collectionProp>
+    </elementProp>
+    <stringProp name="HTTPSampler.domain"/>
+    <stringProp name="HTTPSampler.port"/>
+    <stringProp name="HTTPSampler.connect_timeout"/>
+    <stringProp name="HTTPSampler.response_timeout"/>
+    <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
+    <stringProp name="HTTPSampler.contentEncoding"/>
+    <stringProp name="HTTPSampler.path">${base_path}${admin_path}/mui/index/render/</stringProp>
+    <stringProp name="HTTPSampler.method">GET</stringProp>
+    <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
+    <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
+    <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
+    <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
+    <boolProp name="HTTPSampler.monitor">false</boolProp>
+    <stringProp name="HTTPSampler.embedded_url_re"/>
+  <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_create_process_returns/search_orders.jmx</stringProp></HTTPSamplerProxy>
+<hashTree>
+      <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Response Assertion" enabled="true">
+        <collectionProp name="Asserion.test_strings">
+          <stringProp name="1637639774">totalRecords</stringProp>
+        </collectionProp>
+        <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
+        <boolProp name="Assertion.assume_success">false</boolProp>
+        <intProp name="Assertion.test_type">2</intProp>
+      </ResponseAssertion>
+      <hashTree/>
+      <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract order numbers" enabled="true">
+        <stringProp name="RegexExtractor.useHeaders">false</stringProp>
+        <stringProp name="RegexExtractor.refname">order_numbers</stringProp>
+        <stringProp name="RegexExtractor.regex">\"increment_id\":\"(\d+)\"\,</stringProp>
+        <stringProp name="RegexExtractor.template">$1$</stringProp>
+        <stringProp name="RegexExtractor.default"/>
+        <stringProp name="RegexExtractor.match_number">-1</stringProp>
+        <stringProp name="Scope.variable">simple_products</stringProp>
+      </RegexExtractor>
+      <hashTree/>
+      <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract order ids" enabled="true">
+        <stringProp name="RegexExtractor.useHeaders">false</stringProp>
+        <stringProp name="RegexExtractor.refname">order_ids</stringProp>
+        <stringProp name="RegexExtractor.regex">\"entity_id\":\"(\d+)\"\,</stringProp>
+        <stringProp name="RegexExtractor.template">$1$</stringProp>
+        <stringProp name="RegexExtractor.default"/>
+        <stringProp name="RegexExtractor.match_number">-1</stringProp>
+        <stringProp name="Scope.variable">simple_products</stringProp>
+      </RegexExtractor>
+      <hashTree/>
+    </hashTree>
+
+      <BeanShellSampler guiclass="BeanShellSamplerGui" testclass="BeanShellSampler" testname="SetUp - Generate Unique Ids for each Thread" enabled="true">
+        <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_create_process_returns/setup.jmx</stringProp>
+        <stringProp name="BeanShellSampler.query">
+  import java.util.ArrayList;
+  import java.util.HashMap;
+  import org.apache.jmeter.protocol.http.util.Base64Encoder;
+  import java.util.Random;
+
+  // get count of "order_numbers" variable defined in "Search Pending Orders Limit"
+  int ordersCount = Integer.parseInt(vars.get("order_numbers_matchNr"));
+
+
+  int clusterLength;
+  int threadsNumber = ctx.getThreadGroup().getNumThreads();
+  if (threadsNumber == 0) {
+      //Number of orders for one thread
+      clusterLength = ordersCount;
+  } else {
+      clusterLength = Math.round(ordersCount / threadsNumber);
+      if (clusterLength == 0) {
+          clusterLength = 1;
+      }
+  }
+
+  //Current thread number starts from 0
+  int currentThreadNum = ctx.getThreadNum();
+
+  //Index of the current product from the cluster
+  Random random = new Random();
+  int iterator = random.nextInt(clusterLength);
+  if (iterator == 0) {
+  	iterator = 1;
+  }
+
+  int i = clusterLength * currentThreadNum + iterator;
+
+  orderNumber = vars.get("order_numbers_" + i.toString());
+  orderId = vars.get("order_ids_" + i.toString());
+  vars.put("order_number", orderNumber);
+  vars.put("order_id", orderId);
+
+  </stringProp>
+    <stringProp name="BeanShellSampler.filename"/>
+    <stringProp name="BeanShellSampler.parameters"/>
+    <boolProp name="BeanShellSampler.resetInterpreter">false</boolProp>
+  </BeanShellSampler>
+  <hashTree/>
+
+  <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Open Order" enabled="true">
+    <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
+      <collectionProp name="Arguments.arguments"/>
+    </elementProp>
+    <stringProp name="HTTPSampler.domain"/>
+    <stringProp name="HTTPSampler.port"/>
+    <stringProp name="HTTPSampler.connect_timeout"/>
+    <stringProp name="HTTPSampler.response_timeout"/>
+    <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
+    <stringProp name="HTTPSampler.contentEncoding"/>
+    <stringProp name="HTTPSampler.path">${base_path}${admin_path}/sales/order/view/order_id/${order_id}/</stringProp>
+    <stringProp name="HTTPSampler.method">GET</stringProp>
+    <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
+    <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
+    <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
+    <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
+    <boolProp name="HTTPSampler.monitor">false</boolProp>
+    <stringProp name="HTTPSampler.embedded_url_re"/>
+  <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_create_process_returns/open_order.jmx</stringProp></HTTPSamplerProxy>
+  <hashTree>
+    <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Response Assertion" enabled="true">
+      <collectionProp name="Asserion.test_strings">
+        <stringProp name="2103620713">#${order_number}</stringProp>
+      </collectionProp>
+      <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
+      <boolProp name="Assertion.assume_success">false</boolProp>
+      <intProp name="Assertion.test_type">2</intProp>
+    </ResponseAssertion>
+    <hashTree/>
+    <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract order status" enabled="true">
+      <stringProp name="RegexExtractor.useHeaders">false</stringProp>
+      <stringProp name="RegexExtractor.refname">order_status</stringProp>
+      <stringProp name="RegexExtractor.regex">&lt;span id="order_status"&gt;([^&lt;]+)&lt;/span&gt;</stringProp>
+      <stringProp name="RegexExtractor.template">$1$</stringProp>
+      <stringProp name="RegexExtractor.default"/>
+      <stringProp name="RegexExtractor.match_number">1</stringProp>
+      <stringProp name="Scope.variable">simple_products</stringProp>
+    </RegexExtractor>
+    <hashTree/>
+  </hashTree>
+
+    <IfController guiclass="IfControllerPanel" testclass="IfController" testname="If Controller" enabled="true">
+      <stringProp name="IfController.condition">"${order_status}" == "Pending"</stringProp>
+      <boolProp name="IfController.evaluateAll">false</boolProp>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_edit_order/if_controller.jmx</stringProp></IfController>
+    <hashTree>
+    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Add Comment" enabled="true">
       <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
         <collectionProp name="Arguments.arguments">
-          <elementProp name="namespace" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">${grid_namespace}</stringProp>
-            <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">namespace</stringProp>
-            <stringProp name="Argument.desc">true</stringProp>
-          </elementProp>
-          <elementProp name="search" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value"/>
-            <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">search</stringProp>
-            <stringProp name="Argument.desc">true</stringProp>
-          </elementProp>
-          <elementProp name="filters[placeholder]" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">true</stringProp>
-            <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">filters[placeholder]</stringProp>
-            <stringProp name="Argument.desc">true</stringProp>
-          </elementProp>
-          <elementProp name="paging[pageSize]" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">${grid_entity_page_size}</stringProp>
-            <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">paging[pageSize]</stringProp>
-            <stringProp name="Argument.desc">true</stringProp>
-          </elementProp>
-          <elementProp name="paging[current]" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">1</stringProp>
-            <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">paging[current]</stringProp>
-            <stringProp name="Argument.desc">true</stringProp>
-          </elementProp>
-          <elementProp name="sorting[field]" elementType="HTTPArgument">
+          <elementProp name="history[status]" elementType="HTTPArgument">
             <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">entity_id</stringProp>
+            <stringProp name="Argument.value">pending</stringProp>
             <stringProp name="Argument.metadata">=</stringProp>
             <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">sorting[field]</stringProp>
-            <stringProp name="Argument.desc">true</stringProp>
+            <stringProp name="Argument.name">history[status]</stringProp>
+            <stringProp name="Argument.desc">false</stringProp>
           </elementProp>
-          <elementProp name="sorting[direction]" elementType="HTTPArgument">
+          <elementProp name="history[comment]" elementType="HTTPArgument">
             <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">asc</stringProp>
+            <stringProp name="Argument.value">Some text</stringProp>
             <stringProp name="Argument.metadata">=</stringProp>
             <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">sorting[direction]</stringProp>
-            <stringProp name="Argument.desc">true</stringProp>
+            <stringProp name="Argument.name">history[comment]</stringProp>
           </elementProp>
-          <elementProp name="isAjax" elementType="HTTPArgument">
+          <elementProp name="form_key" elementType="HTTPArgument">
             <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">true</stringProp>
+            <stringProp name="Argument.value">${admin_form_key}</stringProp>
             <stringProp name="Argument.metadata">=</stringProp>
             <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">isAjax</stringProp>
-            <stringProp name="Argument.desc">true</stringProp>
+            <stringProp name="Argument.name">form_key</stringProp>
+            <stringProp name="Argument.desc">false</stringProp>
           </elementProp>
         </collectionProp>
       </elementProp>
@@ -33770,116 +34634,132 @@ if (testLabel
       <stringProp name="HTTPSampler.response_timeout"/>
       <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
       <stringProp name="HTTPSampler.contentEncoding"/>
-      <stringProp name="HTTPSampler.path">${base_path}${admin_path}/mui/index/render/</stringProp>
-      <stringProp name="HTTPSampler.method">GET</stringProp>
+      <stringProp name="HTTPSampler.path">${base_path}${admin_path}/sales/order/addComment/order_id/${order_id}/?isAjax=true</stringProp>
+      <stringProp name="HTTPSampler.method">POST</stringProp>
       <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
       <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
       <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
       <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
       <boolProp name="HTTPSampler.monitor">false</boolProp>
       <stringProp name="HTTPSampler.embedded_url_re"/>
-    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_grid_browsing/set_pages_count.jmx</stringProp></HTTPSamplerProxy>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_edit_order/add_comment.jmx</stringProp></HTTPSamplerProxy>
     <hashTree>
-      <com.atlantbh.jmeter.plugins.jsonutils.jsonpathassertion.JSONPathAssertion guiclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathassertion.gui.JSONPathAssertionGui" testclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathassertion.JSONPathAssertion" testname="Assert total records is not 0" enabled="true">
-        <stringProp name="JSON_PATH">$.totalRecords</stringProp>
-        <stringProp name="EXPECTED_VALUE">0</stringProp>
-        <boolProp name="JSONVALIDATION">true</boolProp>
-        <boolProp name="EXPECT_NULL">false</boolProp>
-        <boolProp name="INVERT">true</boolProp>
-      </com.atlantbh.jmeter.plugins.jsonutils.jsonpathassertion.JSONPathAssertion>
-      <hashTree/>
-      <com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor guiclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.gui.JSONPathExtractorGui" testclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor" testname="Extract total records" enabled="true">
-        <stringProp name="VAR">entity_total_records</stringProp>
-        <stringProp name="JSONPATH">$.totalRecords</stringProp>
-        <stringProp name="DEFAULT"/>
-        <stringProp name="VARIABLE"/>
-        <stringProp name="SUBJECT">BODY</stringProp>
-      </com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor>
-      <hashTree/>
-      <JSR223PostProcessor guiclass="TestBeanGUI" testclass="JSR223PreProcessor" testname="SetUp - Calculate ${gridEntityType} pages count" enabled="true">
-        <stringProp name="cacheKey"/>
-        <stringProp name="filename"/>
-        <stringProp name="parameters"/>
-        <stringProp name="script">
-          var pageSize = parseInt(vars.get("grid_entity_page_size")) || 20;
-          var totalsRecord = parseInt(vars.get("entity_total_records"));
-          var pageCount = Math.round(totalsRecord/pageSize);
-
-          vars.put("grid_pages_count", pageCount);
-        </stringProp>
-        <stringProp name="scriptLanguage">javascript</stringProp>
-      </JSR223PostProcessor>
+      <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Response Assertion" enabled="true">
+        <collectionProp name="Asserion.test_strings">
+          <stringProp name="-2089278331">Not Notified</stringProp>
+        </collectionProp>
+        <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
+        <boolProp name="Assertion.assume_success">false</boolProp>
+        <intProp name="Assertion.test_type">2</intProp>
+      </ResponseAssertion>
       <hashTree/>
     </hashTree>
   
-    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="SetUp - Set ${gridEntityType} Filtered Pages Count" enabled="true">
+  <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Invoice Start" enabled="true">
+    <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
+      <collectionProp name="Arguments.arguments"/>
+    </elementProp>
+    <stringProp name="HTTPSampler.domain"/>
+    <stringProp name="HTTPSampler.port"/>
+    <stringProp name="HTTPSampler.connect_timeout"/>
+    <stringProp name="HTTPSampler.response_timeout"/>
+    <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
+    <stringProp name="HTTPSampler.contentEncoding"/>
+    <stringProp name="HTTPSampler.path">${base_path}${admin_path}/sales/order_invoice/start/order_id/${order_id}/</stringProp>
+    <stringProp name="HTTPSampler.method">GET</stringProp>
+    <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
+    <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
+    <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
+    <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
+    <boolProp name="HTTPSampler.monitor">false</boolProp>
+    <stringProp name="HTTPSampler.embedded_url_re"/>
+  <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_create_process_returns/invoice_start.jmx</stringProp></HTTPSamplerProxy>
+  <hashTree>
+    <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Response Assertion" enabled="true">
+      <collectionProp name="Asserion.test_strings">
+        <stringProp name="-1233850814">Invoice Totals</stringProp>
+      </collectionProp>
+      <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
+      <boolProp name="Assertion.assume_success">false</boolProp>
+      <intProp name="Assertion.test_type">2</intProp>
+    </ResponseAssertion>
+    <hashTree/>
+    <RegexExtractor guiclass="RegexExtractorGui" testclass="RegexExtractor" testname="Extract ordered items ids" enabled="true">
+      <stringProp name="RegexExtractor.useHeaders">false</stringProp>
+      <stringProp name="RegexExtractor.refname">item_ids</stringProp>
+      <stringProp name="RegexExtractor.regex">&lt;div id="order_item_(\d+)_title"\s*class="product-title"&gt;</stringProp>
+      <stringProp name="RegexExtractor.template">$1$</stringProp>
+      <stringProp name="RegexExtractor.default"/>
+      <stringProp name="RegexExtractor.match_number">-1</stringProp>
+      <stringProp name="Scope.variable">simple_products</stringProp>
+    </RegexExtractor>
+    <hashTree/>
+  </hashTree>
+
+  <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Invoice Submit" enabled="true">
+    <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
+      <collectionProp name="Arguments.arguments">
+        <elementProp name="form_key" elementType="HTTPArgument">
+          <boolProp name="HTTPArgument.always_encode">true</boolProp>
+          <stringProp name="Argument.value">${admin_form_key}</stringProp>
+          <stringProp name="Argument.metadata">=</stringProp>
+          <boolProp name="HTTPArgument.use_equals">true</boolProp>
+          <stringProp name="Argument.name">form_key</stringProp>
+          <stringProp name="Argument.desc">false</stringProp>
+        </elementProp>
+        <elementProp name="invoice[items][${item_ids_1}]" elementType="HTTPArgument">
+          <boolProp name="HTTPArgument.always_encode">true</boolProp>
+          <stringProp name="Argument.value">1</stringProp>
+          <stringProp name="Argument.metadata">=</stringProp>
+          <boolProp name="HTTPArgument.use_equals">true</boolProp>
+          <stringProp name="Argument.name">invoice[items][${item_ids_1}]</stringProp>
+        </elementProp>
+        <elementProp name="invoice[items][${item_ids_2}]" elementType="HTTPArgument">
+          <boolProp name="HTTPArgument.always_encode">true</boolProp>
+          <stringProp name="Argument.value">1</stringProp>
+          <stringProp name="Argument.metadata">=</stringProp>
+          <boolProp name="HTTPArgument.use_equals">true</boolProp>
+          <stringProp name="Argument.name">invoice[items][${item_ids_2}]</stringProp>
+        </elementProp>
+        <elementProp name="invoice[comment_text]" elementType="HTTPArgument">
+          <boolProp name="HTTPArgument.always_encode">true</boolProp>
+          <stringProp name="Argument.value">Invoiced</stringProp>
+          <stringProp name="Argument.metadata">=</stringProp>
+          <boolProp name="HTTPArgument.use_equals">true</boolProp>
+          <stringProp name="Argument.name">invoice[comment_text]</stringProp>
+        </elementProp>
+      </collectionProp>
+    </elementProp>
+    <stringProp name="HTTPSampler.domain"/>
+    <stringProp name="HTTPSampler.port"/>
+    <stringProp name="HTTPSampler.connect_timeout"/>
+    <stringProp name="HTTPSampler.response_timeout"/>
+    <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
+    <stringProp name="HTTPSampler.contentEncoding"/>
+    <stringProp name="HTTPSampler.path">${base_path}${admin_path}/sales/order_invoice/save/order_id/${order_id}/</stringProp>
+    <stringProp name="HTTPSampler.method">POST</stringProp>
+    <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
+    <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
+    <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
+    <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
+    <boolProp name="HTTPSampler.monitor">false</boolProp>
+    <stringProp name="HTTPSampler.embedded_url_re"/>
+  <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_create_process_returns/invoice_submit.jmx</stringProp></HTTPSamplerProxy>
+  <hashTree>
+    <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Response Assertion" enabled="true">
+      <collectionProp name="Asserion.test_strings">
+        <stringProp name="1740524604">The invoice has been created</stringProp>
+      </collectionProp>
+      <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
+      <boolProp name="Assertion.assume_success">false</boolProp>
+      <intProp name="Assertion.test_type">2</intProp>
+    </ResponseAssertion>
+    <hashTree/>
+  </hashTree>
+
+    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Shipment Start" enabled="true">
       <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
-        <collectionProp name="Arguments.arguments">
-          <elementProp name="namespace" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">${grid_namespace}</stringProp>
-            <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">namespace</stringProp>
-            <stringProp name="Argument.desc">true</stringProp>
-          </elementProp>
-          <elementProp name="search" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value"/>
-            <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">search</stringProp>
-            <stringProp name="Argument.desc">true</stringProp>
-          </elementProp>
-          <elementProp name="filters[placeholder]" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">${grid_admin_browse_filter_text}</stringProp>
-            <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">filters[placeholder]</stringProp>
-            <stringProp name="Argument.desc">true</stringProp>
-          </elementProp>
-          <elementProp name="paging[pageSize]" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">${grid_entity_page_size}</stringProp>
-            <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">paging[pageSize]</stringProp>
-            <stringProp name="Argument.desc">true</stringProp>
-          </elementProp>
-          <elementProp name="paging[current]" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">1</stringProp>
-            <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">paging[current]</stringProp>
-            <stringProp name="Argument.desc">true</stringProp>
-          </elementProp>
-          <elementProp name="sorting[field]" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">entity_id</stringProp>
-            <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">sorting[field]</stringProp>
-            <stringProp name="Argument.desc">true</stringProp>
-          </elementProp>
-          <elementProp name="sorting[direction]" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">asc</stringProp>
-            <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">sorting[direction]</stringProp>
-            <stringProp name="Argument.desc">true</stringProp>
-          </elementProp>
-          <elementProp name="isAjax" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">true</stringProp>
-            <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">isAjax</stringProp>
-            <stringProp name="Argument.desc">true</stringProp>
-          </elementProp>
-        </collectionProp>
+        <collectionProp name="Arguments.arguments"/>
       </elementProp>
       <stringProp name="HTTPSampler.domain"/>
       <stringProp name="HTTPSampler.port"/>
@@ -33887,7 +34767,7 @@ if (testLabel
       <stringProp name="HTTPSampler.response_timeout"/>
       <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
       <stringProp name="HTTPSampler.contentEncoding"/>
-      <stringProp name="HTTPSampler.path">${base_path}${admin_path}/mui/index/render/</stringProp>
+      <stringProp name="HTTPSampler.path">${base_path}${admin_path}/admin/order_shipment/start/order_id/${order_id}/</stringProp>
       <stringProp name="HTTPSampler.method">GET</stringProp>
       <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
       <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
@@ -33895,122 +34775,50 @@ if (testLabel
       <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
       <boolProp name="HTTPSampler.monitor">false</boolProp>
       <stringProp name="HTTPSampler.embedded_url_re"/>
-    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_grid_browsing/set_filtered_pages_count.jmx</stringProp></HTTPSamplerProxy>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_edit_order/shipment_start.jmx</stringProp></HTTPSamplerProxy>
     <hashTree>
-      <com.atlantbh.jmeter.plugins.jsonutils.jsonpathassertion.JSONPathAssertion guiclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathassertion.gui.JSONPathAssertionGui" testclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathassertion.JSONPathAssertion" testname="Assert total records is not 0" enabled="true">
-        <stringProp name="JSON_PATH">$.totalRecords</stringProp>
-        <stringProp name="EXPECTED_VALUE">0</stringProp>
-        <boolProp name="JSONVALIDATION">true</boolProp>
-        <boolProp name="EXPECT_NULL">false</boolProp>
-        <boolProp name="INVERT">true</boolProp>
-        <boolProp name="ISREGEX">true</boolProp>
-      </com.atlantbh.jmeter.plugins.jsonutils.jsonpathassertion.JSONPathAssertion>
-      <hashTree/>
-      <com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor guiclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.gui.JSONPathExtractorGui" testclass="com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor" testname="Extract total records" enabled="true">
-        <stringProp name="VAR">entity_total_records</stringProp>
-        <stringProp name="JSONPATH">$.totalRecords</stringProp>
-        <stringProp name="DEFAULT"/>
-        <stringProp name="VARIABLE"/>
-        <stringProp name="SUBJECT">BODY</stringProp>
-      </com.atlantbh.jmeter.plugins.jsonutils.jsonpathextractor.JSONPathExtractor>
-      <hashTree/>
-      <JSR223PostProcessor guiclass="TestBeanGUI" testclass="JSR223PreProcessor" testname="SetUp - Calculate ${gridEntityType} filtered pages count" enabled="true">
-        <stringProp name="parameters"/>
-        <stringProp name="filename"/>
-        <stringProp name="script">
-          var pageSize = parseInt(vars.get("grid_entity_page_size")) || 20;
-var totalsRecord = parseInt(vars.get("entity_total_records"));
-var pageCount = Math.round(totalsRecord/pageSize);
-
-vars.put("grid_pages_count_filtered", pageCount);
-        </stringProp>
-        <stringProp name="scriptLanguage">javascript</stringProp>
-      </JSR223PostProcessor>
+      <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Response Assertion" enabled="true">
+        <collectionProp name="Asserion.test_strings">
+          <stringProp name="304100442">New Shipment</stringProp>
+        </collectionProp>
+        <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
+        <boolProp name="Assertion.assume_success">false</boolProp>
+        <intProp name="Assertion.test_type">2</intProp>
+      </ResponseAssertion>
       <hashTree/>
     </hashTree>
-  </hashTree>
-  
-    <GenericController guiclass="LogicControllerGui" testclass="GenericController" testname="Simple Controller" enabled="true">
-  <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/simple_controller.jmx</stringProp>
-</GenericController>
-    <hashTree>
-    <CounterConfig guiclass="CounterConfigGui" testclass="CounterConfig" testname="SetUp - Select ${gridEntityType} Page Number" enabled="true">
-      <stringProp name="CounterConfig.start">1</stringProp>
-      <stringProp name="CounterConfig.end">${grid_pages_count}</stringProp>
-      <stringProp name="CounterConfig.incr">1</stringProp>
-      <stringProp name="CounterConfig.name">page_number</stringProp>
-      <stringProp name="CounterConfig.format"/>
-      <boolProp name="CounterConfig.per_user">true</boolProp>
-      <boolProp name="CounterConfig.reset_on_tg_iteration">false</boolProp>
-    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_grid_browsing/select_page_number.jmx</stringProp></CounterConfig>
-    <hashTree/>
   
-    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="View ${gridEntityType} page" enabled="true">
+    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Shipment Submit" enabled="true">
       <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
         <collectionProp name="Arguments.arguments">
-          <elementProp name="namespace" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">${grid_namespace}</stringProp>
-            <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">namespace</stringProp>
-            <stringProp name="Argument.desc">true</stringProp>
-          </elementProp>
-          <elementProp name="search" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value"/>
-            <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">search</stringProp>
-            <stringProp name="Argument.desc">true</stringProp>
-          </elementProp>
-          <elementProp name="filters[placeholder]" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">true</stringProp>
-            <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">filters[placeholder]</stringProp>
-            <stringProp name="Argument.desc">true</stringProp>
-          </elementProp>
-          <elementProp name="paging[pageSize]" elementType="HTTPArgument">
-            <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">${grid_entity_page_size}</stringProp>
-            <stringProp name="Argument.metadata">=</stringProp>
-            <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">paging[pageSize]</stringProp>
-            <stringProp name="Argument.desc">true</stringProp>
-          </elementProp>
-          <elementProp name="paging[current]" elementType="HTTPArgument">
+          <elementProp name="form_key" elementType="HTTPArgument">
             <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">${page_number}</stringProp>
+            <stringProp name="Argument.value">${admin_form_key}</stringProp>
             <stringProp name="Argument.metadata">=</stringProp>
             <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">paging[current]</stringProp>
-            <stringProp name="Argument.desc">true</stringProp>
+            <stringProp name="Argument.name">form_key</stringProp>
+            <stringProp name="Argument.desc">false</stringProp>
           </elementProp>
-          <elementProp name="sorting[field]" elementType="HTTPArgument">
+          <elementProp name="shipment[items][${item_ids_1}]" elementType="HTTPArgument">
             <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">entity_id</stringProp>
+            <stringProp name="Argument.value">1</stringProp>
             <stringProp name="Argument.metadata">=</stringProp>
             <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">sorting[field]</stringProp>
-            <stringProp name="Argument.desc">true</stringProp>
+            <stringProp name="Argument.name">shipment[items][${item_ids_1}]</stringProp>
           </elementProp>
-          <elementProp name="sorting[direction]" elementType="HTTPArgument">
+          <elementProp name="shipment[items][${item_ids_2}]" elementType="HTTPArgument">
             <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">asc</stringProp>
+            <stringProp name="Argument.value">1</stringProp>
             <stringProp name="Argument.metadata">=</stringProp>
             <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">sorting[direction]</stringProp>
-            <stringProp name="Argument.desc">true</stringProp>
+            <stringProp name="Argument.name">shipment[items][${item_ids_2}]</stringProp>
           </elementProp>
-          <elementProp name="isAjax" elementType="HTTPArgument">
+          <elementProp name="shipment[comment_text]" elementType="HTTPArgument">
             <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">true</stringProp>
+            <stringProp name="Argument.value">Shipped</stringProp>
             <stringProp name="Argument.metadata">=</stringProp>
             <boolProp name="HTTPArgument.use_equals">true</boolProp>
-            <stringProp name="Argument.name">isAjax</stringProp>
-            <stringProp name="Argument.desc">true</stringProp>
+            <stringProp name="Argument.name">shipment[comment_text]</stringProp>
           </elementProp>
         </collectionProp>
       </elementProp>
@@ -34020,19 +34828,19 @@ vars.put("grid_pages_count_filtered", pageCount);
       <stringProp name="HTTPSampler.response_timeout"/>
       <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
       <stringProp name="HTTPSampler.contentEncoding"/>
-      <stringProp name="HTTPSampler.path">${base_path}${admin_path}/mui/index/render/</stringProp>
-      <stringProp name="HTTPSampler.method">GET</stringProp>
+      <stringProp name="HTTPSampler.path">${base_path}${admin_path}/admin/order_shipment/save/order_id/${order_id}/</stringProp>
+      <stringProp name="HTTPSampler.method">POST</stringProp>
       <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
       <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
       <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
       <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
       <boolProp name="HTTPSampler.monitor">false</boolProp>
       <stringProp name="HTTPSampler.embedded_url_re"/>
-    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_grid_browsing/admin_browse_grid.jmx</stringProp></HTTPSamplerProxy>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_edit_order/shipment_submit.jmx</stringProp></HTTPSamplerProxy>
     <hashTree>
       <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Response Assertion" enabled="true">
         <collectionProp name="Asserion.test_strings">
-          <stringProp name="1637639774">\"totalRecords\":[^0]\d*</stringProp>
+          <stringProp name="-2089453199">The shipment has been created</stringProp>
         </collectionProp>
         <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
         <boolProp name="Assertion.assume_success">false</boolProp>
@@ -34040,136 +34848,40 @@ vars.put("grid_pages_count_filtered", pageCount);
       </ResponseAssertion>
       <hashTree/>
     </hashTree>
+  </hashTree>
+  </hashTree>
   
-    <CounterConfig guiclass="CounterConfigGui" testclass="CounterConfig" testname="SetUp - Select Filtered ${gridEntityType} Page Number" enabled="true">
-      <stringProp name="CounterConfig.start">1</stringProp>
-      <stringProp name="CounterConfig.end">${grid_pages_count_filtered}</stringProp>
-      <stringProp name="CounterConfig.incr">1</stringProp>
-      <stringProp name="CounterConfig.name">page_number</stringProp>
-      <stringProp name="CounterConfig.format"/>
-      <boolProp name="CounterConfig.per_user">true</boolProp>
-      <boolProp name="CounterConfig.reset_on_tg_iteration">false</boolProp>
-    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_grid_browsing/select_filtered_page_number.jmx</stringProp></CounterConfig>
-    <hashTree/>
-  
-    <TestFragmentController guiclass="TestFragmentControllerGui" testclass="TestFragmentController" testname="View ${gridEntityType} page - Filtering + Sorting" enabled="true">
-  <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/admin_grid_browsing/admin_browse_grid_sort_and_filter.jmx</stringProp>
-</TestFragmentController>
+    <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="Logout" enabled="true">
+      <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
+        <collectionProp name="Arguments.arguments"/>
+      </elementProp>
+      <stringProp name="HTTPSampler.domain"/>
+      <stringProp name="HTTPSampler.port"/>
+      <stringProp name="HTTPSampler.connect_timeout"/>
+      <stringProp name="HTTPSampler.response_timeout"/>
+      <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
+      <stringProp name="HTTPSampler.contentEncoding"/>
+      <stringProp name="HTTPSampler.path">${base_path}${admin_path}/admin/auth/logout/</stringProp>
+      <stringProp name="HTTPSampler.method">GET</stringProp>
+      <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
+      <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
+      <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
+      <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
+      <boolProp name="HTTPSampler.monitor">false</boolProp>
+      <stringProp name="HTTPSampler.embedded_url_re"/>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/setup/admin_logout.jmx</stringProp></HTTPSamplerProxy>
     <hashTree>
-      <ForeachController guiclass="ForeachControlPanel" testclass="ForeachController" testname="ForEach Sort Field Defined" enabled="true">
-        <stringProp name="ForeachController.inputVal">grid_sort_field</stringProp>
-        <stringProp name="ForeachController.returnVal">grid_sort_field</stringProp>
-        <boolProp name="ForeachController.useSeparator">true</boolProp>
-        <stringProp name="ForeachController.startIndex">0</stringProp>
-        <stringProp name="ForeachController.endIndex">3</stringProp>
-      </ForeachController>
-      <hashTree>
-        <ForeachController guiclass="ForeachControlPanel" testclass="ForeachController" testname="ForEach Sort Order Defined" enabled="true">
-          <stringProp name="ForeachController.inputVal">grid_sort_order</stringProp>
-          <stringProp name="ForeachController.returnVal">grid_sort_order</stringProp>
-          <boolProp name="ForeachController.useSeparator">true</boolProp>
-          <stringProp name="ForeachController.startIndex">0</stringProp>
-          <stringProp name="ForeachController.endIndex">2</stringProp>
-        </ForeachController>
-        <hashTree>
-          <HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="View ${gridEntityType} page - Filtering + Sort By ${grid_sort_field} ${grid_sort_order}" enabled="true">
-            <elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" enabled="true">
-              <collectionProp name="Arguments.arguments">
-                <elementProp name="namespace" elementType="HTTPArgument">
-                  <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                  <stringProp name="Argument.value">${grid_namespace}</stringProp>
-                  <stringProp name="Argument.metadata">=</stringProp>
-                  <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                  <stringProp name="Argument.name">namespace</stringProp>
-                  <stringProp name="Argument.desc">false</stringProp>
-                </elementProp>
-                <elementProp name="filters[${grid_filter_field}]" elementType="HTTPArgument">
-                  <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                  <stringProp name="Argument.value">${grid_admin_browse_filter_text}</stringProp>
-                  <stringProp name="Argument.metadata">=</stringProp>
-                  <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                  <stringProp name="Argument.name">filters[${grid_filter_field}]</stringProp>
-                  <stringProp name="Argument.desc">false</stringProp>
-                </elementProp>
-                <elementProp name="filters[placeholder]" elementType="HTTPArgument">
-                  <boolProp name="HTTPArgument.always_encode">true</boolProp>
-            <stringProp name="Argument.value">true</stringProp>
-                  <stringProp name="Argument.metadata">=</stringProp>
-                  <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                  <stringProp name="Argument.name">filters[placeholder]</stringProp>
-                  <stringProp name="Argument.desc">false</stringProp>
-                </elementProp>
-                <elementProp name="paging[pageSize]" elementType="HTTPArgument">
-                  <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                  <stringProp name="Argument.value">${grid_entity_page_size}</stringProp>
-                  <stringProp name="Argument.metadata">=</stringProp>
-                  <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                  <stringProp name="Argument.name">paging[pageSize]</stringProp>
-                  <stringProp name="Argument.desc">false</stringProp>
-                </elementProp>
-                <elementProp name="paging[current]" elementType="HTTPArgument">
-                  <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                  <stringProp name="Argument.value">${page_number}</stringProp>
-                  <stringProp name="Argument.metadata">=</stringProp>
-                  <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                  <stringProp name="Argument.name">paging[current]</stringProp>
-                  <stringProp name="Argument.desc">false</stringProp>
-                </elementProp>
-                <elementProp name="sorting[field]" elementType="HTTPArgument">
-                  <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                  <stringProp name="Argument.value">${grid_sort_field}</stringProp>
-                  <stringProp name="Argument.metadata">=</stringProp>
-                  <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                  <stringProp name="Argument.name">sorting[field]</stringProp>
-                  <stringProp name="Argument.desc">false</stringProp>
-                </elementProp>
-                <elementProp name="sorting[direction]" elementType="HTTPArgument">
-                  <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                  <stringProp name="Argument.value">${grid_sort_order}</stringProp>
-                  <stringProp name="Argument.metadata">=</stringProp>
-                  <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                  <stringProp name="Argument.name">sorting[direction]</stringProp>
-                  <stringProp name="Argument.desc">false</stringProp>
-                </elementProp>
-                <elementProp name="isAjax" elementType="HTTPArgument">
-                  <boolProp name="HTTPArgument.always_encode">true</boolProp>
-                  <stringProp name="Argument.value">true</stringProp>
-                  <stringProp name="Argument.metadata">=</stringProp>
-                  <boolProp name="HTTPArgument.use_equals">true</boolProp>
-                  <stringProp name="Argument.name">isAjax</stringProp>
-                  <stringProp name="Argument.desc">false</stringProp>
-                </elementProp>
-              </collectionProp>
-            </elementProp>
-            <stringProp name="HTTPSampler.domain"/>
-            <stringProp name="HTTPSampler.port"/>
-            <stringProp name="HTTPSampler.connect_timeout"/>
-            <stringProp name="HTTPSampler.response_timeout"/>
-            <stringProp name="HTTPSampler.protocol">${request_protocol}</stringProp>
-            <stringProp name="HTTPSampler.contentEncoding"/>
-            <stringProp name="HTTPSampler.path">${base_path}${admin_path}/mui/index/render/</stringProp>
-            <stringProp name="HTTPSampler.method">GET</stringProp>
-            <boolProp name="HTTPSampler.follow_redirects">true</boolProp>
-            <boolProp name="HTTPSampler.auto_redirects">false</boolProp>
-            <boolProp name="HTTPSampler.use_keepalive">true</boolProp>
-            <boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
-            <boolProp name="HTTPSampler.monitor">false</boolProp>
-            <stringProp name="HTTPSampler.embedded_url_re"/>
-          </HTTPSamplerProxy>
-          <hashTree>
-            <ResponseAssertion guiclass="AssertionGui" testclass="ResponseAssertion" testname="Response Assertion" enabled="true">
-              <collectionProp name="Asserion.test_strings">
-                <stringProp name="1637639774">\"totalRecords\":[^0]\d*</stringProp>
-              </collectionProp>
-              <stringProp name="Assertion.test_field">Assertion.response_data</stringProp>
-              <boolProp name="Assertion.assume_success">false</boolProp>
-              <intProp name="Assertion.test_type">2</intProp>
-            </ResponseAssertion>
-            <hashTree/>
-          </hashTree>
-        </hashTree>
-      </hashTree>
-    </hashTree>
+    
+    <BeanShellPostProcessor guiclass="TestBeanGUI" testclass="BeanShellPostProcessor" testname="Return Admin to Pool" enabled="true">
+        <boolProp name="resetInterpreter">false</boolProp>
+        <stringProp name="parameters"/>
+        <stringProp name="filename"/>
+        <stringProp name="script">
+adminUserList = props.get("adminUserList");
+adminUserList.add(vars.get("admin_user"));
+        </stringProp>
+    <stringProp name="TestPlan.comments">mpaf/tool/fragments/ce/common/return_admin_email_to_pool.jmx</stringProp></BeanShellPostProcessor>
+    <hashTree/>
   </hashTree>
   </hashTree>
 
@@ -34270,17 +34982,6 @@ vars.put("grid_pages_count_filtered", pageCount);
         <boolProp name="CookieManager.clearEachIteration">true</boolProp>
       </CookieManager>
       <hashTree/>
-      <BeanShellSampler guiclass="BeanShellSamplerGui" testclass="BeanShellSampler" testname="SetUp - BeanShell Sampler: Clear properties" enabled="true">
-        <stringProp name="BeanShellSampler.query">props.remove("category_url_key");
-props.remove("category_name");
-props.remove("simple_products_list");
-props.remove("configurable_products_list");
-props.remove("customer_emails_list");</stringProp>
-        <stringProp name="BeanShellSampler.filename"/>
-        <stringProp name="BeanShellSampler.parameters"/>
-        <boolProp name="BeanShellSampler.resetInterpreter">false</boolProp>
-      </BeanShellSampler>
-      <hashTree/>
     </hashTree>
   
     <ResultCollector guiclass="StatGraphVisualizer" testclass="ResultCollector" testname="Aggregate Graph" enabled="false">
diff --git a/setup/performance-toolkit/profiles/ce/extra_large.xml b/setup/performance-toolkit/profiles/ce/extra_large.xml
index 830d1d95d7d21a4505dcb35b289a7aabfc234360..44b3512090b12c59483db9e3dcd97048b57b19ef 100644
--- a/setup/performance-toolkit/profiles/ce/extra_large.xml
+++ b/setup/performance-toolkit/profiles/ce/extra_large.xml
@@ -7,6 +7,7 @@
 -->
 <config xmlns:xi="http://www.w3.org/2001/XInclude">
     <profile>
+        <admin_users>50</admin_users><!-- Number of admin users to generate -->
         <websites>5</websites> <!-- Number of websites to generate -->
         <store_groups>5</store_groups> <!--Number of stores-->
         <store_views>5</store_views> <!-- Number of store views -->
diff --git a/setup/performance-toolkit/profiles/ce/large.xml b/setup/performance-toolkit/profiles/ce/large.xml
index dd297b21d350357d4514e0340762c2d8eea6ab74..606c854d27adc2d72d05f53b00fe68e0e7888a44 100644
--- a/setup/performance-toolkit/profiles/ce/large.xml
+++ b/setup/performance-toolkit/profiles/ce/large.xml
@@ -7,6 +7,7 @@
 -->
 <config xmlns:xi="http://www.w3.org/2001/XInclude">
     <profile>
+        <admin_users>50</admin_users><!-- Number of admin users to generate -->
         <websites>5</websites> <!-- Number of websites to generate -->
         <store_groups>5</store_groups> <!--Number of stores-->
         <store_views>5</store_views> <!-- Number of store views -->
diff --git a/setup/performance-toolkit/profiles/ce/medium.xml b/setup/performance-toolkit/profiles/ce/medium.xml
index 896ab92d32f33828c9a093fb4c18a536950fd701..4f735ae4ac2d417cdc55a6953d25302528e0c659 100644
--- a/setup/performance-toolkit/profiles/ce/medium.xml
+++ b/setup/performance-toolkit/profiles/ce/medium.xml
@@ -7,6 +7,7 @@
 -->
 <config xmlns:xi="http://www.w3.org/2001/XInclude">
     <profile>
+        <admin_users>50</admin_users><!-- Number of admin users to generate -->
         <websites>3</websites> <!-- Number of websites to generate -->
         <store_groups>3</store_groups> <!--Number of stores-->
         <store_views>3</store_views> <!-- Number of store views -->
diff --git a/setup/performance-toolkit/profiles/ce/medium_msite.xml b/setup/performance-toolkit/profiles/ce/medium_msite.xml
index 245eed4c18fe1c2cd2be1c3f9aa3e5df8ed8a5ee..24d51d170fbc2265fd4dcfd90bffc7f05b2f4a35 100644
--- a/setup/performance-toolkit/profiles/ce/medium_msite.xml
+++ b/setup/performance-toolkit/profiles/ce/medium_msite.xml
@@ -7,6 +7,7 @@
 -->
 <config xmlns:xi="http://www.w3.org/2001/XInclude">
     <profile>
+        <admin_users>50</admin_users><!-- Number of admin users to generate -->
         <websites>25</websites> <!-- Number of websites to generate -->
         <store_groups>25</store_groups> <!--Number of stores-->
         <store_views>50</store_views> <!-- Number of store views -->
diff --git a/setup/performance-toolkit/profiles/ce/small.xml b/setup/performance-toolkit/profiles/ce/small.xml
index cbcb4764f0f894d04512387532aaf560927b0e65..270828c2a2c9d947afae6a39d522042bc26561c2 100644
--- a/setup/performance-toolkit/profiles/ce/small.xml
+++ b/setup/performance-toolkit/profiles/ce/small.xml
@@ -7,6 +7,7 @@
 -->
 <config xmlns:xi="http://www.w3.org/2001/XInclude">
     <profile>
+        <admin_users>50</admin_users><!-- Number of admin users to generate -->
         <websites>1</websites> <!-- Number of websites to generate -->
         <store_groups>1</store_groups> <!--Number of stores-->
         <store_views>1</store_views> <!-- Number of store views -->
diff --git a/setup/src/Magento/Setup/Console/Command/GenerateFixturesCommand.php b/setup/src/Magento/Setup/Console/Command/GenerateFixturesCommand.php
index eb0efd3983fa22411d8ab3ff4210a959f0ce5091..c817d2e07660a35e478747f5156a0d21225089a8 100644
--- a/setup/src/Magento/Setup/Console/Command/GenerateFixturesCommand.php
+++ b/setup/src/Magento/Setup/Console/Command/GenerateFixturesCommand.php
@@ -17,6 +17,7 @@ use Symfony\Component\Console\Output\OutputInterface;
 
 /**
  * Command generates fixtures for performance tests
+ * @SuppressWarnings(PHPMD.CouplingBetweenObjects)
  */
 class GenerateFixturesCommand extends Command
 {
@@ -83,35 +84,33 @@ class GenerateFixturesCommand extends Command
                 $fixture->printInfo($output);
             }
 
+            /** @var \Magento\Setup\Fixtures\ConfigsApplyFixture $configFixture */
+            $configFixture = $fixtureModel
+                ->getFixtureByName(\Magento\Setup\Fixtures\ConfigsApplyFixture::class);
+            $configFixture && $this->executeFixture($configFixture, $output);
+
             /** @var $config \Magento\Indexer\Model\Config */
             $config = $fixtureModel->getObjectManager()->get(\Magento\Indexer\Model\Config::class);
             $indexerListIds = $config->getIndexers();
             /** @var $indexerRegistry \Magento\Framework\Indexer\IndexerRegistry */
             $indexerRegistry = $fixtureModel->getObjectManager()
                 ->create(\Magento\Framework\Indexer\IndexerRegistry::class);
-            $indexersState = [];
+
             foreach ($indexerListIds as $indexerId) {
                 $indexer = $indexerRegistry->get($indexerId['indexer_id']);
-                $indexersState[$indexerId['indexer_id']] = $indexer->isScheduled();
                 $indexer->setScheduled(true);
             }
 
             foreach ($fixtureModel->getFixtures() as $fixture) {
-                $output->write('<info>' . $fixture->getActionTitle() . '... </info>');
-                $startTime = microtime(true);
-                $fixture->execute($output);
-                $endTime = microtime(true);
-                $resultTime = $endTime - $startTime;
-                $output->writeln('<info> done in ' . gmdate('H:i:s', $resultTime) . '</info>');
+                $this->executeFixture($fixture, $output);
             }
 
             $this->clearChangelog();
 
-            foreach ($indexerListIds as $indexerId) {
-                /** @var $indexer \Magento\Indexer\Model\Indexer */
-                $indexer = $indexerRegistry->get($indexerId['indexer_id']);
-                $indexer->setScheduled($indexersState[$indexerId['indexer_id']]);
-            }
+            /** @var \Magento\Setup\Fixtures\IndexersStatesApplyFixture $indexerFixture */
+            $indexerFixture = $fixtureModel
+                ->getFixtureByName(\Magento\Setup\Fixtures\IndexersStatesApplyFixture::class);
+            $indexerFixture && $this->executeFixture($indexerFixture, $output);
 
             if (!$input->getOption(self::SKIP_REINDEX_OPTION)) {
                 $fixtureModel->reindex($output);
@@ -148,4 +147,14 @@ class GenerateFixturesCommand extends Command
             }
         }
     }
+
+    private function executeFixture(\Magento\Setup\Fixtures\Fixture $fixture, OutputInterface $output)
+    {
+        $output->write('<info>' . $fixture->getActionTitle() . '... </info>');
+        $startTime = microtime(true);
+        $fixture->execute($output);
+        $endTime = microtime(true);
+        $resultTime = $endTime - $startTime;
+        $output->writeln('<info> done in ' . gmdate('H:i:s', $resultTime) . '</info>');
+    }
 }
diff --git a/setup/src/Magento/Setup/Fixtures/ConfigsApplyFixture.php b/setup/src/Magento/Setup/Fixtures/ConfigsApplyFixture.php
index d65441f878cc5ad09e70db88f9e7b4fda7d6ac38..6c6fdbd9fa6f8aaaf1e909f565fe7742bc816630 100644
--- a/setup/src/Magento/Setup/Fixtures/ConfigsApplyFixture.php
+++ b/setup/src/Magento/Setup/Fixtures/ConfigsApplyFixture.php
@@ -14,7 +14,7 @@ class ConfigsApplyFixture extends Fixture
     /**
      * @var int
      */
-    protected $priority = 0;
+    protected $priority = -1;
 
     /**
      * {@inheritdoc}
@@ -41,8 +41,13 @@ class ConfigsApplyFixture extends Fixture
                 ->setValue($config['value'])
                 ->save();
         }
-        $this->fixtureModel->getObjectManager()->get(\Magento\Framework\App\CacheInterface::class)
+        $this->fixtureModel->getObjectManager()
+            ->get(\Magento\Framework\App\CacheInterface::class)
             ->clean([\Magento\Framework\App\Config::CACHE_TAG]);
+
+        $this->fixtureModel->getObjectManager()
+            ->get(\Magento\Config\App\Config\Type\System::class)
+            ->clean();
     }
 
     /**
diff --git a/setup/src/Magento/Setup/Fixtures/FixtureModel.php b/setup/src/Magento/Setup/Fixtures/FixtureModel.php
index 6466bf73310d76c0fceac1e49752312bcdbaac70..104c9cb343216b749e847b1700759befce21e3d8 100644
--- a/setup/src/Magento/Setup/Fixtures/FixtureModel.php
+++ b/setup/src/Magento/Setup/Fixtures/FixtureModel.php
@@ -10,6 +10,7 @@
 namespace Magento\Setup\Fixtures;
 
 use Magento\Indexer\Console\Command\IndexerReindexCommand;
+use Magento\Setup\Exception;
 use Symfony\Component\Console\Input\ArrayInput;
 use Symfony\Component\Console\Output\OutputInterface;
 
@@ -47,6 +48,13 @@ class FixtureModel
      */
     protected $fixtures = [];
 
+    /**
+     * List of fixtures indexed by class names
+     *
+     * @var \Magento\Setup\Fixtures\Fixture[]
+     */
+    private $fixturesByNames = [];
+
     /**
      * Parameters labels
      *
@@ -109,12 +117,18 @@ class FixtureModel
                     'fixtureModel' => $this,
                 ]
             );
+
             if (isset($this->fixtures[$fixture->getPriority()])) {
                 throw new \InvalidArgumentException(
                     sprintf('Duplicate priority %d in fixture %s', $fixture->getPriority(), $type)
                 );
             }
-            $this->fixtures[$fixture->getPriority()] = $fixture;
+
+            if ($fixture->getPriority() >= 0) {
+                $this->fixtures[$fixture->getPriority()] = $fixture;
+            }
+
+            $this->fixturesByNames[get_class($fixture)] = $fixture;
         }
 
         ksort($this->fixtures);
@@ -142,6 +156,21 @@ class FixtureModel
         return $this->fixtures;
     }
 
+    /**
+     * Returns fixture by name
+     * @param $name string
+     * @return \Magento\Setup\Fixtures\Fixture
+     * @throws \Magento\Setup\Exception
+     */
+    public function getFixtureByName($name)
+    {
+        if (!array_key_exists($name, $this->fixturesByNames)) {
+            throw new Exception('Wrong fixture name');
+        }
+
+        return $this->fixturesByNames[$name];
+    }
+
     /**
      * Get object manager
      *
diff --git a/setup/src/Magento/Setup/Fixtures/IndexersStatesApplyFixture.php b/setup/src/Magento/Setup/Fixtures/IndexersStatesApplyFixture.php
index 7b5bd92663008358e8e87552efd8136166356508..b07ce33089814db2de4994c01ef9dd3805c37a9e 100644
--- a/setup/src/Magento/Setup/Fixtures/IndexersStatesApplyFixture.php
+++ b/setup/src/Magento/Setup/Fixtures/IndexersStatesApplyFixture.php
@@ -14,7 +14,7 @@ class IndexersStatesApplyFixture extends Fixture
     /**
      * @var int
      */
-    protected $priority = 170;
+    protected $priority = -1;
 
     /**
      * {@inheritdoc}
@@ -25,10 +25,18 @@ class IndexersStatesApplyFixture extends Fixture
         if (!isset($indexers["indexer"]) || empty($indexers["indexer"])) {
             return;
         }
+
         $this->fixtureModel->resetObjectManager();
-        foreach ($indexers["indexer"] as $indexer) {
-            $this->fixtureModel->indexersStates[$indexer['id']] = ($indexer['set_scheduled'] == "true");
+
+        /** @var $indexerRegistry \Magento\Framework\Indexer\IndexerRegistry */
+        $indexerRegistry = $this->fixtureModel->getObjectManager()
+            ->create(\Magento\Framework\Indexer\IndexerRegistry::class);
+
+        foreach ($indexers["indexer"] as $indexerConfig) {
+            $indexer = $indexerRegistry->get($indexerConfig['id']);
+            $indexer->setScheduled($indexerConfig['set_scheduled'] == "true");
         }
+
         $this->fixtureModel->getObjectManager()->get(\Magento\Framework\App\CacheInterface::class)
             ->clean([\Magento\Framework\App\Config::CACHE_TAG]);
     }
diff --git a/setup/src/Magento/Setup/Test/Unit/Fixtures/ConfigsApplyFixtureTest.php b/setup/src/Magento/Setup/Test/Unit/Fixtures/ConfigsApplyFixtureTest.php
index 7622347aebb937198aa9bcb32fc70777755ab87d..954ea4be82521fa2f761d70dd9da8e8653167cd5 100644
--- a/setup/src/Magento/Setup/Test/Unit/Fixtures/ConfigsApplyFixtureTest.php
+++ b/setup/src/Magento/Setup/Test/Unit/Fixtures/ConfigsApplyFixtureTest.php
@@ -33,21 +33,27 @@ class ConfigsApplyFixtureTest extends \PHPUnit\Framework\TestCase
         $cacheMock = $this->createMock(\Magento\Framework\App\Cache::class);
 
         $valueMock = $this->createMock(\Magento\Framework\App\Config::class);
+        $configMock = $this->createMock(\Magento\Config\App\Config\Type\System::class);
 
         $objectManagerMock = $this->createMock(\Magento\Framework\ObjectManager\ObjectManager::class);
-        $objectManagerMock->expects($this->once())
+        $objectManagerMock
             ->method('get')
-            ->will($this->returnValue($cacheMock));
+            ->willReturnMap([
+                [\Magento\Framework\App\CacheInterface::class, $cacheMock],
+                [\Magento\Config\App\Config\Type\System::class, $configMock]
+            ]);
 
         $this->fixtureModelMock
             ->expects($this->once())
             ->method('getValue')
             ->will($this->returnValue(['config' => $valueMock]));
         $this->fixtureModelMock
-            ->expects($this->once())
             ->method('getObjectManager')
             ->will($this->returnValue($objectManagerMock));
 
+        $cacheMock->method('clean');
+        $configMock->method('clean');
+
         $this->model->execute();
     }
 
diff --git a/setup/src/Magento/Setup/Test/Unit/Fixtures/IndexersStatesApplyFixtureTest.php b/setup/src/Magento/Setup/Test/Unit/Fixtures/IndexersStatesApplyFixtureTest.php
index 0298fc05116f6144362421148f87df3a2ae98ca8..3c8d30fb6dfccca141a7d7fdf11d229877c10065 100644
--- a/setup/src/Magento/Setup/Test/Unit/Fixtures/IndexersStatesApplyFixtureTest.php
+++ b/setup/src/Magento/Setup/Test/Unit/Fixtures/IndexersStatesApplyFixtureTest.php
@@ -30,11 +30,23 @@ class IndexersStatesApplyFixtureTest extends \PHPUnit\Framework\TestCase
     public function testExecute()
     {
         $cacheInterfaceMock = $this->createMock(\Magento\Framework\App\CacheInterface::class);
+        $indexerRegistryMock = $this->createMock(\Magento\Framework\Indexer\IndexerRegistry::class);
+        $indexerMock = $this->getMockForAbstractClass(\Magento\Framework\Indexer\IndexerInterface::class);
+
+        $indexerRegistryMock->expects($this->once())
+            ->method('get')
+            ->willReturn($indexerMock);
+
+        $indexerMock->expects($this->once())
+            ->method('setScheduled');
 
         $objectManagerMock = $this->createMock(\Magento\Framework\ObjectManager\ObjectManager::class);
         $objectManagerMock->expects($this->once())
             ->method('get')
             ->willReturn($cacheInterfaceMock);
+        $objectManagerMock->expects($this->once())
+            ->method('create')
+            ->willReturn($indexerRegistryMock);
 
         $this->fixtureModelMock
             ->expects($this->once())
@@ -43,7 +55,6 @@ class IndexersStatesApplyFixtureTest extends \PHPUnit\Framework\TestCase
                 'indexer' => ['id' => 1]
             ]);
         $this->fixtureModelMock
-            ->expects($this->once())
             ->method('getObjectManager')
             ->willReturn($objectManagerMock);