MAGETWO-65422: Write default configs to shared configuration file by app:config:dump

Bohdan Korablov · Bohdan Korablov · commit 3d282f213dd5 · 2017-06-22T12:26:34.000+03:00
diff --git a/app/code/Magento/Config/Model/PreparedValueFactory.php b/app/code/Magento/Config/Model/PreparedValueFactory.php
@@ -12,7 +12,7 @@
 use Magento\Framework\App\Config\ValueInterface;
 use Magento\Framework\App\Config\Value;
 use Magento\Framework\App\ScopeInterface;
-use Magento\Store\Model\ScopeInterface as StoreScopeInterface;
+use Magento\Store\Model\ScopeTypeNormalizer;
 use Magento\Framework\App\ScopeResolverPool;
 use Magento\Framework\Exception\RuntimeException;
 
@@ -52,22 +52,32 @@ class PreparedValueFactory
      */
     private $config;
 
+    /**
+     * The scope type normalizer.
+     *
+     * @var ScopeTypeNormalizer
+     */
+    private $scopeTypeNormalizer;
+
     /**
      * @param ScopeResolverPool $scopeResolverPool The scope resolver pool
      * @param StructureFactory $structureFactory The manager for system configuration structure
      * @param BackendFactory $valueFactory The factory for configuration value objects
      * @param ScopeConfigInterface $config The scope configuration
+     * @param ScopeTypeNormalizer $scopeTypeNormalizer The scope type normalizer
      */
     public function __construct(
         ScopeResolverPool $scopeResolverPool,
         StructureFactory $structureFactory,
         BackendFactory $valueFactory,
-        ScopeConfigInterface $config
+        ScopeConfigInterface $config,
+        ScopeTypeNormalizer $scopeTypeNormalizer
     ) {
         $this->scopeResolverPool = $scopeResolverPool;
         $this->structureFactory = $structureFactory;
         $this->valueFactory = $valueFactory;
         $this->config = $config;
+        $this->scopeTypeNormalizer = $scopeTypeNormalizer;
     }
 
     /**
@@ -106,20 +116,26 @@ public function create($path, $value, $scope, $scopeCode = null)
             if ($backendModel instanceof Value) {
                 $scopeId = 0;
 
-                if (in_array($scope, [StoreScopeInterface::SCOPE_WEBSITE, StoreScopeInterface::SCOPE_WEBSITES])) {
-                    $scope = StoreScopeInterface::SCOPE_WEBSITES;
-                } elseif (in_array($scope, [StoreScopeInterface::SCOPE_STORE, StoreScopeInterface::SCOPE_STORES])) {
-                    $scope = StoreScopeInterface::SCOPE_STORES;
-                }
+                $scope = $this->scopeTypeNormalizer->normalize($scope);
 
                 if ($scope !== ScopeInterface::SCOPE_DEFAULT) {
-                    $scopeResolver = $this->scopeResolverPool->get($scope);
-                    $scopeId = $scopeResolver->getScope($scopeCode)->getId();
+                    $scopeId = $this->scopeResolverPool->get($scope)
+                        ->getScope($scopeCode)
+                        ->getId();
+                }
+
+                if ($field instanceof Structure\Element\Field) {
+                    $groupPath = $field->getGroupPath();
+                    $group = $structure->getElement($groupPath);
+                    $backendModel->setField($field->getId());
+                    $backendModel->setGroupId($group->getId());
+                    $backendModel->setFieldConfig($field->getData());
                 }
 
                 $backendModel->setPath($configPath);
                 $backendModel->setScope($scope);
                 $backendModel->setScopeId($scopeId);
+                $backendModel->setScopeCode($scopeCode);
                 $backendModel->setValue($value);
             }
 
diff --git a/app/code/Magento/Config/Test/Unit/Model/PreparedValueFactoryTest.php b/app/code/Magento/Config/Test/Unit/Model/PreparedValueFactoryTest.php
@@ -12,15 +12,18 @@
 use Magento\Framework\App\Config\Value;
 use Magento\Config\Model\Config\Structure;
 use Magento\Config\Model\Config\Structure\Element\Field;
+use Magento\Config\Model\Config\Structure\Element\Group;
 use Magento\Framework\App\ScopeInterface;
 use Magento\Store\Model\ScopeInterface as StoreScopeInterface;
 use Magento\Framework\App\ScopeResolver;
 use Magento\Framework\App\ScopeResolverPool;
+use Magento\Store\Model\ScopeTypeNormalizer;
 use PHPUnit_Framework_MockObject_MockObject as Mock;
 
 /**
  * @inheritdoc
  * @SuppressWarnings(PHPMD.CouplingBetweenObjects)
+ * @SuppressWarnings(PHPMD.ExcessiveMethodLength)
  */
 class PreparedValueFactoryTest extends \PHPUnit_Framework_TestCase
 {
@@ -69,6 +72,11 @@ class PreparedValueFactoryTest extends \PHPUnit_Framework_TestCase
      */
     private $scopeMock;
 
+    /**
+     * @var ScopeTypeNormalizer|Mock
+     */
+    private $scopeTypeNormalizer;
+
     /**
      * @var PreparedValueFactory
      */
@@ -91,11 +99,15 @@ protected function setUp()
             ->disableOriginalConstructor()
             ->getMock();
         $this->fieldMock = $this->getMockBuilder(Field::class)
+            //->setMethods(['getData', 'getConfigPath', 'getId', 'hasBackendModel'])
             ->disableOriginalConstructor()
             ->getMock();
         $this->valueMock = $this->getMockBuilder(Value::class)
             ->disableOriginalConstructor()
-            ->setMethods(['setPath', 'setScope', 'setScopeId', 'setValue'])
+            ->setMethods([
+                'setPath', 'setScope', 'setScopeId', 'setValue', 'setField',
+                'setGroupId', 'setFieldConfig', 'setScopeCode'
+            ])
             ->getMock();
         $this->configMock = $this->getMockBuilder(ScopeConfigInterface::class)
             ->getMockForAbstractClass();
@@ -107,12 +119,16 @@ protected function setUp()
             ->getMock();
         $this->scopeMock = $this->getMockBuilder(ScopeInterface::class)
             ->getMockForAbstractClass();
+        $this->scopeTypeNormalizer = $this->getMockBuilder(ScopeTypeNormalizer::class)
+            ->disableOriginalConstructor()
+            ->getMock();
 
         $this->preparedValueFactory = new PreparedValueFactory(
             $this->scopeResolverPoolMock,
             $this->structureFactoryMock,
             $this->valueFactoryMock,
-            $this->configMock
+            $this->configMock,
+            $this->scopeTypeNormalizer
         );
     }
 
@@ -133,6 +149,11 @@ public function testCreate(
         $scopeCode,
         $scopeId
     ) {
+        $groupPath = 'some/group';
+        $groupId = 'some_group';
+        $fieldId = 'some_field';
+        $fieldData = ['backend_model' => 'some_model'];
+
         if (ScopeInterface::SCOPE_DEFAULT !== $scope) {
             $this->scopeResolverPoolMock->expects($this->once())
                 ->method('get')
@@ -146,19 +167,43 @@ public function testCreate(
                 ->method('getId')
                 ->willReturn($scopeId);
         }
+        /** @var Group|Mock $groupMock */
+        $groupMock = $this->getMockBuilder(Group::class)
+            ->disableOriginalConstructor()
+            ->getMock();
+        $groupMock->expects($this->once())
+            ->method('getId')
+            ->willReturn($groupId);
 
+        $this->scopeTypeNormalizer->expects($this->once())
+            ->method('normalize')
+            ->with($scope, true)
+            ->willReturnArgument(0);
         $this->structureFactoryMock->expects($this->once())
             ->method('create')
             ->willReturn($this->structureMock);
         $this->structureMock->expects($this->once())
             ->method('getElementByConfigPath')
             ->willReturn($this->fieldMock);
+        $this->structureMock->expects($this->once())
+            ->method('getElement')
+            ->with($groupPath)
+            ->willReturn($groupMock);
         $this->fieldMock->expects($this->once())
             ->method('hasBackendModel')
             ->willReturn(true);
         $this->fieldMock
             ->method('getConfigPath')
             ->willReturn($configPath);
+        $this->fieldMock
+            ->method('getId')
+            ->willReturn($fieldId);
+        $this->fieldMock
+            ->method('getData')
+            ->willReturn($fieldData);
+        $this->fieldMock->expects($this->once())
+            ->method('getGroupPath')
+            ->willReturn($groupPath);
         $this->valueFactoryMock->expects($this->once())
             ->method('create')
             ->willReturn($this->valueMock);
@@ -174,10 +219,26 @@ public function testCreate(
             ->method('setScopeId')
             ->with($scopeId)
             ->willReturnSelf();
+        $this->valueMock->expects($this->once())
+            ->method('setScopeCode')
+            ->with($scopeCode)
+            ->willReturnSelf();
         $this->valueMock->expects($this->once())
             ->method('setValue')
             ->with($value)
             ->willReturnSelf();
+        $this->valueMock->expects($this->once())
+            ->method('setField')
+            ->with($fieldId)
+            ->willReturnSelf();
+        $this->valueMock->expects($this->once())
+            ->method('setGroupId')
+            ->with($groupId)
+            ->willReturnSelf();
+        $this->valueMock->expects($this->once())
+            ->method('setFieldConfig')
+            ->with($fieldData)
+            ->willReturnSelf();
 
         $this->assertInstanceOf(
             Value::class,
diff --git a/app/code/Magento/Store/Model/ScopeTypeNormalizer.php b/app/code/Magento/Store/Model/ScopeTypeNormalizer.php
@@ -0,0 +1,63 @@
+<?php
+/**
+ * Copyright © 2013-2017 Magento, Inc. All rights reserved.
+ * See COPYING.txt for license details.
+ */
+namespace Magento\Store\Model;
+
+/**
+ * Normalizes scope types to the chosen form, plural or singular.
+ */
+class ScopeTypeNormalizer
+{
+    /**
+     * Normalizes scope types.
+     *
+     * We have a few forms of scope types in the plural and singular:
+     * websites, website, groups, group, stores, store
+     *
+     * This method returns scope type in the chosen form (plural or singular).
+     *
+     * For example, the next calls of this method returns 'website':
+     * ```php
+     * $this->normalize('websites', false);
+     * $this->normalize('website', false);
+     * ```
+     *
+     * This calls of this method returns 'websites':
+     * ```php
+     * $this->normalize('website', false);
+     * $this->normalize('websites', false);
+     * $this->normalize('website');
+     * $this->normalize('websites');
+     * ```
+     *
+     * If there is not scope in the list (websites, website, groups, group, stores, store)
+     * then it will be returned without changes.
+     *
+     * The next calls of this method returns 'default':
+     * ```php
+     * $this->normalize('default', false);
+     * $this->normalize('default', true);
+     * $this->normalize('default');
+     * ```
+     *
+     * @param string $scopeType The type of scope
+     * @param bool $plural The flag for choosing returned form of scope, in the plural or not. Used plural by default.
+     * @return string
+     */
+    public function normalize($scopeType, $plural = true)
+    {
+        $replaces = [
+            ScopeInterface::SCOPE_WEBSITE => ScopeInterface::SCOPE_WEBSITES,
+            ScopeInterface::SCOPE_GROUP => ScopeInterface::SCOPE_GROUPS,
+            ScopeInterface::SCOPE_STORE => ScopeInterface::SCOPE_STORES,
+        ];
+
+        if (!$plural) {
+            $replaces = array_flip($replaces);
+        }
+
+        return $replaces[$scopeType] ?? $scopeType;
+    }
+}
diff --git a/app/code/Magento/Store/Test/Unit/Model/ScopeTypeNormalizerTest.php b/app/code/Magento/Store/Test/Unit/Model/ScopeTypeNormalizerTest.php
@@ -0,0 +1,59 @@
+<?php
+/**
+ * Copyright © 2013-2017 Magento, Inc. All rights reserved.
+ * See COPYING.txt for license details.
+ */
+namespace Magento\Store\Test\Unit\Model;
+
+use Magento\Store\Model\ScopeTypeNormalizer;
+use Magento\Store\Model\ScopeInterface;
+
+class ScopeTypeNormalizerTest extends \PHPUnit_Framework_TestCase
+{
+    /**
+     * @var ScopeTypeNormalizer
+     */
+    private $scopeTypeNormalizer;
+
+    /**
+     * @inheritdoc
+     */
+    protected function setUp()
+    {
+        $this->scopeTypeNormalizer = new ScopeTypeNormalizer();
+    }
+
+    /**
+     * @param string $scopeType
+     * @param bool $plural
+     * @param string $expectedResult
+     * @dataProvider normalizeDataProvider
+     */
+    public function testNormalize($scopeType, $plural, $expectedResult)
+    {
+        $this->assertEquals($expectedResult, $this->scopeTypeNormalizer->normalize($scopeType, $plural));
+    }
+
+    /**
+     * @return array
+     */
+    public function normalizeDataProvider()
+    {
+        return [
+            [ScopeInterface::SCOPE_WEBSITE, true, ScopeInterface::SCOPE_WEBSITES],
+            [ScopeInterface::SCOPE_WEBSITES, true, ScopeInterface::SCOPE_WEBSITES],
+            [ScopeInterface::SCOPE_WEBSITE, false, ScopeInterface::SCOPE_WEBSITE],
+            [ScopeInterface::SCOPE_WEBSITES, false, ScopeInterface::SCOPE_WEBSITE],
+            [ScopeInterface::SCOPE_GROUP, true, ScopeInterface::SCOPE_GROUPS],
+            [ScopeInterface::SCOPE_GROUPS, true, ScopeInterface::SCOPE_GROUPS],
+            [ScopeInterface::SCOPE_GROUP, false, ScopeInterface::SCOPE_GROUP],
+            [ScopeInterface::SCOPE_GROUPS, false, ScopeInterface::SCOPE_GROUP],
+            [ScopeInterface::SCOPE_STORE, true, ScopeInterface::SCOPE_STORES],
+            [ScopeInterface::SCOPE_STORES, true, ScopeInterface::SCOPE_STORES],
+            [ScopeInterface::SCOPE_STORE, false, ScopeInterface::SCOPE_STORE],
+            [ScopeInterface::SCOPE_STORES, false, ScopeInterface::SCOPE_STORE],
+            ['default', true, 'default'],
+            ['default', false, 'default'],
+        ];
+    }
+}
