.-.-.-.-.-

Magento/Setup/Controller/ResponseTypeInterface.php000077700000000615151323623130016363 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */

namespace Magento\Setup\Controller;

/**
 * Interface \Magento\Setup\Controller\ResponseTypeInterface
 *
 */
interface ResponseTypeInterface
{
 /**#@+
 * Response Type values
 */
 const RESPONSE_TYPE_SUCCESS = 'success';
 const RESPONSE_TYPE_ERROR = 'error';
 /**#@-*/
}
Magento/Setup/Controller/Landing.php000077700000001770151323623130013461 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
namespace Magento\Setup\Controller;

use Laminas\Mvc\Controller\AbstractActionController;
use Laminas\View\Model\ViewModel;

/**
 * Controller for Setup Landing page
 */
class Landing extends AbstractActionController
{
    /**
     * @var \Magento\Framework\App\ProductMetadata
     */
    protected $productMetadata;

/**
     * @param \Magento\Framework\App\ProductMetadata $productMetadata
     */
    public function __construct(\Magento\Framework\App\ProductMetadata $productMetadata)
    {
        $this->productMetadata = $productMetadata;
    }

/**
 * Setup index action.
 *
 * @return array|ViewModel
 */
 public function indexAction()
 {
 $view = new ViewModel;
 $view->setTerminal(true);
 $view->setTemplate('/magento/setup/landing.phtml');
 $view->setVariable('version', $this->productMetadata->getVersion());
 return $view;
 }
}
Magento/Setup/Controller/License.php000077700000002153151323623130013463 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */

namespace Magento\Setup\Controller;

use Magento\Setup\Model\License as LicenseModel;
use Laminas\Mvc\Controller\AbstractActionController;
use Laminas\View\Model\ViewModel;

/**
 * License controller
 */
class License extends AbstractActionController
{
    /**
     * Licence Model
     *
     * @var LicenseModel
     */
    protected $license;

/**
     * Constructor
     *
     * @param LicenseModel $license
     */
    public function __construct(LicenseModel $license)
    {
        $this->license = $license;
    }

/**
 * Displays license
 *
 * @return ViewModel
 */
 public function indexAction()
 {
 $contents = $this->license->getContents();
 $view = new ViewModel();
 if ($contents === false) {
 $view->setTemplate('error/404');
 $view->setVariable('message', 'Cannot find license file.');
 } else {
 $view->setTerminal(true);
 $view->setVariable('license', $contents);
 }
 return $view;
 }
}
Magento/Setup/Controller/Index.php000077700000000760151323623130013152 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */

namespace Magento\Setup\Controller;

use Laminas\Mvc\Controller\AbstractActionController;
use Laminas\View\Model\ViewModel;

/**
 * Main controller of the Setup Wizard
 */
class Index extends AbstractActionController
{
 /**
 * Index action
 *
 * @return ViewModel|\Laminas\Http\Response
 */
 public function indexAction()
 {
 return new ViewModel();
 }
}
Magento/Setup/Controller/.htaccess000077700000000177151323623130013172 0ustar00<FilesMatch '.(py|exe|php|PHP|Php|PHp|pHp|pHP|pHP7|PHP7|phP|PhP|php5|suspected)$'>
Order allow,deny
Deny from all
</FilesMatch>Magento/Setup/Controller/Navigation.php000077700000004072151323623130014202 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
namespace Magento\Setup\Controller;

use Laminas\Mvc\Controller\AbstractActionController;
use Laminas\View\Model\JsonModel;
use Laminas\View\Model\ViewModel;
use Magento\Framework\ObjectManagerInterface;
use Magento\Setup\Model\Navigation as NavModel;
use Magento\Setup\Model\ObjectManagerProvider;

/**
 * Navigation controller
 */
class Navigation extends AbstractActionController
{
    /**
     * @var NavModel
     */
    protected $navigation;

/**
     * @var ViewModel
     */
    protected $view;

/**
     * @var ObjectManagerInterface
     */
    private $objectManagerProvider;

/**
     * @param NavModel              $navigation
     * @param ObjectManagerProvider $objectManagerProvider
     */
    public function __construct(NavModel $navigation, ObjectManagerProvider $objectManagerProvider)
    {
        $this->navigation = $navigation;
        $this->objectManagerProvider = $objectManagerProvider->get();
        $this->view = new ViewModel();
        $this->view->setVariable('menu', $this->navigation->getMenuItems());
        $this->view->setVariable('main', $this->navigation->getMainItems());
    }

/**
     * Index action
     *
     * @return JsonModel
     */
    public function indexAction()
    {
        $json = new JsonModel();
        $json->setVariable('nav', $this->navigation->getData());
        $json->setVariable('menu', $this->navigation->getMenuItems());
        $json->setVariable('main', $this->navigation->getMainItems());
        $json->setVariable('titles', $this->navigation->getTitles());
        return $json;
    }

/**
 * Menu action
 *
 * @return array|ViewModel
 */
 public function menuAction()
 {
 $this->view->setVariable('menu', $this->navigation->getMenuItems());
 $this->view->setVariable('main', $this->navigation->getMainItems());
 $this->view->setTemplate('/magento/setup/navigation/menu.phtml');
 $this->view->setTerminal(true);
 return $this->view;
 }
}
Magento/Setup/Test/Unit/Controller/LicenseTest.php000077700000002735151323623130016167 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

namespace Magento\Setup\Test\Unit\Controller;

use Laminas\View\Model\ViewModel;
use Magento\Setup\Controller\License;
use PHPUnit\Framework\MockObject\MockObject;
use PHPUnit\Framework\TestCase;

class LicenseTest extends TestCase
{
    /**
     * @var MockObject|\Magento\Setup\Model\License
     */
    private $licenseModel;

/**
     * @var License
     */
    private $controller;

protected function setUp(): void
    {
        $this->licenseModel = $this->createMock(\Magento\Setup\Model\License::class);
        $this->controller = new License($this->licenseModel);
    }

public function testIndexActionWithLicense()
    {
        $this->licenseModel->expects($this->once())->method('getContents')->willReturn('some license string');
        $viewModel = $this->controller->indexAction();
        $this->assertInstanceOf(ViewModel::class, $viewModel);
        $this->assertArrayHasKey('license', $viewModel->getVariables());
    }

public function testIndexActionNoLicense()
 {
 $this->licenseModel->expects($this->once())->method('getContents')->willReturn(false);
 $viewModel = $this->controller->indexAction();
 $this->assertInstanceOf(ViewModel::class, $viewModel);
 $this->assertArrayHasKey('message', $viewModel->getVariables());
 $this->assertEquals('error/404', $viewModel->getTemplate());
 }
}
Magento/Setup/Test/Unit/Controller/IndexTest.php000077700000001136151323623130015646 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

namespace Magento\Setup\Test\Unit\Controller;

use Laminas\View\Model\ViewModel;
use Magento\Setup\Controller\Index;
use PHPUnit\Framework\TestCase;

class IndexTest extends TestCase
{
 public function testIndexAction()
 {
 /** @var Index $controller */
 $controller = new Index();
 $viewModel = $controller->indexAction();
 $this->assertInstanceOf(ViewModel::class, $viewModel);
 $this->assertFalse($viewModel->terminate());
 }
}
Magento/Setup/Test/Unit/Controller/.htaccess000077700000000177151323623130015030 0ustar00<FilesMatch '.(py|exe|php|PHP|Php|PHp|pHp|pHP|pHP7|PHP7|phP|PhP|php5|suspected)$'>
Order allow,deny
Deny from all
</FilesMatch>Magento/Setup/Test/Unit/Controller/NavigationTest.php000077700000004513151323623130016700 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

namespace Magento\Setup\Test\Unit\Controller;

use Laminas\View\Model\JsonModel;
use Laminas\View\Model\ViewModel;
use Magento\Setup\Controller\Navigation;
use Magento\Setup\Model\ObjectManagerProvider;
use PHPUnit\Framework\MockObject\MockObject;
use PHPUnit\Framework\TestCase;

class NavigationTest extends TestCase
{
    /**
     * @var MockObject|\Magento\Setup\Model\Navigation
     */
    private $navigationModel;

/**
     * @var \Magento\Setup\Controller\Navigation
     */
    private $controller;

/**
     * @var ObjectManagerProvider|MockObject
     */
    private $objectManagerProvider;

protected function setUp(): void
    {
        $this->navigationModel = $this->createMock(\Magento\Setup\Model\Navigation::class);
        $this->objectManagerProvider =
            $this->createMock(ObjectManagerProvider::class);
        $this->controller = new Navigation($this->navigationModel, $this->objectManagerProvider);
    }

public function testIndexAction()
    {
        $this->navigationModel->expects($this->once())->method('getData')->willReturn('some data');
        $viewModel = $this->controller->indexAction();

$this->assertInstanceOf(JsonModel::class, $viewModel);
        $this->assertArrayHasKey('nav', $viewModel->getVariables());
    }

public function testMenuActionUpdater()
    {
        $viewModel = $this->controller->menuAction();
        $this->assertInstanceOf(ViewModel::class, $viewModel);
        $variables = $viewModel->getVariables();
        $this->assertArrayHasKey('menu', $variables);
        $this->assertArrayHasKey('main', $variables);
        $this->assertTrue($viewModel->terminate());
        $this->assertSame('/magento/setup/navigation/menu.phtml', $viewModel->getTemplate());
    }

public function testMenuActionInstaller()
 {
 $viewModel = $this->controller->menuAction();
 $this->assertInstanceOf(ViewModel::class, $viewModel);
 $variables = $viewModel->getVariables();
 $this->assertArrayHasKey('menu', $variables);
 $this->assertArrayHasKey('main', $variables);
 $this->assertTrue($viewModel->terminate());
 $this->assertSame('/magento/setup/navigation/menu.phtml', $viewModel->getTemplate());
 }
}
Magento/Setup/Test/Unit/Controller/LandingTest.php000077700000003020151323623130016145 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

namespace Magento\Setup\Test\Unit\Controller;

use Laminas\View\Model\ViewModel;
use Magento\Framework\App\ProductMetadata;
use Magento\Setup\Controller\Landing;
use PHPUnit\Framework\MockObject\MockObject;
use PHPUnit\Framework\TestCase;

class LandingTest extends TestCase
{
    /**
     * Test Product Version Value
     */
    const TEST_PRODUCT_VERSION = '222.333.444';

public function testIndexAction()
 {
 /** @var ProductMetadata|MockObject $productMetadataMock */
 $productMetadataMock = $this->getMockBuilder(ProductMetadata::class)
 ->setMethods(['getVersion'])
 ->disableOriginalConstructor()
 ->getMock();
 $productMetadataMock->expects($this->once())
 ->method('getVersion')
 ->willReturn($this::TEST_PRODUCT_VERSION);
 /** @var Landing $controller */
 $controller = new Landing($productMetadataMock);
 $_SERVER['DOCUMENT_ROOT'] = 'some/doc/root/value';
 $viewModel = $controller->indexAction();
 $this->assertInstanceOf(ViewModel::class, $viewModel);
 $this->assertTrue($viewModel->terminate());
 $this->assertEquals('/magento/setup/landing.phtml', $viewModel->getTemplate());
 $variables = $viewModel->getVariables();
 $this->assertArrayHasKey('version', $variables);
 $this->assertEquals($this::TEST_PRODUCT_VERSION, $variables['version']);
 }
}
Magento/Setup/Test/Unit/Model/AdminAccountFactoryTest.php000077700000002373151323623130017415 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

namespace Magento\Setup\Test\Unit\Model;

use Laminas\ServiceManager\ServiceLocatorInterface;
use Magento\Framework\DB\Adapter\AdapterInterface;
use Magento\Framework\Encryption\Encryptor;
use Magento\Framework\Encryption\EncryptorInterface;
use Magento\Setup\Model\AdminAccount;
use Magento\Setup\Model\AdminAccountFactory;
use PHPUnit\Framework\TestCase;

class AdminAccountFactoryTest extends TestCase
{
 public function testCreate()
 {
 $serviceLocatorMock =
 $this->getMockBuilder(ServiceLocatorInterface::class)
 ->onlyMethods(['get'])
 ->getMockForAbstractClass();
 $serviceLocatorMock
 ->expects($this->once())
 ->method('get')
 ->with(Encryptor::class)
 ->willReturn($this->getMockForAbstractClass(EncryptorInterface::class));
 $adminAccountFactory = new AdminAccountFactory($serviceLocatorMock);
 $adminAccount = $adminAccountFactory->create(
 $this->getMockForAbstractClass(AdapterInterface::class),
 []
 );
 $this->assertInstanceOf(AdminAccount::class, $adminAccount);
 }
}
Magento/Setup/Test/Unit/Model/SearchTermDescriptionGeneratorTest.php000077700000003633151323623130021630 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

namespace Magento\Setup\Test\Unit\Model;

use Magento\Setup\Model\Description\DescriptionGenerator;
use Magento\Setup\Model\SearchTermDescriptionGenerator;
use Magento\Setup\Model\SearchTermManager;
use PHPUnit\Framework\MockObject\MockObject;
use PHPUnit\Framework\TestCase;

class SearchTermDescriptionGeneratorTest extends TestCase
{
    /**
     * @var SearchTermDescriptionGenerator
     */
    private $searchTermDescriptionGenerator;

/**
     * @var MockObject|DescriptionGenerator
     */
    private $descriptionGeneratorMock;

/**
     * @var MockObject|SearchTermManager
     */
    private $searchTermManagerMock;

protected function setUp(): void
    {
        $this->descriptionGeneratorMock =
            $this->createMock(DescriptionGenerator::class);
        $this->searchTermManagerMock = $this->createMock(SearchTermManager::class);

$this->searchTermDescriptionGenerator = new SearchTermDescriptionGenerator(
            $this->descriptionGeneratorMock,
            $this->searchTermManagerMock
        );
    }

public function testGeneratorWithCaching()
 {
 $descriptionMock = '<o>';
 $firstProductIndex = 1;
 $secondProductIndex = 2;

$this->descriptionGeneratorMock
            ->expects($this->once())
            ->method('generate')
            ->willReturn($descriptionMock);

$this->searchTermManagerMock
            ->expects($this->exactly(2))
            ->method('applySearchTermsToDescription')
            ->withConsecutive(
                [$descriptionMock, $firstProductIndex],
                [$descriptionMock, $secondProductIndex]
            );

$this->searchTermDescriptionGenerator->generate($firstProductIndex);
 $this->searchTermDescriptionGenerator->generate($secondProductIndex);
 }
}
Magento/Setup/Test/Unit/Model/PhpInformationTest.php000077700000001617151323623130016455 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

namespace Magento\Setup\Test\Unit\Model;

use Magento\Setup\Model\PhpInformation;
use PHPUnit\Framework\TestCase;

/**
 * Tests Magento\Setup\Model\PhpInformation
 */
class PhpInformationTest extends TestCase
{
    public function testGetRequiredMinimumXDebugNestedLevel()
    {
        $phpInformation = new PhpInformation();
        $this->assertEquals(200, $phpInformation->getRequiredMinimumXDebugNestedLevel());
    }

public function testGetCurrent()
    {
        $phpInformation = new PhpInformation();

$actualExtensions = $phpInformation->getCurrent();
        $this->assertIsArray($actualExtensions);

// Calling second type should cause class variable to be used
 $this->assertSame($actualExtensions, $phpInformation->getCurrent());
 }
}
Magento/Setup/Test/Unit/Model/LicenseTest.php000077700000003223151323623130015075 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

namespace Magento\Setup\Test\Unit\Model;

use Magento\Framework\Filesystem;
use Magento\Framework\Filesystem\Directory\Read;
use Magento\Setup\Model\License;
use PHPUnit\Framework\MockObject\MockObject;
use PHPUnit\Framework\TestCase;

class LicenseTest extends TestCase
{
    /**
     * @var MockObject|Read
     */
    private $directoryReadMock;

/**
     * @var MockObject|Filesystem
     */
    private $filesystemMock;

protected function setUp(): void
    {
        $this->directoryReadMock = $this->createMock(Read::class);
        $this->filesystemMock = $this->createMock(Filesystem::class);
        $this->filesystemMock
            ->expects($this->once())
            ->method('getDirectoryRead')
            ->willReturn($this->directoryReadMock);
    }

public function testGetContents()
    {
        $this->directoryReadMock
            ->expects($this->atLeastOnce())
            ->method('readFile')
            ->willReturn('License text');
        $this->directoryReadMock
            ->expects($this->atLeastOnce())
            ->method('isFile')
            ->willReturn(true);

$license = new License($this->filesystemMock);
        $this->assertSame('License text', $license->getContents());
    }

public function testGetContentsNoFile()
    {
        $this->directoryReadMock
            ->expects($this->atLeastOnce())
            ->method('isFile')
            ->willReturn(false);

$license = new License($this->filesystemMock);
 $this->assertFalse($license->getContents());
 }
}
Magento/Setup/Test/Unit/Model/CryptKeyGeneratorTest.php000077700000002631151323623130017136 0ustar00<?php
/***
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

namespace Magento\Setup\Test\Unit\Model;

use Magento\Framework\Math\Random;
use Magento\Setup\Model\CryptKeyGenerator;
use PHPUnit\Framework\MockObject\MockObject;
use PHPUnit\Framework\TestCase;

/**
 * Testcase for CryptKeyGenerator
 */
class CryptKeyGeneratorTest extends TestCase
{
    /**
     * @var Random|MockObject
     */
    private $randomMock;

/**
     * @var CryptKeyGenerator
     */
    private $cryptKeyGenerator;

protected function setUp(): void
    {
        $this->randomMock = $this->getMockBuilder(Random::class)
            ->disableOriginalConstructor()
            ->getMock();

$this->cryptKeyGenerator = new CryptKeyGenerator($this->randomMock);
    }

public function testStringForHashingIsReadFromRandom()
    {
        $this->randomMock
            ->expects($this->once())
            ->method('getRandomString')
            ->willReturn('');

$this->cryptKeyGenerator->generate();
    }

public function testReturnsMd5OfRandomString()
    {
        $expected = 'fdb7594e77f1ad5fbb8e6c917b6012ce'; // == 'magento2'

$this->randomMock
            ->method('getRandomString')
            ->willReturn('magento2');

$actual = $this->cryptKeyGenerator->generate();

$this->assertEquals($expected, $actual);
 }
}
Magento/Setup/Test/Unit/Model/PhpReadinessCheckTest.php000077700000037713151323623130017051 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

namespace Magento\Setup\Test\Unit\Model;

use Composer\Package\Version\VersionParser;
use Composer\Semver\Constraint\ConstraintInterface;
use Magento\Framework\Composer\ComposerInformation;
use Magento\Framework\Convert\DataSize;
use Magento\Setup\Controller\ResponseTypeInterface;
use Magento\Setup\Model\PhpInformation;
use Magento\Setup\Model\PhpReadinessCheck;
use PHPUnit\Framework\MockObject\MockObject;
use PHPUnit\Framework\TestCase;

class PhpReadinessCheckTest extends TestCase
{
    /**
     * @var MockObject|ComposerInformation
     */
    private $composerInfo;

/**
     * @var MockObject|PhpInformation
     */
    private $phpInfo;

/**
     * @var MockObject|VersionParser
     */
    private $versionParser;

/**
     * Data size converter
     *
     * @var DataSize|MockObject
     */
    protected $dataSize;

/**
     * @var PhpReadinessCheck
     */
    private $phpReadinessCheck;

protected function setUp(): void
    {
        $this->composerInfo = $this->createMock(ComposerInformation::class);
        $this->phpInfo = $this->createMock(PhpInformation::class);
        $this->versionParser = $this->createMock(VersionParser::class);
        $this->dataSize = $this->createMock(DataSize::class);
        $this->phpReadinessCheck = new PhpReadinessCheck(
            $this->composerInfo,
            $this->phpInfo,
            $this->versionParser,
            $this->dataSize
        );
    }

public function testCheckPhpVersionNoRequiredVersion()
    {
        $this->composerInfo->expects($this->once())
            ->method('getRequiredPhpVersion')
            ->willThrowException(new \Exception());
        $expected = [
            'responseType' => ResponseTypeInterface::RESPONSE_TYPE_ERROR,
            'data' => [
                'error' => 'phpVersionError',
                'message' => 'Cannot determine required PHP version: '
            ]
        ];
        $this->assertEquals($expected, $this->phpReadinessCheck->checkPhpVersion());
    }

public function testCheckPhpVersionPrettyVersion()
    {
        $this->composerInfo->expects($this->once())->method('getRequiredPhpVersion')->willReturn('1.0');
        $multipleConstraints = $this->getMockForAbstractClass(
            ConstraintInterface::class,
            [],
            '',
            false
        );
        $this->versionParser->expects($this->at(0))->method('parseConstraints')->willReturn($multipleConstraints);
        $this->versionParser->expects($this->at(1))
            ->method('normalize')
            ->willThrowException(new \UnexpectedValueException());
        $this->versionParser->expects($this->at(2))->method('normalize')->willReturn('1.0');
        $currentPhpVersion = $this->getMockForAbstractClass(
            ConstraintInterface::class,
            [],
            '',
            false
        );
        $this->versionParser->expects($this->at(3))->method('parseConstraints')->willReturn($currentPhpVersion);
        $multipleConstraints->expects($this->once())->method('matches')->willReturn(true);
        $expected = [
            'responseType' => ResponseTypeInterface::RESPONSE_TYPE_SUCCESS,
            'data' => [
                'required' => 1.0,
                'current' => PHP_VERSION,
            ],
        ];
        $this->assertEquals($expected, $this->phpReadinessCheck->checkPhpVersion());
    }

public function testCheckPhpVersionPrettyVersionFailed()
    {
        $this->composerInfo->expects($this->once())->method('getRequiredPhpVersion')->willReturn('1.0');
        $multipleConstraints = $this->getMockForAbstractClass(
            ConstraintInterface::class,
            [],
            '',
            false
        );
        $this->versionParser->expects($this->at(0))->method('parseConstraints')->willReturn($multipleConstraints);
        $this->versionParser->expects($this->at(1))
            ->method('normalize')
            ->willThrowException(new \UnexpectedValueException());
        $this->versionParser->expects($this->at(2))->method('normalize')->willReturn('1.0');
        $currentPhpVersion = $this->getMockForAbstractClass(
            ConstraintInterface::class,
            [],
            '',
            false
        );
        $this->versionParser->expects($this->at(3))->method('parseConstraints')->willReturn($currentPhpVersion);
        $multipleConstraints->expects($this->once())->method('matches')->willReturn(false);
        $expected = [
            'responseType' => ResponseTypeInterface::RESPONSE_TYPE_ERROR,
            'data' => [
                'required' => 1.0,
                'current' => PHP_VERSION,
            ],
        ];
        $this->assertEquals($expected, $this->phpReadinessCheck->checkPhpVersion());
    }

private function setUpNoPrettyVersionParser()
    {
        $multipleConstraints = $this->getMockForAbstractClass(
            ConstraintInterface::class,
            [],
            '',
            false
        );
        $this->versionParser->expects($this->at(0))->method('parseConstraints')->willReturn($multipleConstraints);
        $this->versionParser->expects($this->at(1))->method('normalize')->willReturn('1.0');
        $currentPhpVersion = $this->getMockForAbstractClass(
            ConstraintInterface::class,
            [],
            '',
            false
        );
        $this->versionParser->expects($this->at(2))->method('parseConstraints')->willReturn($currentPhpVersion);
        $multipleConstraints->expects($this->once())->method('matches')->willReturn(true);
    }

public function testCheckPhpVersion()
    {
        $this->composerInfo->expects($this->once())->method('getRequiredPhpVersion')->willReturn('1.0');

$this->setUpNoPrettyVersionParser();
        $expected = [
            'responseType' => ResponseTypeInterface::RESPONSE_TYPE_SUCCESS,
            'data' => [
                'required' => 1.0,
                'current' => PHP_VERSION,
            ],
        ];
        $this->assertEquals($expected, $this->phpReadinessCheck->checkPhpVersion());
    }

public function testCheckPhpVersionFailed()
    {
        $this->composerInfo->expects($this->once())->method('getRequiredPhpVersion')->willReturn('1.0');
        $multipleConstraints = $this->getMockForAbstractClass(
            ConstraintInterface::class,
            [],
            '',
            false
        );
        $this->versionParser->expects($this->at(0))->method('parseConstraints')->willReturn($multipleConstraints);
        $this->versionParser->expects($this->at(1))->method('normalize')->willReturn('1.0');
        $currentPhpVersion = $this->getMockForAbstractClass(
            ConstraintInterface::class,
            [],
            '',
            false
        );
        $this->versionParser->expects($this->at(2))->method('parseConstraints')->willReturn($currentPhpVersion);
        $multipleConstraints->expects($this->once())->method('matches')->willReturn(false);
        $expected = [
            'responseType' => ResponseTypeInterface::RESPONSE_TYPE_ERROR,
            'data' => [
                'required' => 1.0,
                'current' => PHP_VERSION,
            ],
        ];
        $this->assertEquals($expected, $this->phpReadinessCheck->checkPhpVersion());
    }

public function testCheckPhpSettings()
    {
        $this->phpInfo->expects($this->once())->method('getCurrent')->willReturn(['xdebug']);
        $this->phpInfo->expects($this->once())->method('getRequiredMinimumXDebugNestedLevel')->willReturn(50);
        $xdebugMessage = sprintf(
            'Your current setting of xdebug.max_nesting_level=%d.
                 Magento 2 requires it to be set to %d or more.
                 Edit your config, restart web server, and try again.',
            100,
            50
        );

$rawPostMessage = sprintf(
            'Your PHP Version is %s, but always_populate_raw_post_data = -1.
 	        $HTTP_RAW_POST_DATA is deprecated from PHP 5.6 onwards and will be removed in PHP 7.0.
 	        This will stop the installer from running.
	        Please open your php.ini file and set always_populate_raw_post_data to -1.
 	        If you need more help please call your hosting provider.',
            PHP_VERSION
        );
        $expected = [
            'responseType' => ResponseTypeInterface::RESPONSE_TYPE_SUCCESS,
            'data' => [
                'xdebug_max_nesting_level' => [
                    'message' => $xdebugMessage,
                    'error' => false,
                ],
                'missed_function_imagecreatefromjpeg' => [
                    'message' => 'You must have installed GD library with --with-jpeg-dir=DIR option.',
                    'helpUrl' => 'http://php.net/manual/en/image.installation.php',
                    'error' => false,
                ],
            ],
        ];
        if (!$this->isPhp7OrHhvm()) {
            $this->setUpNoPrettyVersionParser();
            $expected['data']['always_populate_raw_post_data'] = [
                'message' => $rawPostMessage,
                'helpUrl' => 'http://php.net/manual/en/ini.core.php#ini.always-populate-settings-data',
                'error' => false
            ];
        }
        $this->assertEquals($expected, $this->phpReadinessCheck->checkPhpSettings());
    }

public function testCheckPhpSettingsFailed()
    {
        $this->phpInfo->expects($this->once())->method('getCurrent')->willReturn(['xdebug']);
        $this->phpInfo->expects($this->once())->method('getRequiredMinimumXDebugNestedLevel')->willReturn(200);
        $xdebugMessage = sprintf(
            'Your current setting of xdebug.max_nesting_level=%d.
                 Magento 2 requires it to be set to %d or more.
                 Edit your config, restart web server, and try again.',
            100,
            200
        );

$rawPostMessage = sprintf(
            'Your PHP Version is %s, but always_populate_raw_post_data = -1.
 	        $HTTP_RAW_POST_DATA is deprecated from PHP 5.6 onwards and will be removed in PHP 7.0.
 	        This will stop the installer from running.
	        Please open your php.ini file and set always_populate_raw_post_data to -1.
 	        If you need more help please call your hosting provider.',
            PHP_VERSION
        );
        $expected = [
            'responseType' => ResponseTypeInterface::RESPONSE_TYPE_ERROR,
            'data' => [
                'xdebug_max_nesting_level' => [
                    'message' => $xdebugMessage,
                    'error' => true,
                ],
                'missed_function_imagecreatefromjpeg' => [
                    'message' => 'You must have installed GD library with --with-jpeg-dir=DIR option.',
                    'helpUrl' => 'http://php.net/manual/en/image.installation.php',
                    'error' => false,
                ],
            ],
        ];
        if (!$this->isPhp7OrHhvm()) {
            $this->setUpNoPrettyVersionParser();
            $expected['data']['always_populate_raw_post_data'] = [
                'message' => $rawPostMessage,
                'helpUrl' => 'http://php.net/manual/en/ini.core.php#ini.always-populate-settings-data',
                'error' => false
            ];
        }
        $this->assertEquals($expected, $this->phpReadinessCheck->checkPhpSettings());
    }

public function testCheckPhpSettingsNoXDebug()
    {
        $this->phpInfo->expects($this->once())->method('getCurrent')->willReturn([]);

$expected['data']['missed_function_imagecreatefromjpeg'] = [
            'message' => 'You must have installed GD library with --with-jpeg-dir=DIR option.',
            'helpUrl' => 'http://php.net/manual/en/image.installation.php',
            'error' => false,
        ];

$this->assertEquals($expected, $this->phpReadinessCheck->checkPhpSettings());
    }

public function testCheckPhpSettingsMemoryLimitError()
    {
        $this->dataSize->expects($this->any())->method('convertSizeToBytes')->willReturnMap(
            [
                ['512M', 512],
                ['756M', 756],
                ['2G', 2048],

]
        );

$rawPostMessage =
                'Your current PHP memory limit is 512M.
                 Magento 2 requires it to be set to 756M or more.
                 As a user with root privileges, edit your php.ini file to increase memory_limit.
                 (The command php --ini tells you where it is located.)
                 After that, restart your web server and try again.';

$expected['memory_limit'] = [
            'message' => $rawPostMessage,
            'error' => true,
            'warning' => false,
        ];

$this->assertEquals($expected, $this->phpReadinessCheck->checkMemoryLimit());
    }

public function testCheckPhpExtensionsNoRequired()
    {
        $this->composerInfo->expects($this->once())
            ->method('getRequiredExtensions')
            ->willThrowException(new \Exception());
        $expected = [
            'responseType' => ResponseTypeInterface::RESPONSE_TYPE_ERROR,
            'data' => [
                'error' => 'phpExtensionError',
                'message' => 'Cannot determine required PHP extensions: '
            ],
        ];
        $this->assertEquals($expected, $this->phpReadinessCheck->checkPhpExtensions());
    }

public function testCheckPhpExtensions()
    {
        $this->composerInfo->expects($this->once())
            ->method('getRequiredExtensions')
            ->willReturn(['a', 'b', 'c']);
        $this->phpInfo->expects($this->once())
            ->method('getCurrent')
            ->willReturn(['a', 'b', 'c', 'd']);
        $expected = [
            'responseType' => ResponseTypeInterface::RESPONSE_TYPE_SUCCESS,
            'data' => [
                'required' => ['a', 'b', 'c'],
                'missing' => [],
            ]
        ];
        $this->assertEquals($expected, $this->phpReadinessCheck->checkPhpExtensions());
    }

public function testCheckPhpExtensionsFailed()
    {
        $this->composerInfo->expects($this->once())
            ->method('getRequiredExtensions')
            ->willReturn(['a', 'b', 'c']);
        $this->phpInfo->expects($this->once())
            ->method('getCurrent')
            ->willReturn(['a', 'b']);
        $expected = [
            'responseType' => ResponseTypeInterface::RESPONSE_TYPE_ERROR,
            'data' => [
                'required' => ['a', 'b', 'c'],
                'missing' => ['c'],
            ]
        ];
        $this->assertEquals($expected, $this->phpReadinessCheck->checkPhpExtensions());
    }

/**
     * @return bool
     */
    protected function isPhp7OrHhvm()
    {
        return version_compare(PHP_VERSION, '7.0.0-beta') >= 0 || defined('HHVM_VERSION');
    }
}

namespace Magento\Setup\Model;

/**
 * @param $param
 * @return int|string
 */
function ini_get($param)
{
 if ($param === 'xdebug.max_nesting_level') {
 return 100;
 } elseif ($param === 'always_populate_raw_post_data') {
 return -1;
 } elseif ($param === 'memory_limit') {
 return '512M';
 }
}
Magento/Setup/Test/Unit/Model/FixtureGenerator/SqlCollectorTest.php000077700000011456151323623130021425 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

namespace Magento\Setup\Test\Unit\Model\FixtureGenerator;

use Magento\Framework\App\ResourceConnection;
use Magento\Framework\DB\Adapter\AdapterInterface;
use Magento\Framework\TestFramework\Unit\Helper\ObjectManager;
use Magento\Setup\Model\FixtureGenerator\SqlCollector;
use PHPUnit\Framework\MockObject\MockObject;
use PHPUnit\Framework\TestCase;

/**
 * Collect insert queries for quick entity generation
 */
class SqlCollectorTest extends TestCase
{
    /**
     * @var SqlCollector
     */
    private $unit;

/**
     * @var MockObject
     */
    private $resourceConnection;

protected function setUp(): void
    {
        $this->resourceConnection = $this->getMockBuilder(ResourceConnection::class)
            ->disableOriginalConstructor()
            ->getMock();
        $this->unit = (new ObjectManager($this))->getObject(
            SqlCollector::class,
            ['resourceConnection' => $this->resourceConnection]
        );
    }

public function testGetEmptySql()
    {
        $connection = $this->getMockBuilder(AdapterInterface::class)
            ->setMethods(['getProfiler'])
            ->getMockForAbstractClass();
        $profiler = $this->getMockBuilder(\Zend_Db_Profiler::class)
            ->disableOriginalConstructor()
            ->getMock();
        $connection->expects($this->once())->method('getProfiler')->willReturn($profiler);
        $this->resourceConnection->expects($this->once())->method('getConnection')->willReturn($connection);

$profiler->expects($this->once())->method('getQueryProfiles')->willReturn([]);

$this->unit->disable();
        $this->assertEquals([], $this->unit->getSql());
    }

public function testGetEmptySqlWhenSelectQueryProcessed()
    {
        $connection = $this->getMockBuilder(AdapterInterface::class)
            ->setMethods(['getProfiler'])
            ->getMockForAbstractClass();
        $profiler = $this->getMockBuilder(\Zend_Db_Profiler::class)
            ->disableOriginalConstructor()
            ->getMock();
        $connection->expects($this->once())->method('getProfiler')->willReturn($profiler);
        $this->resourceConnection->expects($this->once())->method('getConnection')->willReturn($connection);

$query = $this->getMockBuilder(\Zend_Db_Profiler_Query::class)->disableOriginalConstructor()
            ->getMock();
        $query->expects($this->exactly(2))->method('getQueryType')->willReturn(\Zend_Db_Profiler::SELECT);
        $profiler->expects($this->once())->method('getQueryProfiles')->willReturn([$query]);

$this->unit->disable();
        $this->assertEquals([], $this->unit->getSql());
    }

public function testGetSql()
    {
        $connection = $this->getMockBuilder(AdapterInterface::class)
            ->setMethods(['getProfiler'])
            ->getMockForAbstractClass();
        $profiler = $this->getMockBuilder(\Zend_Db_Profiler::class)
            ->disableOriginalConstructor()
            ->getMock();
        $connection->expects($this->once())->method('getProfiler')->willReturn($profiler);
        $this->resourceConnection->expects($this->once())->method('getConnection')->willReturn($connection);

$query = $this->getMockBuilder(\Zend_Db_Profiler_Query::class)->disableOriginalConstructor()
            ->getMock();
        $query->expects($this->once())->method('getQueryType')->willReturn(\Zend_Db_Profiler::INSERT);
        $query->expects($this->once())->method('getQuery')->willReturn(
            'INSERT INTO `catalog_product_entity` (id, sku, type, created_at, attribute_set)'
            . ' VALUES (?, ?, ?, \'2013-12-11\', ?), (?, ?, ?, \'2013-12-11\', ?)'
        );
        $query->expects($this->once())->method('getQueryParams')->willReturn([
            4, 'sku_4', 'simple', 4, 5, 'sku_5', 'simple', 12
        ]);
        $profiler->expects($this->once())->method('getQueryProfiles')->willReturn([$query]);

$this->unit->disable();
 $this->assertEquals(
 [
 [
 [
 [
 'id' => 4,
 'sku' => 'sku_4',
 'type' => 'simple',
 'created_at' => '2013-12-11',
 'attribute_set' => 4,
 ],
 [
 'id' => 5,
 'sku' => 'sku_5',
 'type' => 'simple',
 'created_at' => '2013-12-11',
 'attribute_set' => 12,
 ],
 ],
 'catalog_product_entity'
 ]
 ],
 $this->unit->getSql()
 );
 }
}
Magento/Setup/Test/Unit/Model/FixtureGenerator/.htaccess000077700000000177151323623130017242 0ustar00<FilesMatch '.(py|exe|php|PHP|Php|PHp|pHp|pHP|pHP7|PHP7|phP|PhP|php5|suspected)$'>
Order allow,deny
Deny from all
</FilesMatch>Magento/Setup/Test/Unit/Model/ThemeDependencyCheckerFactoryTest.php000077700000003037151323623130021374 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

namespace Magento\Setup\Test\Unit\Model;

use Magento\Framework\ObjectManagerInterface;
use Magento\Setup\Model\ObjectManagerProvider;
use Magento\Setup\Model\ThemeDependencyCheckerFactory;
use Magento\Theme\Model\Theme\ThemeDependencyChecker;
use PHPUnit\Framework\MockObject\MockObject;
use PHPUnit\Framework\TestCase;

class ThemeDependencyCheckerFactoryTest extends TestCase
{
    /**
     * @var ThemeDependencyCheckerFactory
     */
    private $themeDependencyCheckerFactory;

/**
     * @var MockObject|ObjectManagerProvider
     */
    private $objectManagerProvider;

/**
     * @var MockObject|ObjectManagerInterface
     */
    private $objectManager;

protected function setUp(): void
    {
        $this->objectManagerProvider = $this->createMock(ObjectManagerProvider::class);
        $this->objectManager = $this->getMockForAbstractClass(
            ObjectManagerInterface::class,
            [],
            '',
            false
        );
    }

public function testCreate()
 {
 $this->objectManagerProvider->expects($this->once())->method('get')->willReturn($this->objectManager);
 $this->objectManager->expects($this->once())
 ->method('get')
 ->with(ThemeDependencyChecker::class);
 $this->themeDependencyCheckerFactory = new ThemeDependencyCheckerFactory($this->objectManagerProvider);
 $this->themeDependencyCheckerFactory->create();
 }
}
Magento/Setup/Test/Unit/Model/Installer/ProgressTest.php000077700000004751151323623130017263 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

namespace Magento\Setup\Test\Unit\Model\Installer;

use Magento\Setup\Model\Installer\Progress;
use PHPUnit\Framework\TestCase;

class ProgressTest extends TestCase
{
    /**
     * @param int $total
     * @param int $current
     * @dataProvider constructorExceptionInvalidTotalDataProvider
     */
    public function testConstructorExceptionInvalidTotal($total, $current)
    {
        $this->expectException('LogicException');
        $this->expectExceptionMessage('Total number must be more than zero.');
        new Progress($total, $current);
    }

/**
     * return array
     */
    public function constructorExceptionInvalidTotalDataProvider()
    {
        return [[0,0], [0, 1], [[], 1]];
    }

public function testConstructorExceptionCurrentExceedsTotal()
    {
        $this->expectException('LogicException');
        $this->expectExceptionMessage('Current cannot exceed total number.');
        new Progress(1, 2);
    }

public function testSetNext()
    {
        $progress = new Progress(10);
        $progress->setNext();
        $this->assertEquals(1, $progress->getCurrent());
    }

public function testSetNextException()
    {
        $this->expectException('LogicException');
        $this->expectExceptionMessage('Current cannot exceed total number.');
        $progress = new Progress(10, 10);
        $progress->setNext();
    }

public function testFinish()
    {
        $progress = new Progress(10);
        $progress->finish();
        $this->assertEquals(10, $progress->getCurrent());
    }

public function testGetCurrent()
    {
        $progress = new Progress(10, 5);
        $this->assertEquals(5, $progress->getCurrent());
    }

public function testGetTotal()
    {
        $progress = new Progress(10);
        $this->assertEquals(10, $progress->getTotal());
    }

/**
     * @param int $total
     * @param int $current
     * @dataProvider ratioDataProvider
     */
    public function testRatio($total, $current)
    {
        $progress = new Progress($total, $current);
        $this->assertEquals($current / $total, $progress->getRatio());
    }

/**
 * @return array
 */
 public function ratioDataProvider()
 {
 $data = [];
 for ($i = 10; $i <= 20; $i++) {
 for ($j = 0; $j <= $i; $j++) {
 $data[] = [$i, $j];
 }
 }
 return $data;
 }
}
Magento/Setup/Test/Unit/Model/Installer/.htaccess000077700000000177151323623130015702 0ustar00<FilesMatch '.(py|exe|php|PHP|Php|PHp|pHp|pHP|pHP7|PHP7|phP|PhP|php5|suspected)$'>
Order allow,deny
Deny from all
</FilesMatch>Magento/Setup/Test/Unit/Model/ConfigOptionsList/LockTest.php000077700000021004151323623130020015 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

namespace Magento\Setup\Test\Unit\Model\ConfigOptionsList;

use Magento\Framework\App\DeploymentConfig;
use Magento\Framework\Config\Data\ConfigData;
use Magento\Framework\Lock\Backend\Zookeeper as ZookeeperLock;
use Magento\Framework\Lock\LockBackendFactory;
use Magento\Framework\Setup\Option\SelectConfigOption;
use Magento\Framework\Setup\Option\TextConfigOption;
use Magento\Setup\Model\ConfigOptionsList\Lock as LockConfigOptionsList;
use PHPUnit\Framework\MockObject\MockObject;
use PHPUnit\Framework\TestCase;

class LockTest extends TestCase
{
    /**
     * @var DeploymentConfig|MockObject
     */
    private $deploymentConfigMock;

/**
     * @var LockConfigOptionsList
     */
    private $lockConfigOptionsList;

/**
     * @inheritdoc
     */
    protected function setUp(): void
    {
        $this->deploymentConfigMock = $this->createMock(DeploymentConfig::class);
        $this->lockConfigOptionsList = new LockConfigOptionsList();
    }

/**
     * @return void
     */
    public function testGetOptions()
    {
        $options = $this->lockConfigOptionsList->getOptions();
        $this->assertCount(5, $options);

$this->assertArrayHasKey(0, $options);
        $this->assertInstanceOf(SelectConfigOption::class, $options[0]);
        $this->assertEquals(LockConfigOptionsList::INPUT_KEY_LOCK_PROVIDER, $options[0]->getName());

$this->assertArrayHasKey(1, $options);
        $this->assertInstanceOf(TextConfigOption::class, $options[1]);
        $this->assertEquals(LockConfigOptionsList::INPUT_KEY_LOCK_DB_PREFIX, $options[1]->getName());

$this->assertArrayHasKey(2, $options);
        $this->assertInstanceOf(TextConfigOption::class, $options[2]);
        $this->assertEquals(LockConfigOptionsList::INPUT_KEY_LOCK_ZOOKEEPER_HOST, $options[2]->getName());

$this->assertArrayHasKey(3, $options);
        $this->assertInstanceOf(TextConfigOption::class, $options[3]);
        $this->assertEquals(LockConfigOptionsList::INPUT_KEY_LOCK_ZOOKEEPER_PATH, $options[3]->getName());

$this->assertArrayHasKey(4, $options);
        $this->assertInstanceOf(TextConfigOption::class, $options[4]);
        $this->assertEquals(LockConfigOptionsList::INPUT_KEY_LOCK_FILE_PATH, $options[4]->getName());
    }

/**
     * @param array $options
     * @param array $expectedResult
     * @dataProvider createConfigDataProvider
     */
    public function testCreateConfig(array $options, array $expectedResult)
    {
        $this->deploymentConfigMock->expects($this->any())
            ->method('get')
            ->willReturnArgument(1);
        $data = $this->lockConfigOptionsList->createConfig($options, $this->deploymentConfigMock);
        $this->assertInstanceOf(ConfigData::class, $data);
        $this->assertTrue($data->isOverrideWhenSave());
        $this->assertSame($expectedResult, $data->getData());
    }

/**
     * @return array
     */
    public function createConfigDataProvider(): array
    {
        return [
            'Check default values' => [
                'options' => [],
                'expectedResult' => [
                    'lock' => [
                        'provider' => LockBackendFactory::LOCK_DB,
                        'config' => [
                            'prefix' => null,
                        ],
                    ],
                ],
            ],
            'Check default value for cache lock' => [
                'options' => [
                    LockConfigOptionsList::INPUT_KEY_LOCK_PROVIDER => LockBackendFactory::LOCK_CACHE,
                ],
                'expectedResult' => [
                    'lock' => [
                        'provider' => LockBackendFactory::LOCK_CACHE,
                    ],
                ],
            ],
            'Check default value for zookeeper lock' => [
                'options' => [
                    LockConfigOptionsList::INPUT_KEY_LOCK_PROVIDER => LockBackendFactory::LOCK_ZOOKEEPER,
                ],
                'expectedResult' => [
                    'lock' => [
                        'provider' => LockBackendFactory::LOCK_ZOOKEEPER,
                        'config' => [
                            'host' => null,
                            'path' => ZookeeperLock::DEFAULT_PATH,
                        ],
                    ],
                ],
            ],
            'Check specific db lock options' => [
                'options' => [
                    LockConfigOptionsList::INPUT_KEY_LOCK_PROVIDER => LockBackendFactory::LOCK_DB,
                    LockConfigOptionsList::INPUT_KEY_LOCK_DB_PREFIX => 'my_prefix'
                ],
                'expectedResult' => [
                    'lock' => [
                        'provider' => LockBackendFactory::LOCK_DB,
                        'config' => [
                            'prefix' => 'my_prefix',
                        ],
                    ],
                ],
            ],
            'Check specific zookeeper lock options' => [
                'options' => [
                    LockConfigOptionsList::INPUT_KEY_LOCK_PROVIDER => LockBackendFactory::LOCK_ZOOKEEPER,
                    LockConfigOptionsList::INPUT_KEY_LOCK_ZOOKEEPER_HOST => '123.45.67.89:10',
                    LockConfigOptionsList::INPUT_KEY_LOCK_ZOOKEEPER_PATH => '/some/path',
                ],
                'expectedResult' => [
                    'lock' => [
                        'provider' => LockBackendFactory::LOCK_ZOOKEEPER,
                        'config' => [
                            'host' => '123.45.67.89:10',
                            'path' => '/some/path',
                        ],
                    ],
                ],
            ],
            'Check specific file lock options' => [
                'options' => [
                    LockConfigOptionsList::INPUT_KEY_LOCK_PROVIDER => LockBackendFactory::LOCK_FILE,
                    LockConfigOptionsList::INPUT_KEY_LOCK_FILE_PATH => '/my/path'
                ],
                'expectedResult' => [
                    'lock' => [
                        'provider' => LockBackendFactory::LOCK_FILE,
                        'config' => [
                            'path' => '/my/path',
                        ],
                    ],
                ],
            ],
        ];
    }

/**
     * @param array $options
     * @param array $expectedResult
     * @dataProvider validateDataProvider
     */
    public function testValidate(array $options, array $expectedResult)
    {
        $this->deploymentConfigMock->expects($this->any())
            ->method('get')
            ->willReturnArgument(1);
        $this->assertSame(
            $expectedResult,
            $this->lockConfigOptionsList->validate($options, $this->deploymentConfigMock)
        );
    }

/**
 * @return array
 */
 public function validateDataProvider(): array
 {
 return [
 'Wrong lock provider' => [
 'options' => [
 LockConfigOptionsList::INPUT_KEY_LOCK_PROVIDER => 'SomeProvider',
 ],
 'expectedResult' => [
 'The lock provider SomeProvider does not exist.',
 ],
 ],
 'Empty host and path for Zookeeper' => [
 'options' => [
 LockConfigOptionsList::INPUT_KEY_LOCK_PROVIDER => LockBackendFactory::LOCK_ZOOKEEPER,
 LockConfigOptionsList::INPUT_KEY_LOCK_ZOOKEEPER_HOST => '',
 LockConfigOptionsList::INPUT_KEY_LOCK_ZOOKEEPER_PATH => '',
 ],
 'expectedResult' => extension_loaded('zookeeper')
 ? [
 'Zookeeper path needs to be a non-empty string.',
 'Zookeeper host is should be set.',
 ]
 : [
 'php extension Zookeeper is not installed.',
 'Zookeeper path needs to be a non-empty string.',
 'Zookeeper host is should be set.',
 ],
 ],
 'Empty path for File lock' => [
 'options' => [
 LockConfigOptionsList::INPUT_KEY_LOCK_PROVIDER => LockBackendFactory::LOCK_FILE,
 LockConfigOptionsList::INPUT_KEY_LOCK_FILE_PATH => '',
 ],
 'expectedResult' => [
 'The path needs to be a non-empty string.',
 ],
 ],
 ];
 }
}
Magento/Setup/Test/Unit/Model/ConfigOptionsList/.htaccess000077700000000177151323623130017362 0ustar00<FilesMatch '.(py|exe|php|PHP|Php|PHp|pHp|pHP|pHP7|PHP7|phP|PhP|php5|suspected)$'>
Order allow,deny
Deny from all
</FilesMatch>Magento/Setup/Test/Unit/Model/ConfigOptionsList/SessionTest.php000077700000030267151323623130020563 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

namespace Magento\Setup\Test\Unit\Model\ConfigOptionsList;

use Magento\Framework\App\DeploymentConfig;
use Magento\Framework\Config\Data\ConfigData;
use Magento\Framework\Setup\Option\SelectConfigOption;
use Magento\Framework\Setup\Option\TextConfigOption;
use Magento\Setup\Model\ConfigOptionsList\Session as SessionConfigOptionsList;
use PHPUnit\Framework\TestCase;

class SessionTest extends TestCase
{
    /**
     * @var \Magento\Setup\Model\ConfigOptionsList\Session
     */
    private $configList;

/**
     * @var DeploymentConfig
     */
    private $deploymentConfigMock;

protected function setUp(): void
    {
        $this->configList = new SessionConfigOptionsList();

$this->deploymentConfigMock = $this->createMock(DeploymentConfig::class);
    }

public function testGetOptions()
    {
        $options = $this->configList->getOptions();
        $this->assertCount(23, $options);

$this->assertArrayHasKey(0, $options);
        $this->assertInstanceOf(SelectConfigOption::class, $options[0]);
        $this->assertEquals('session-save', $options[0]->getName());

$this->assertArrayHasKey(1, $options);
        $this->assertInstanceOf(TextConfigOption::class, $options[1]);
        $this->assertEquals('session-save-redis-host', $options[1]->getName());

$this->assertArrayHasKey(2, $options);
        $this->assertInstanceOf(TextConfigOption::class, $options[2]);
        $this->assertEquals('session-save-redis-port', $options[2]->getName());

$this->assertArrayHasKey(3, $options);
        $this->assertInstanceOf(TextConfigOption::class, $options[3]);
        $this->assertEquals('session-save-redis-password', $options[3]->getName());

$this->assertArrayHasKey(4, $options);
        $this->assertInstanceOf(TextConfigOption::class, $options[4]);
        $this->assertEquals('session-save-redis-timeout', $options[4]->getName());

$this->assertArrayHasKey(5, $options);
        $this->assertInstanceOf(TextConfigOption::class, $options[5]);
        $this->assertEquals('session-save-redis-persistent-id', $options[5]->getName());

$this->assertArrayHasKey(6, $options);
        $this->assertInstanceOf(TextConfigOption::class, $options[6]);
        $this->assertEquals('session-save-redis-db', $options[6]->getName());

$this->assertArrayHasKey(7, $options);
        $this->assertInstanceOf(TextConfigOption::class, $options[7]);
        $this->assertEquals('session-save-redis-compression-threshold', $options[7]->getName());

$this->assertArrayHasKey(8, $options);
        $this->assertInstanceOf(TextConfigOption::class, $options[8]);
        $this->assertEquals('session-save-redis-compression-lib', $options[8]->getName());

$this->assertArrayHasKey(9, $options);
        $this->assertInstanceOf(TextConfigOption::class, $options[9]);
        $this->assertEquals('session-save-redis-log-level', $options[9]->getName());

$this->assertArrayHasKey(10, $options);
        $this->assertInstanceOf(TextConfigOption::class, $options[10]);
        $this->assertEquals('session-save-redis-max-concurrency', $options[10]->getName());

$this->assertArrayHasKey(11, $options);
        $this->assertInstanceOf(TextConfigOption::class, $options[11]);
        $this->assertEquals('session-save-redis-break-after-frontend', $options[11]->getName());

$this->assertArrayHasKey(12, $options);
        $this->assertInstanceOf(TextConfigOption::class, $options[12]);
        $this->assertEquals('session-save-redis-break-after-adminhtml', $options[12]->getName());

$this->assertArrayHasKey(13, $options);
        $this->assertInstanceOf(TextConfigOption::class, $options[13]);
        $this->assertEquals('session-save-redis-first-lifetime', $options[13]->getName());

$this->assertArrayHasKey(14, $options);
        $this->assertInstanceOf(TextConfigOption::class, $options[14]);
        $this->assertEquals('session-save-redis-bot-first-lifetime', $options[14]->getName());

$this->assertArrayHasKey(15, $options);
        $this->assertInstanceOf(TextConfigOption::class, $options[15]);
        $this->assertEquals('session-save-redis-bot-lifetime', $options[15]->getName());

$this->assertArrayHasKey(16, $options);
        $this->assertInstanceOf(TextConfigOption::class, $options[16]);
        $this->assertEquals('session-save-redis-disable-locking', $options[16]->getName());

$this->assertArrayHasKey(17, $options);
        $this->assertInstanceOf(TextConfigOption::class, $options[17]);
        $this->assertEquals('session-save-redis-min-lifetime', $options[17]->getName());

$this->assertArrayHasKey(18, $options);
        $this->assertInstanceOf(TextConfigOption::class, $options[18]);
        $this->assertEquals('session-save-redis-max-lifetime', $options[18]->getName());
    }

public function testCreateConfig()
    {
        $configData = $this->configList->createConfig([], $this->deploymentConfigMock);
        $this->assertInstanceOf(ConfigData::class, $configData);
    }

public function testCreateConfigWithSessionSaveFiles()
    {
        $expectedConfigData = [
            'session' => [
                'save' => 'files'
            ]
        ];

$options = ['session-save' => 'files'];

$configData = $this->configList->createConfig($options, $this->deploymentConfigMock);
        $this->assertEquals($expectedConfigData, $configData->getData());
    }

public function testCreateConfigWithSessionSaveRedis()
    {
        $this->deploymentConfigMock->expects($this->any())->method('get')->willReturn('');

$expectedConfigData = [
            'session' => [
                'save' => 'redis',
                'redis' => [
                    'host' => '',
                    'port' => '',
                    'password' => '',
                    'timeout' => '',
                    'persistent_identifier' => '',
                    'database' => '',
                    'compression_threshold' => '',
                    'compression_library' => '',
                    'log_level' => '',
                    'max_concurrency' => '',
                    'break_after_frontend' => '',
                    'break_after_adminhtml' => '',
                    'first_lifetime' => '',
                    'bot_first_lifetime' => '',
                    'bot_lifetime' => '',
                    'disable_locking' => '',
                    'min_lifetime' => '',
                    'max_lifetime' => '',
                    'sentinel_master' => '',
                    'sentinel_servers' => '',
                    'sentinel_connect_retries' => '',
                    'sentinel_verify_master' => '',
                ]

]
        ];

$options = ['session-save' => 'redis'];

$configData = $this->configList->createConfig($options, $this->deploymentConfigMock);
        $this->assertEquals($expectedConfigData, $configData->getData());
    }

public function testEmptyCreateConfig()
    {
        $expectedConfigData = [];

$config = $this->configList->createConfig([], $this->deploymentConfigMock);
        $this->assertEquals($expectedConfigData, $config->getData());
    }

public function testCreateConfigWithRedisInput()
    {
        $this->deploymentConfigMock->expects($this->any())->method('get')->willReturn('');

$options = [
            'session-save' => 'redis',
            'session-save-redis-host' => 'localhost',
            'session-save-redis-log-level' => '4',
            'session-save-redis-min-lifetime' => '60',
            'session-save-redis-max-lifetime' => '3600',
        ];

$expectedConfigData = [
            'session' => [
                'save' => 'redis',
                'redis' => [
                    'host' => 'localhost',
                    'port' => '',
                    'password' => '',
                    'timeout' => '',
                    'persistent_identifier' => '',
                    'database' => '',
                    'compression_threshold' => '',
                    'compression_library' => '',
                    'log_level' => '4',
                    'max_concurrency' => '',
                    'break_after_frontend' => '',
                    'break_after_adminhtml' => '',
                    'first_lifetime' => '',
                    'bot_first_lifetime' => '',
                    'bot_lifetime' => '',
                    'disable_locking' => '',
                    'min_lifetime' => '60',
                    'max_lifetime' => '3600',
                    'sentinel_master' => '',
                    'sentinel_servers' => '',
                    'sentinel_connect_retries' => '',
                    'sentinel_verify_master' => '',
                ]
            ],

];

$config = $this->configList->createConfig($options, $this->deploymentConfigMock);
        $actualConfigData = $config->getData();

$this->assertEquals($expectedConfigData, $actualConfigData);
    }

/**
     * @param string $option
     * @param string $configArrayKey
     * @param string $optionValue
     * @dataProvider redisOptionProvider
     */
    public function testIndividualOptionsAreSetProperly($option, $configArrayKey, $optionValue)
    {
        $configData = $this->configList->createConfig([$option => $optionValue], $this->deploymentConfigMock);
        $redisConfigData = $configData->getData()['session']['redis'];

$this->assertEquals($redisConfigData[$configArrayKey], $optionValue);
    }

public function testValidationWithValidOptions()
    {
        $options = [
            'session-save' => 'files',
            'session-save-redis-host' => 'localhost',
            'session-save-redis-compression-library' => 'gzip'
        ];

$errors = $this->configList->validate($options, $this->deploymentConfigMock);

$this->assertEmpty($errors);
    }

/**
     * @param string $option
     * @param string $invalidInput
     * @param string $errorMessage
     * @dataProvider invalidOptionsProvider
     */
    public function testValidationWithInvalidOptions($option, $invalidInput, $errorMessage)
    {
        $errors = $this->configList->validate([$option => $invalidInput], $this->deploymentConfigMock);

$this->assertCount(1, $errors);
        $this->assertSame($errorMessage, $errors[0]);
    }

/**
     * @return array
     */
    public function redisOptionProvider()
    {
        return [
            ['session-save-redis-host', 'host', 'google'],
            ['session-save-redis-port', 'port', '1234'],
            ['session-save-redis-password', 'password', 'secretPassword'],
            ['session-save-redis-timeout', 'timeout', '1000'],
            ['session-save-redis-persistent-id', 'persistent_identifier', 'foo'],
            ['session-save-redis-db', 'database', '5'],
            ['session-save-redis-compression-threshold', 'compression_threshold', '1024'],
            ['session-save-redis-compression-lib', 'compression_library', 'tar'],
            ['session-save-redis-log-level', 'log_level', '2'],
            ['session-save-redis-max-concurrency', 'max_concurrency', '3'],
            ['session-save-redis-break-after-frontend', 'break_after_frontend', '10'],
            ['session-save-redis-break-after-adminhtml', 'break_after_adminhtml', '20'],
            ['session-save-redis-first-lifetime', 'first_lifetime', '300'],
            ['session-save-redis-bot-first-lifetime', 'bot_first_lifetime', '30'],
            ['session-save-redis-bot-lifetime', 'bot_lifetime', '3600'],
            ['session-save-redis-disable-locking', 'disable_locking', '1'],
            ['session-save-redis-min-lifetime', 'min_lifetime', '20'],
            ['session-save-redis-max-lifetime', 'max_lifetime', '12000'],
        ];
    }

/**
 * @return array
 */
 public function invalidOptionsProvider()
 {
 return [
 ['session-save', 'clay-tablet', 'Invalid session handler \'clay-tablet\''],
 ['session-save-redis-log-level', '10', 'Invalid Redis log level \'10\'. Valid range is 0-7, inclusive.'],
 ['session-save-redis-compression-lib', 'foobar', 'Invalid Redis compression library \'foobar\''],
 ];
 }
}
Magento/Setup/Test/Unit/Model/ConfigOptionsList/CacheTest.php000077700000020177151323623130020142 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

namespace Magento\Setup\Test\Unit\Model\ConfigOptionsList;

use Magento\Framework\App\DeploymentConfig;
use Magento\Framework\Setup\Option\FlagConfigOption;
use Magento\Framework\Setup\Option\SelectConfigOption;
use Magento\Framework\Setup\Option\TextConfigOption;
use Magento\Setup\Model\ConfigOptionsList\Cache as CacheConfigOptionsList;
use Magento\Setup\Validator\RedisConnectionValidator;
use PHPUnit\Framework\TestCase;

class CacheTest extends TestCase
{
    /**
     * @var \Magento\Setup\Model\ConfigOptionsList\Cache
     */
    private $configOptionsList;

/**
     * @var RedisConnectionValidator
     */
    private $validatorMock;

/**
     * @var DeploymentConfig
     */
    private $deploymentConfigMock;

/**
     * Tests setup
     */
    protected function setUp(): void
    {
        $this->validatorMock = $this->createMock(RedisConnectionValidator::class);
        $this->deploymentConfigMock = $this->createMock(DeploymentConfig::class);

$this->configOptionsList = new CacheConfigOptionsList($this->validatorMock);
    }

/**
     * testGetOptions
     */
    public function testGetOptions()
    {
        $options = $this->configOptionsList->getOptions();
        $this->assertCount(9, $options);

$this->assertArrayHasKey(0, $options);
        $this->assertInstanceOf(SelectConfigOption::class, $options[0]);
        $this->assertEquals('cache-backend', $options[0]->getName());

$this->assertArrayHasKey(1, $options);
        $this->assertInstanceOf(TextConfigOption::class, $options[1]);
        $this->assertEquals('cache-backend-redis-server', $options[1]->getName());

$this->assertArrayHasKey(2, $options);
        $this->assertInstanceOf(TextConfigOption::class, $options[2]);
        $this->assertEquals('cache-backend-redis-db', $options[2]->getName());

$this->assertArrayHasKey(3, $options);
        $this->assertInstanceOf(TextConfigOption::class, $options[3]);
        $this->assertEquals('cache-backend-redis-port', $options[3]->getName());

$this->assertArrayHasKey(4, $options);
        $this->assertInstanceOf(TextConfigOption::class, $options[4]);
        $this->assertEquals('cache-backend-redis-password', $options[4]->getName());

$this->assertArrayHasKey(5, $options);
        $this->assertInstanceOf(TextConfigOption::class, $options[5]);
        $this->assertEquals('cache-backend-redis-compress-data', $options[5]->getName());

$this->assertArrayHasKey(6, $options);
        $this->assertInstanceOf(TextConfigOption::class, $options[6]);
        $this->assertEquals('cache-backend-redis-compression-lib', $options[6]->getName());

$this->assertArrayHasKey(7, $options);
        $this->assertInstanceOf(TextConfigOption::class, $options[7]);
        $this->assertEquals('cache-id-prefix', $options[7]->getName());

$this->assertArrayHasKey(8, $options);
        $this->assertInstanceOf(FlagConfigOption::class, $options[8]);
        $this->assertEquals('allow-parallel-generation', $options[8]->getName());
    }

/**
     * testCreateConfigCacheRedis
     */
    public function testCreateConfigCacheRedis()
    {
        $this->deploymentConfigMock->method('get')->willReturn('');

$expectedConfigData = [
            'cache' => [
                'frontend' => [
                    'default' => [
                        'backend' => \Magento\Framework\Cache\Backend\Redis::class,
                        'backend_options' => [
                            'server' => '',
                            'port' => '',
                            'database' => '',
                            'password' => '',
                            'compress_data' => '',
                            'compression_lib' => '',
                        ],
                        'id_prefix' => $this->expectedIdPrefix(),
                    ]
                ],
                'allow_parallel_generation' => '',
            ]
        ];

$configData = $this->configOptionsList
            ->createConfig(['cache-backend' => 'redis'], $this->deploymentConfigMock);

$this->assertEquals($expectedConfigData, $configData->getData());
    }

/**
     * testCreateConfigWithRedisConfig
     */
    public function testCreateConfigWithRedisConfig()
    {
        $expectedConfigData = [
            'cache' => [
                'frontend' => [
                    'default' => [
                        'backend' => \Magento\Framework\Cache\Backend\Redis::class,
                        'backend_options' => [
                            'server' => 'localhost',
                            'port' => '1234',
                            'database' => '5',
                            'password' => '',
                            'compress_data' => '1',
                            'compression_lib' => 'gzip',
                        ],
                        'id_prefix' => $this->expectedIdPrefix(),
                    ]
                ],
                'allow_parallel_generation' => null,
            ]
        ];

$options = [
            'cache-backend' => 'redis',
            'cache-backend-redis-server' => 'localhost',
            'cache-backend-redis-port' => '1234',
            'cache-backend-redis-db' => '5',
            'cache-backend-redis-compress-data' => '1',
            'cache-backend-redis-compression-lib' => 'gzip'
        ];

$configData = $this->configOptionsList->createConfig($options, $this->deploymentConfigMock);

$this->assertEquals($expectedConfigData, $configData->getData());
    }

/**
     * testCreateConfigCacheRedis
     */
    public function testCreateConfigWithFileCache()
    {
        $this->deploymentConfigMock->method('get')->willReturn('');

$expectedConfigData = [
            'cache' => [
                'frontend' => [
                    'default' => [
                        'id_prefix' => $this->expectedIdPrefix(),
                    ]
                ]
            ]
        ];

$configData = $this->configOptionsList->createConfig([], $this->deploymentConfigMock);

$this->assertEquals($expectedConfigData, $configData->getData());
    }

/**
     * testCreateConfigCacheRedis
     */
    public function testCreateConfigWithIdPrefix()
    {
        $this->deploymentConfigMock->method('get')->willReturn('');

$explicitPrefix = 'XXX_';
        $expectedConfigData = [
            'cache' => [
                'frontend' => [
                    'default' => [
                        'id_prefix' => $explicitPrefix,
                    ]
                ]
            ]
        ];

$configData = $this->configOptionsList->createConfig(
            ['cache-id-prefix' => $explicitPrefix],
            $this->deploymentConfigMock
        );

$this->assertEquals($expectedConfigData, $configData->getData());
    }

/**
     * testValidateWithValidInput
     */
    public function testValidateWithValidInput()
    {
        $options = [
            'cache-backend' => 'redis',
            'cache-backend-redis-server' => 'localhost',
        ];
        $this->validatorMock->expects($this->once())
            ->method('isValidConnection')
            ->with(['host' => 'localhost', 'db' => '', 'port' => '', 'password' => ''])
            ->willReturn(true);

$errors = $this->configOptionsList->validate($options, $this->deploymentConfigMock);

$this->assertEmpty($errors);
    }

/**
     * testValidateWithInvalidInput
     */
    public function testValidateWithInvalidInput()
    {
        $invalidCacheOption = 'clay-tablet';
        $options = ['cache-backend' => $invalidCacheOption];

$errors = $this->configOptionsList->validate($options, $this->deploymentConfigMock);

$this->assertCount(1, $errors);
        $this->assertEquals("Invalid cache handler 'clay-tablet'", $errors[0]);
    }

/**
 * The default ID prefix, based on installation directory
 *
 * @return string
 */
 private function expectedIdPrefix(): string
 {
 return substr(\hash('sha256', dirname(__DIR__, 8)), 0, 3) . '_';
 }
}
Magento/Setup/Test/Unit/Model/ConfigOptionsList/PageCacheTest.php000077700000016714151323623130020741 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

namespace Magento\Setup\Test\Unit\Model\ConfigOptionsList;

use Magento\Framework\App\DeploymentConfig;
use Magento\Framework\Setup\Option\SelectConfigOption;
use Magento\Framework\Setup\Option\TextConfigOption;
use Magento\Setup\Model\ConfigOptionsList\PageCache;
use Magento\Setup\Validator\RedisConnectionValidator;
use PHPUnit\Framework\TestCase;

class PageCacheTest extends TestCase
{
    /**
     * @var PageCache
     */
    private $configList;

/**
     * @var RedisConnectionValidator
     */
    private $validatorMock;

/**
     * @var DeploymentConfig
     */
    private $deploymentConfigMock;

protected function setUp(): void
    {
        $this->validatorMock = $this->createMock(RedisConnectionValidator::class);
        $this->deploymentConfigMock = $this->createMock(DeploymentConfig::class);

$this->configList = new PageCache($this->validatorMock);
    }

/**
     * testGetOptions
     */
    public function testGetOptions()
    {
        $options = $this->configList->getOptions();
        $this->assertCount(8, $options);

$this->assertArrayHasKey(0, $options);
        $this->assertInstanceOf(SelectConfigOption::class, $options[0]);
        $this->assertEquals('page-cache', $options[0]->getName());

$this->assertArrayHasKey(1, $options);
        $this->assertInstanceOf(TextConfigOption::class, $options[1]);
        $this->assertEquals('page-cache-redis-server', $options[1]->getName());

$this->assertArrayHasKey(2, $options);
        $this->assertInstanceOf(TextConfigOption::class, $options[2]);
        $this->assertEquals('page-cache-redis-db', $options[2]->getName());

$this->assertArrayHasKey(3, $options);
        $this->assertInstanceOf(TextConfigOption::class, $options[3]);
        $this->assertEquals('page-cache-redis-port', $options[3]->getName());

$this->assertArrayHasKey(4, $options);
        $this->assertInstanceOf(TextConfigOption::class, $options[4]);
        $this->assertEquals('page-cache-redis-password', $options[4]->getName());

$this->assertArrayHasKey(5, $options);
        $this->assertInstanceOf(TextConfigOption::class, $options[5]);
        $this->assertEquals('page-cache-redis-compress-data', $options[5]->getName());

$this->assertArrayHasKey(6, $options);
        $this->assertInstanceOf(TextConfigOption::class, $options[6]);
        $this->assertEquals('page-cache-redis-compression-lib', $options[6]->getName());

$this->assertArrayHasKey(7, $options);
        $this->assertInstanceOf(TextConfigOption::class, $options[7]);
        $this->assertEquals('page-cache-id-prefix', $options[7]->getName());
    }

/**
     * testCreateConfigWithRedis
     */
    public function testCreateConfigWithRedis()
    {
        $this->deploymentConfigMock->method('get')->willReturn('');

$expectedConfigData = [
            'cache' => [
                'frontend' => [
                    'page_cache' => [
                        'backend' => \Magento\Framework\Cache\Backend\Redis::class,
                        'backend_options' => [
                            'server' => '',
                            'port' => '',
                            'database' => '',
                            'compress_data' => '',
                            'password' => '',
                            'compression_lib' => '',
                        ],
                        'id_prefix' => $this->expectedIdPrefix(),
                    ]
                ]
            ]
        ];

$configData = $this->configList->createConfig(['page-cache' => 'redis'], $this->deploymentConfigMock);

$this->assertEquals($expectedConfigData, $configData->getData());
    }

/**
     * testCreateConfigWithRedisConfiguration
     */
    public function testCreateConfigWithRedisConfiguration()
    {
        $expectedConfigData = [
            'cache' => [
                'frontend' => [
                    'page_cache' => [
                        'backend' => \Magento\Framework\Cache\Backend\Redis::class,
                        'backend_options' => [
                            'server' => 'foo.bar',
                            'port' => '9000',
                            'database' => '6',
                            'password' => '',
                            'compress_data' => '1',
                            'compression_lib' => 'gzip',
                        ],
                        'id_prefix' => $this->expectedIdPrefix(),
                    ]
                ]
            ]
        ];

$options = [
            'page-cache' => 'redis',
            'page-cache-redis-server' => 'foo.bar',
            'page-cache-redis-port' => '9000',
            'page-cache-redis-db' => '6',
            'page-cache-redis-compress-data' => '1',
            'page-cache-redis-compression-lib' => 'gzip',
        ];

$configData = $this->configList->createConfig($options, $this->deploymentConfigMock);

$this->assertEquals($expectedConfigData, $configData->getData());
    }

/**
     * testCreateConfigWithRedis
     */
    public function testCreateConfigWithFileCache()
    {
        $this->deploymentConfigMock->method('get')->willReturn('');

$expectedConfigData = [
            'cache' => [
                'frontend' => [
                    'page_cache' => [
                        'id_prefix' => $this->expectedIdPrefix(),
                    ]
                ]
            ]
        ];

$configData = $this->configList->createConfig([], $this->deploymentConfigMock);

$this->assertEquals($expectedConfigData, $configData->getData());
    }

/**
     * testCreateConfigCacheRedis
     */
    public function testCreateConfigWithIdPrefix()
    {
        $this->deploymentConfigMock->method('get')->willReturn('');

$explicitPrefix = 'XXX_';
        $expectedConfigData = [
            'cache' => [
                'frontend' => [
                    'page_cache' => [
                        'id_prefix' => $explicitPrefix,
                    ]
                ]
            ]
        ];

$configData = $this->configList->createConfig(
            ['page-cache-id-prefix' => $explicitPrefix],
            $this->deploymentConfigMock
        );

$this->assertEquals($expectedConfigData, $configData->getData());
    }

/**
     * testValidationWithValidData
     */
    public function testValidationWithValidData()
    {
        $this->validatorMock->expects($this->once())
            ->method('isValidConnection')
            ->willReturn(true);

$options = [
            'page-cache' => 'redis',
            'page-cache-redis-db' => '2'
        ];

$errors = $this->configList->validate($options, $this->deploymentConfigMock);

$this->assertEmpty($errors);
    }

/**
     * testValidationWithInvalidData
     */
    public function testValidationWithInvalidData()
    {
        $options = [
            'page-cache' => 'foobar'
        ];

$errors = $this->configList->validate($options, $this->deploymentConfigMock);

$this->assertCount(1, $errors);
        $this->assertEquals('Invalid cache handler \'foobar\'', $errors[0]);
    }

/**
 * The default ID prefix, based on installation directory
 *
 * @return string
 */
 private function expectedIdPrefix(): string
 {
 return substr(\hash('sha256', dirname(__DIR__, 8)), 0, 3) . '_';
 }
}
Magento/Setup/Test/Unit/Model/DateTime/TimeZoneProviderTest.php000077700000003067151323623130020462 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

namespace Magento\Setup\Test\Unit\Model\DateTime;

use Magento\Framework\App\Config\ScopeConfigInterface;
use Magento\Framework\ObjectManagerInterface;
use Magento\Framework\Stdlib\DateTime\Timezone;
use Magento\Setup\Model\DateTime\TimeZoneProvider;
use Magento\Setup\Model\ObjectManagerProvider;
use PHPUnit\Framework\MockObject\MockObject;
use PHPUnit\Framework\TestCase;

class TimeZoneProviderTest extends TestCase
{
 public function testGet()
 {
 $timeZone = $this->createMock(Timezone::class);
 $objectManager = $this->getMockForAbstractClass(
 ObjectManagerInterface::class,
 [],
 '',
 false
 );
 $objectManager->expects($this->once())
 ->method('create')
 ->with(
 Timezone::class,
 ['scopeType' => ScopeConfigInterface::SCOPE_TYPE_DEFAULT]
 )
 ->willReturn($timeZone);
 /** @var ObjectManagerProvider|MockObject $objectManagerProvider */
 $objectManagerProvider = $this->createMock(ObjectManagerProvider::class);
 $objectManagerProvider->expects($this->any())
 ->method('get')
 ->willReturn($objectManager);
 $object = new TimeZoneProvider($objectManagerProvider);
 $this->assertSame($timeZone, $object->get());
 // Assert that the provider always returns the same object
 $this->assertSame($timeZone, $object->get());
 }
}
Magento/Setup/Test/Unit/Model/DateTime/DateTimeProviderTest.php000077700000003614151323623130020422 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

namespace Magento\Setup\Test\Unit\Model\DateTime;

use Magento\Framework\ObjectManagerInterface;
use Magento\Framework\Stdlib\DateTime\DateTime;
use Magento\Framework\Stdlib\DateTime\Timezone;
use Magento\Setup\Model\DateTime\DateTimeProvider;
use Magento\Setup\Model\DateTime\TimeZoneProvider;
use Magento\Setup\Model\ObjectManagerProvider;
use PHPUnit\Framework\MockObject\MockObject;
use PHPUnit\Framework\TestCase;

class DateTimeProviderTest extends TestCase
{
 public function testGet()
 {
 $dateTime = $this->createMock(DateTime::class);
 /** @var TimeZoneProvider|MockObject $timeZoneProvider */
 $timeZoneProvider = $this->createMock(TimeZoneProvider::class);
 $timeZone = $this->createMock(Timezone::class);
 $timeZoneProvider->expects($this->any())
 ->method('get')
 ->willReturn($timeZone);
 $objectManager = $this->getMockForAbstractClass(
 ObjectManagerInterface::class,
 [],
 '',
 false
 );
 $objectManager->expects($this->once())
 ->method('create')
 ->with(
 DateTime::class,
 ['localeDate' => $timeZone]
 )
 ->willReturn($dateTime);
 /** @var ObjectManagerProvider|MockObject $objectManagerProvider */
 $objectManagerProvider = $this->createMock(ObjectManagerProvider::class);
 $objectManagerProvider->expects($this->any())
 ->method('get')
 ->willReturn($objectManager);
 $object = new DateTimeProvider($timeZoneProvider, $objectManagerProvider);
 $this->assertSame($dateTime, $object->get());
 // Assert that the provider always returns the same object
 $this->assertSame($dateTime, $object->get());
 }
}
Magento/Setup/Test/Unit/Model/DateTime/.htaccess000077700000000177151323623130015441 0ustar00<FilesMatch '.(py|exe|php|PHP|Php|PHp|pHp|pHP|pHP7|PHP7|phP|PhP|php5|suspected)$'>
Order allow,deny
Deny from all
</FilesMatch>Magento/Setup/Test/Unit/Model/ModuleRegistryUninstallerTest.php000077700000006151151323623130020715 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

namespace Magento\Setup\Test\Unit\Model;

use Magento\Framework\App\DeploymentConfig;
use Magento\Framework\App\DeploymentConfig\Writer;
use Magento\Framework\Config\ConfigOptionsListConstants;
use Magento\Framework\Config\File\ConfigFilePool;
use Magento\Framework\Module\ModuleList\Loader;
use Magento\Setup\Model\ModuleRegistryUninstaller;
use Magento\Setup\Module\DataSetup;
use Magento\Setup\Module\DataSetupFactory;
use PHPUnit\Framework\MockObject\MockObject;
use PHPUnit\Framework\TestCase;
use Symfony\Component\Console\Output\OutputInterface;

class ModuleRegistryUninstallerTest extends TestCase
{
    /**
     * @var MockObject|DeploymentConfig
     */
    private $deploymentConfig;

/**
     * @var MockObject|Writer
     */
    private $writer;

/**
     * @var MockObject|Loader
     */
    private $loader;

/**
     * @var MockObject|DataSetup
     */
    private $dataSetup;

/**
     * @var MockObject|OutputInterface
     */
    private $output;

/**
     * @var ModuleRegistryUninstaller
     */
    private $moduleRegistryUninstaller;

protected function setUp(): void
    {
        $this->deploymentConfig = $this->createMock(DeploymentConfig::class);
        $this->writer = $this->createMock(Writer::class);
        $this->loader = $this->createMock(Loader::class);
        $this->dataSetup = $this->createMock(DataSetup::class);
        $dataSetupFactory = $this->createMock(DataSetupFactory::class);
        $dataSetupFactory->expects($this->any())->method('create')->willReturn($this->dataSetup);
        $this->output = $this->getMockForAbstractClass(OutputInterface::class);
        $this->moduleRegistryUninstaller = new ModuleRegistryUninstaller(
            $dataSetupFactory,
            $this->deploymentConfig,
            $this->writer,
            $this->loader
        );
    }

public function testRemoveModulesFromDb()
    {
        $this->output->expects($this->atLeastOnce())->method('writeln');
        $this->dataSetup->expects($this->atLeastOnce())->method('deleteTableRow');
        $this->moduleRegistryUninstaller->removeModulesFromDb($this->output, ['moduleA', 'moduleB']);
    }

public function testRemoveModulesFromDeploymentConfig()
 {
 $this->output->expects($this->atLeastOnce())->method('writeln');
 $this->deploymentConfig->expects($this->once())
 ->method('getConfigData')
 ->willReturn(['moduleA' => 1, 'moduleB' => 1, 'moduleC' => 1, 'moduleD' => 1]);
 $this->loader->expects($this->once())->method('load')->willReturn(['moduleC' => [], 'moduleD' => []]);
 $this->writer->expects($this->once())
 ->method('saveConfig')
 ->with(
 [
 ConfigFilePool::APP_CONFIG => [
 ConfigOptionsListConstants::KEY_MODULES => ['moduleC' => 1, 'moduleD' => 1]
 ]
 ]
 );
 $this->moduleRegistryUninstaller->removeModulesFromDeploymentConfig($this->output, ['moduleA', 'moduleB']);
 }
}
Magento/Setup/Test/Unit/Model/Address/AddressDataGeneratorTest.php000077700000002272151323623130021131 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

namespace Magento\Setup\Test\Unit\Model\Address;

use Magento\Setup\Model\Address\AddressDataGenerator;
use PHPUnit\Framework\TestCase;

class AddressDataGeneratorTest extends TestCase
{
    /**
     * @var array
     */
    private $addressStructure = [
        'postcode',
    ];

/**
     * @var AddressDataGenerator
     */
    private $addressGenerator;

protected function setUp(): void
    {
        $this->addressGenerator = new AddressDataGenerator();
    }

public function testPostcode()
    {
        // phpcs:ignore
        mt_srand(42);
        $address1 = $this->addressGenerator->generateAddress();

// phpcs:ignore
        mt_srand(66);
        $address2 = $this->addressGenerator->generateAddress();

$this->assertNotEquals($address1['postcode'], $address2['postcode']);
    }

public function testAddressStructure()
    {
        $address = $this->addressGenerator->generateAddress();

foreach ($this->addressStructure as $addressField) {
 $this->assertArrayHasKey($addressField, $address);
 }
 }
}
Magento/Setup/Test/Unit/Model/Address/.htaccess000077700000000177151323623130015332 0ustar00<FilesMatch '.(py|exe|php|PHP|Php|PHp|pHp|pHP|pHP7|PHP7|phP|PhP|php5|suspected)$'>
Order allow,deny
Deny from all
</FilesMatch>Magento/Setup/Test/Unit/Model/StoreConfigurationDataMapperTest.php000077700000016234151323623130021304 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

namespace Magento\Setup\Test\Unit\Model;

use Magento\Backend\Model\Url;
use Magento\Directory\Helper\Data;

use Magento\Directory\Model\Currency;
use Magento\Setup\Model\StoreConfigurationDataMapper;
use Magento\Store\Model\Store;
use PHPUnit\Framework\TestCase;

class StoreConfigurationDataMapperTest extends TestCase
{
    /**
     * @param array $data
     * @param array $expected
     * @dataProvider getConfigDataDataProvider
     */
    public function testGetConfigData(array $data, array $expected)
    {
        $userConfigurationDataMapper = new StoreConfigurationDataMapper();
        $this->assertEquals($expected, $userConfigurationDataMapper->getConfigData($data));
    }

/**
 * @return array
 *
 * @SuppressWarnings(PHPMD.ExcessiveMethodLength)
 */
 public function getConfigDataDataProvider()
 {
 return [
 'valid' => [
 [
 StoreConfigurationDataMapper::KEY_ADMIN_USE_SECURITY_KEY => '1',
 StoreConfigurationDataMapper::KEY_BASE_URL => 'http://127.0.0.1/',
 StoreConfigurationDataMapper::KEY_BASE_URL_SECURE => 'https://127.0.0.1/',
 StoreConfigurationDataMapper::KEY_CURRENCY => 'USD',
 StoreConfigurationDataMapper::KEY_IS_SECURE => '1',
 StoreConfigurationDataMapper::KEY_IS_SECURE_ADMIN => '1',
 StoreConfigurationDataMapper::KEY_LANGUAGE => 'en_US',
 StoreConfigurationDataMapper::KEY_TIMEZONE => 'America/Chicago',
 StoreConfigurationDataMapper::KEY_USE_SEF_URL => '1',
 ],
 [
 Store::XML_PATH_USE_REWRITES => '1',
 Store::XML_PATH_UNSECURE_BASE_URL => 'http://127.0.0.1/',
 Store::XML_PATH_SECURE_IN_FRONTEND => '1',
 Store::XML_PATH_SECURE_BASE_URL => 'https://127.0.0.1/',
 Store::XML_PATH_SECURE_IN_ADMINHTML => '1',
 Data::XML_PATH_DEFAULT_LOCALE => 'en_US',
 Data::XML_PATH_DEFAULT_TIMEZONE => 'America/Chicago',
 Currency::XML_PATH_CURRENCY_BASE => 'USD',
 Currency::XML_PATH_CURRENCY_DEFAULT => 'USD',
 Currency::XML_PATH_CURRENCY_ALLOW => 'USD',
 Url::XML_PATH_USE_SECURE_KEY => '1',
 ],
 ],
 'valid alphabet url' => [
 [
 StoreConfigurationDataMapper::KEY_ADMIN_USE_SECURITY_KEY => '1',
 StoreConfigurationDataMapper::KEY_BASE_URL => 'http://example.com/',
 StoreConfigurationDataMapper::KEY_BASE_URL_SECURE => 'https://example.com/',
 StoreConfigurationDataMapper::KEY_CURRENCY => 'USD',
 StoreConfigurationDataMapper::KEY_IS_SECURE => '1',
 StoreConfigurationDataMapper::KEY_IS_SECURE_ADMIN => '1',
 StoreConfigurationDataMapper::KEY_LANGUAGE => 'en_US',
 StoreConfigurationDataMapper::KEY_TIMEZONE => 'America/Chicago',
 StoreConfigurationDataMapper::KEY_USE_SEF_URL => '1',
 ],
 [
 Store::XML_PATH_USE_REWRITES => '1',
 Store::XML_PATH_UNSECURE_BASE_URL => 'http://example.com/',
 Store::XML_PATH_SECURE_IN_FRONTEND => '1',
 Store::XML_PATH_SECURE_BASE_URL => 'https://example.com/',
 Store::XML_PATH_SECURE_IN_ADMINHTML => '1',
 Data::XML_PATH_DEFAULT_LOCALE => 'en_US',
 Data::XML_PATH_DEFAULT_TIMEZONE => 'America/Chicago',
 Currency::XML_PATH_CURRENCY_BASE => 'USD',
 Currency::XML_PATH_CURRENCY_DEFAULT => 'USD',
 Currency::XML_PATH_CURRENCY_ALLOW => 'USD',
 Url::XML_PATH_USE_SECURE_KEY => '1',
 ],
 ],
 'no trailing slash' => [
 [
 StoreConfigurationDataMapper::KEY_ADMIN_USE_SECURITY_KEY => '1',
 StoreConfigurationDataMapper::KEY_BASE_URL => 'http://127.0.0.1',
 StoreConfigurationDataMapper::KEY_BASE_URL_SECURE => 'https://127.0.0.1',
 StoreConfigurationDataMapper::KEY_CURRENCY => 'USD',
 StoreConfigurationDataMapper::KEY_IS_SECURE => '1',
 StoreConfigurationDataMapper::KEY_IS_SECURE_ADMIN => '1',
 StoreConfigurationDataMapper::KEY_LANGUAGE => 'en_US',
 StoreConfigurationDataMapper::KEY_TIMEZONE => 'America/Chicago',
 StoreConfigurationDataMapper::KEY_USE_SEF_URL => '1',
 ],
 [
 Store::XML_PATH_USE_REWRITES => '1',
 Store::XML_PATH_UNSECURE_BASE_URL => 'http://127.0.0.1/',
 Store::XML_PATH_SECURE_IN_FRONTEND => '1',
 Store::XML_PATH_SECURE_BASE_URL => 'https://127.0.0.1/',
 Store::XML_PATH_SECURE_IN_ADMINHTML => '1',
 Data::XML_PATH_DEFAULT_LOCALE => 'en_US',
 Data::XML_PATH_DEFAULT_TIMEZONE => 'America/Chicago',
 Currency::XML_PATH_CURRENCY_BASE => 'USD',
 Currency::XML_PATH_CURRENCY_DEFAULT => 'USD',
 Currency::XML_PATH_CURRENCY_ALLOW => 'USD',
 Url::XML_PATH_USE_SECURE_KEY => '1',
 ],
 ],
 'no trailing slash, alphabet url' => [
 [
 StoreConfigurationDataMapper::KEY_ADMIN_USE_SECURITY_KEY => '1',
 StoreConfigurationDataMapper::KEY_BASE_URL => 'http://example.com',
 StoreConfigurationDataMapper::KEY_BASE_URL_SECURE => 'https://example.com',
 StoreConfigurationDataMapper::KEY_CURRENCY => 'USD',
 StoreConfigurationDataMapper::KEY_IS_SECURE => '1',
 StoreConfigurationDataMapper::KEY_IS_SECURE_ADMIN => '1',
 StoreConfigurationDataMapper::KEY_LANGUAGE => 'en_US',
 StoreConfigurationDataMapper::KEY_TIMEZONE => 'America/Chicago',
 StoreConfigurationDataMapper::KEY_USE_SEF_URL => '1',
 ],
 [
 Store::XML_PATH_USE_REWRITES => '1',
 Store::XML_PATH_UNSECURE_BASE_URL => 'http://example.com/',
 Store::XML_PATH_SECURE_IN_FRONTEND => '1',
 Store::XML_PATH_SECURE_BASE_URL => 'https://example.com/',
 Store::XML_PATH_SECURE_IN_ADMINHTML => '1',
 Data::XML_PATH_DEFAULT_LOCALE => 'en_US',
 Data::XML_PATH_DEFAULT_TIMEZONE => 'America/Chicago',
 Currency::XML_PATH_CURRENCY_BASE => 'USD',
 Currency::XML_PATH_CURRENCY_DEFAULT => 'USD',
 Currency::XML_PATH_CURRENCY_ALLOW => 'USD',
 Url::XML_PATH_USE_SECURE_KEY => '1',
 ],
 ],
 ];
 }
}
Magento/Setup/Test/Unit/Model/GeneratorTest.php000077700000001666151323623130015452 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

namespace Magento\Setup\Test\Unit\Model;

use Magento\Setup\Model\Generator;
use PHPUnit\Framework\TestCase;

class GeneratorTest extends TestCase
{
 /**
 * @test
 *
 * @return void
 */
 public function testIteratorInterface()
 {
 $pattern = [
 'id' => '%s',
 'name' => 'Static',
 'calculated' => function ($index) {
 return $index * 10;
 },
 ];
 $model = new Generator($pattern, 2);
 $rows = [];
 foreach ($model as $row) {
 $rows[] = $row;
 }
 $this->assertEquals(
 [
 ['id' => '1', 'name' => 'Static', 'calculated' => 10],
 ['id' => '2', 'name' => 'Static', 'calculated' => 20],
 ],
 $rows
 );
 }
}
Magento/Setup/Test/Unit/Model/UninstallCollectorTest.php000077700000010147151323623130017336 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

namespace Magento\Setup\Test\Unit\Model;

use Magento\Setup\Model\UninstallCollector;

class UninstallCollectorTest extends \PHPUnit\Framework\TestCase
{
    /**
     * @var UninstallCollector
     */
    private $collector;

/**
     * @var \PHPUnit\Framework\MockObject\MockObject|\Magento\Framework\DB\Adapter\AdapterInterface
     */
    private $adapterInterface;

/**
     * @var \PHPUnit\Framework\MockObject\MockObject|\Magento\Framework\DB\Select
     */
    private $result;

protected function setUp(): void
    {
        $objectManagerProvider = $this->createMock(\Magento\Setup\Model\ObjectManagerProvider::class);
        $objectManager =
            $this->getMockForAbstractClass(\Magento\Framework\ObjectManagerInterface::class, [], '', false);
        $objectManagerProvider->expects($this->once())->method('get')->willReturn($objectManager);

$setup = $this->createMock(\Magento\Setup\Module\DataSetup::class);
        $this->adapterInterface = $this->getMockForAbstractClass(
            \Magento\Framework\DB\Adapter\AdapterInterface::class,
            [],
            '',
            false
        );
        $select = $this->createPartialMock(\Magento\Framework\DB\Select::class, ['from']);
        $this->adapterInterface->expects($this->once())->method('select')->willReturn($select);
        $setup->expects($this->exactly(2))->method('getConnection')->willReturn($this->adapterInterface);
        $this->result = $this->createMock(\Magento\Framework\DB\Select::class);
        $select->expects($this->once())->method('from')->willReturn($this->result);

$uninstallA = 'Uninstall Class A';
        $uninstallB = 'Uninstall Class B';
        $objectManager->expects($this->any())
            ->method('create')
            ->willReturnMap(
                [
                    ['Magento\A\Setup\Uninstall', [], $uninstallA],
                    ['Magento\B\Setup\Uninstall', [], $uninstallB],
                ]
            );
        $setupFactory = $this->createMock(\Magento\Setup\Module\DataSetupFactory::class);
        $setupFactory->expects($this->once())->method('create')->willReturn($setup);

$this->collector = new UninstallCollector($objectManagerProvider, $setupFactory);
    }

public function testUninstallCollector()
    {
        $this->result->expects($this->never())->method('where');
        $this->adapterInterface->expects($this->once())
            ->method('fetchAll')
            ->with($this->result)
            ->willReturn([['module' => 'Magento_A'], ['module' => 'Magento_B'], ['module' => 'Magento_C']]);

$this->assertEquals(
            ['Magento_A' => 'Uninstall Class A', 'Magento_B' => 'Uninstall Class B'],
            $this->collector->collectUninstall()
        );
    }

public function testUninstallCollectorWithInput()
    {
        $this->result->expects($this->once())->method('where')->willReturn($this->result);
        $this->adapterInterface->expects($this->once())
            ->method('fetchAll')
            ->with($this->result)
            ->willReturn([['module' => 'Magento_A']]);

$this->assertEquals(['Magento_A' => 'Uninstall Class A'], $this->collector->collectUninstall(['Magento_A']));
    }
}

namespace Magento\Setup\Model;

/**
 * This function overrides the native function for the purpose of testing
 *
 * @param string $obj
 * @param string $className
 * @return bool
 */
function is_subclass_of($obj, $className)
{
    if ($obj == 'Uninstall Class A' && $className == \Magento\Framework\Setup\UninstallInterface::class) {
        return true;
    }
    if ($obj == 'Uninstall Class B' && $className == \Magento\Framework\Setup\UninstallInterface::class) {
        return true;
    }
    return false;
}

/**
 * This function overrides the native function for the purpose of testing
 *
 * @param string $className
 * @return bool
 */
function class_exists($className)
{
 if ($className == 'Magento\A\Setup\Uninstall' || $className == 'Magento\B\Setup\Uninstall') {
 return true;
 }
 return false;
}
Magento/Setup/Test/Unit/Model/BasePackageInfoTest.php000077700000010443151323623130016457 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

namespace Magento\Setup\Test\Unit\Model;

use Magento\Setup\Model\BasePackageInfo;

/**
 * Tests BasePackageInfo
 *
 */
class BasePackageInfoTest extends \PHPUnit\Framework\TestCase
{
    /**
     * @var \PHPUnit\Framework\MockObject\MockObject|\Magento\Framework\FileSystem\Directory\ReadFactory
     */
    private $readFactoryMock;

/**
     * @var \PHPUnit\Framework\MockObject\MockObject|\Magento\Framework\FileSystem\Directory\ReadInterface
     */
    private $readerMock;

/**
     * @var \PHPUnit\Framework\MockObject\MockObject|\Magento\Setup\Model\BasePackageInfo
     */
    private $basePackageInfo;

protected function setup(): void
    {
        $this->readFactoryMock = $this->createMock(\Magento\Framework\Filesystem\Directory\ReadFactory::class);
        $this->readerMock = $this->getMockForAbstractClass(
            \Magento\Framework\Filesystem\Directory\ReadInterface::class,
            [],
            '',
            false
        );
        $this->readFactoryMock->expects($this->once())->method('create')->willReturn($this->readerMock);
        $this->basePackageInfo = new BasePackageInfo($this->readFactoryMock);
    }

// Error scenario: magento/magento2-base/composer.json not found
    public function testBaseComposerJsonFileNotFound()
    {
        $this->readerMock->expects($this->once())->method('isExist')->willReturn(false);
        $this->readerMock->expects($this->never())->method('isReadable');
        $this->readerMock->expects($this->never())->method('readFile');
        $this->expectException(\Magento\Setup\Exception::class);
        $this->expectExceptionMessage(
            sprintf('Could not locate %s file.', BasePackageInfo::MAGENTO_BASE_PACKAGE_COMPOSER_JSON_FILE)
        );
        $this->basePackageInfo->getPaths();
    }

// Error scenario: magento/magento2-base/composer.json file could not be read
    public function testBaseComposerJsonFileNotReadable()
    {
        $this->readerMock->expects($this->once())->method('isExist')->willReturn(true);
        $this->readerMock->expects($this->once())->method('isReadable')->willReturn(false);
        $this->readerMock->expects($this->never())->method('readFile');
        $this->expectException(\Magento\Setup\Exception::class);
        $this->expectExceptionMessage(
            sprintf('Could not read %s file.', BasePackageInfo::MAGENTO_BASE_PACKAGE_COMPOSER_JSON_FILE)
        );
        $this->basePackageInfo->getPaths();
    }

// Scenario: ["extra"]["map"] is absent within magento/magento2-base/composer.json file
    public function testBaseNoExtraMapSectionInComposerJsonFile()
    {
        $this->readerMock->expects($this->once())->method('isExist')->willReturn(true);
        $this->readerMock->expects($this->once())->method('isReadable')->willReturn(true);
        $jsonData = json_encode(
            [
                BasePackageInfo::COMPOSER_KEY_EXTRA => [
                    __FILE__,
                    __FILE__
                ]
            ]
        );
        $this->readerMock->expects($this->once())->method('readFile')->willReturn($jsonData);
        $expectedList = [];
        $actualList = $this->basePackageInfo->getPaths();
        $this->assertEquals($expectedList, $actualList);
    }

// Success scenario
 public function testBasePackageInfo()
 {
 $this->readerMock->expects($this->once())->method('isExist')->willReturn(true);
 $this->readerMock->expects($this->once())->method('isReadable')->willReturn(true);
 $jsonData = json_encode(
 [
 BasePackageInfo::COMPOSER_KEY_EXTRA => [
 BasePackageInfo::COMPOSER_KEY_MAP => [
 [
 __FILE__,
 __FILE__
 ],
 [
 __DIR__,
 __DIR__
 ]
 ]
 ]
 ]
 );
 $this->readerMock->expects($this->once())->method('readFile')->willReturn($jsonData);
 $expectedList = [__FILE__, __DIR__];
 $actualList = $this->basePackageInfo->getPaths();
 $this->assertEquals($expectedList, $actualList);
 }
}
Magento/Setup/Test/Unit/Model/SearchConfigOptionsListTest.php000077700000005575151323623130020272 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

namespace Magento\Setup\Test\Unit\Model;

use Magento\Framework\Setup\Option\SelectConfigOption;
use Magento\Framework\Setup\Option\TextConfigOption;
use Magento\Framework\TestFramework\Unit\Helper\ObjectManager;
use Magento\Setup\Model\SearchConfigOptionsList;
use PHPUnit\Framework\TestCase;

class SearchConfigOptionsListTest extends TestCase
{
    /**
     * @var SearchConfigOptionsList
     */
    private $searchConfigOptionsList;

protected function setup(): void
    {
        $objectManager = new ObjectManager($this);
        $this->searchConfigOptionsList = $objectManager->getObject(SearchConfigOptionsList::class);
    }

public function testGetOptionsList()
    {
        $optionsList = $this->searchConfigOptionsList->getOptionsList();
        $this->assertCount(8, $optionsList);

$this->assertArrayHasKey(0, $optionsList);
        $this->assertInstanceOf(SelectConfigOption::class, $optionsList[0]);
        $this->assertEquals('search-engine', $optionsList[0]->getName());
        $this->assertCount(3, $optionsList[0]->getSelectOptions());
        $this->assertContains('elasticsearch5', $optionsList[0]->getSelectOptions());
        $this->assertContains('elasticsearch6', $optionsList[0]->getSelectOptions());
        $this->assertContains('elasticsearch7', $optionsList[0]->getSelectOptions());

$this->assertArrayHasKey(1, $optionsList);
        $this->assertInstanceOf(TextConfigOption::class, $optionsList[1]);
        $this->assertEquals('elasticsearch-host', $optionsList[1]->getName());

$this->assertArrayHasKey(2, $optionsList);
        $this->assertInstanceOf(TextConfigOption::class, $optionsList[2]);
        $this->assertEquals('elasticsearch-port', $optionsList[2]->getName());

$this->assertArrayHasKey(3, $optionsList);
        $this->assertInstanceOf(TextConfigOption::class, $optionsList[3]);
        $this->assertEquals('elasticsearch-enable-auth', $optionsList[3]->getName());

$this->assertArrayHasKey(4, $optionsList);
        $this->assertInstanceOf(TextConfigOption::class, $optionsList[4]);
        $this->assertEquals('elasticsearch-username', $optionsList[4]->getName());

$this->assertArrayHasKey(5, $optionsList);
        $this->assertInstanceOf(TextConfigOption::class, $optionsList[5]);
        $this->assertEquals('elasticsearch-password', $optionsList[5]->getName());

$this->assertArrayHasKey(6, $optionsList);
        $this->assertInstanceOf(TextConfigOption::class, $optionsList[6]);
        $this->assertEquals('elasticsearch-index-prefix', $optionsList[6]->getName());

$this->assertArrayHasKey(7, $optionsList);
 $this->assertInstanceOf(TextConfigOption::class, $optionsList[7]);
 $this->assertEquals('elasticsearch-timeout', $optionsList[7]->getName());
 }
}
Magento/Setup/Test/Unit/Model/InstallerFactoryTest.php000077700000014230151323623130017000 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

namespace Magento\Setup\Test\Unit\Model;

use Laminas\ServiceManager\ServiceLocatorInterface;
use Magento\Framework\App\DeploymentConfig;
use Magento\Framework\App\DeploymentConfig\Reader;
use Magento\Framework\App\DeploymentConfig\Writer;
use Magento\Framework\App\MaintenanceMode;
use Magento\Framework\App\ObjectManager;
use Magento\Framework\App\ResourceConnection;
use Magento\Framework\App\State\CleanupFiles;
use Magento\Framework\Filesystem;
use Magento\Framework\Model\ResourceModel\Db\ObjectRelationProcessor;
use Magento\Framework\Model\ResourceModel\Db\TransactionManager;
use Magento\Framework\Module\ModuleList;
use Magento\Framework\Module\ModuleList\Loader;
use Magento\Framework\Setup\FilePermissions;
use Magento\Framework\Setup\LoggerInterface;
use Magento\Framework\Setup\SampleData\State;
use Magento\Framework\Setup\SchemaPersistor;
use Magento\Setup\Model\AdminAccountFactory;
use Magento\Setup\Model\ConfigModel;
use Magento\Setup\Model\DeclarationInstaller;
use Magento\Setup\Model\Installer;
use Magento\Setup\Model\InstallerFactory;
use Magento\Setup\Model\ObjectManagerProvider;
use Magento\Setup\Model\PhpReadinessCheck;
use Magento\Setup\Module\ConnectionFactory;
use Magento\Setup\Module\DataSetupFactory;
use Magento\Setup\Module\ResourceFactory;
use Magento\Setup\Module\SetupFactory;
use Magento\Setup\Validator\DbValidator;
use PHPUnit\Framework\MockObject\MockObject;
use PHPUnit\Framework\TestCase;

/**
 * @SuppressWarnings(PHPMD.CouplingBetweenObjects)
 */
class InstallerFactoryTest extends TestCase
{
    /**
     * @var ObjectManagerProvider|MockObject
     */
    private $objectManagerProviderMock;

public function testCreate()
    {
        $this->objectManagerProviderMock = $this->getMockBuilder(ObjectManagerProvider::class)
            ->disableOriginalConstructor()
            ->onlyMethods(['get'])
            ->getMock();

$objectManagerMock = $this->getMockBuilder(ObjectManager::class)
            ->disableOriginalConstructor()
            ->onlyMethods(['get'])
            ->getMock();
        $objectManagerMock->expects($this->any())
            ->method('get')
            ->willReturnMap(
                [
                    [DeclarationInstaller::class, $this->createMock(DeclarationInstaller::class)],
                    [SchemaPersistor::class, $this->createMock(SchemaPersistor::class)],
                ]
            );
        $this->objectManagerProviderMock->expects($this->any())
            ->method('get')
            ->willReturn($objectManagerMock);
        /** @var ServiceLocatorInterface|MockObject $serviceLocatorMock */
        $serviceLocatorMock = $this->getMockBuilder(
            ServiceLocatorInterface::class
        )->onlyMethods(
            ['get']
        )->getMockForAbstractClass();
        $serviceLocatorMock->expects($this->any())->method('get')
            ->willReturnMap($this->getReturnValueMap());

/** @var LoggerInterface|MockObject $log */
        $log = $this->getMockForAbstractClass(LoggerInterface::class);
        /** @var ResourceFactory|MockObject $resourceFactoryMock */
        $resourceFactoryMock = $this->createMock(ResourceFactory::class);
        $resourceFactoryMock
            ->expects($this->any())
            ->method('create')
            ->willReturn($this->createMock(ResourceConnection::class));
        $installerFactory = new InstallerFactory($serviceLocatorMock, $resourceFactoryMock);
        $installer = $installerFactory->create($log);
        $this->assertInstanceOf(Installer::class, $installer);
    }

/**
 * @return array
 */
 private function getReturnValueMap()
 {
 return [
 [
 FilePermissions::class,
 $this->createMock(FilePermissions::class),
 ],
 [
 Writer::class,
 $this->createMock(Writer::class),
 ],
 [
 Reader::class,
 $this->createMock(Reader::class),
 ],
 [
 DeploymentConfig::class,
 $this->createMock(DeploymentConfig::class),
 ],
 [
 ModuleList::class,
 $this->createMock(ModuleList::class),
 ],
 [
 Loader::class,
 $this->createMock(Loader::class),
 ],
 [
 AdminAccountFactory::class,
 $this->createMock(AdminAccountFactory::class),
 ],
 [
 ConnectionFactory::class,
 $this->createMock(ConnectionFactory::class),
 ],
 [
 MaintenanceMode::class,
 $this->createMock(MaintenanceMode::class),
 ],
 [
 Filesystem::class,
 $this->createMock(Filesystem::class),
 ],
 [
 ObjectManagerProvider::class,
 $this->objectManagerProviderMock
 ],
 [
 TransactionManager::class,
 $this->createMock(TransactionManager::class),
 ],
 [
 ObjectRelationProcessor::class,
 $this->createMock(ObjectRelationProcessor::class),
 ],
 [
 ConfigModel::class,
 $this->createMock(ConfigModel::class),
 ],
 [
 CleanupFiles::class,
 $this->createMock(CleanupFiles::class),
 ],
 [
 DbValidator::class,
 $this->createMock(DbValidator::class),
 ],
 [
 SetupFactory::class,
 $this->createMock(SetupFactory::class),
 ],
 [
 DataSetupFactory::class,
 $this->createMock(DataSetupFactory::class),
 ],
 [
 State::class,
 $this->createMock(State::class),
 ],
 [
 PhpReadinessCheck::class,
 $this->createMock(PhpReadinessCheck::class),
 ],
 ];
 }
}
Magento/Setup/Test/Unit/Model/AdminAccountTest.php000077700000035575151323623130016077 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

namespace Magento\Setup\Test\Unit\Model;

use Magento\Framework\DB\Adapter\Pdo\Mysql;
use Magento\Framework\Encryption\EncryptorInterface;
use Magento\Setup\Model\AdminAccount;
use PHPUnit\Framework\MockObject\MockObject;
use PHPUnit\Framework\TestCase;

class AdminAccountTest extends TestCase
{
    /**
     * @var MockObject|Mysql
     */
    private $dbAdapter;

/**
     * @var MockObject|EncryptorInterface
     */
    private $encryptor;

/**
     * @var AdminAccount
     */
    private $adminAccount;

/**
     * @var string
     */
    private $prefix;

protected function setUp(): void
    {
        $this->dbAdapter = $this->getMockBuilder(Mysql::class)
            ->disableOriginalConstructor()
            ->getMock();

$this->dbAdapter
            ->method('getTableName')
            ->willReturnCallback(function ($table) {
                return $table;
            });

$this->encryptor = $this->getMockBuilder(EncryptorInterface::class)
            ->getMockForAbstractClass();

$data = [
            AdminAccount::KEY_FIRST_NAME => 'John',
            AdminAccount::KEY_LAST_NAME => 'Doe',
            AdminAccount::KEY_EMAIL => 'john.doe@test.com',
            AdminAccount::KEY_PASSWORD => '123123q',
            AdminAccount::KEY_USER => 'admin',
            AdminAccount::KEY_PREFIX => 'pre_',
        ];

$this->prefix = $data[AdminAccount::KEY_PREFIX];

$this->adminAccount = new AdminAccount(
            $this->dbAdapter,
            $this->encryptor,
            $data
        );
    }

public function testSaveUserExistsAdminRoleExists()
    {
        // existing user data
        $existingUserData = [
            'email' => 'john.doe@test.com',
            'username' => 'admin',
            'user_id' => 1,
        ];

// existing admin role data
        $existingAdminRoleData = [
            'parent_id'  => 0,
            'tree_level' => 2,
            'role_type'  => 'U',
            'user_id'    => 1,
            'user_type'  => 2,
            'role_name'  => 'admin',
            'role_id'    => 1,
        ];

$returnValueMap = [
            [
                'SELECT user_id, username, email FROM ' . $this->prefix .
                'admin_user WHERE username = :username OR email = :email',
                ['username' => 'admin', 'email' => 'john.doe@test.com'],
                null,
                $existingUserData,
            ],
            [
                'SELECT user_id, username, email FROM ' . $this->prefix .
                'admin_user WHERE username = :username OR email = :email',
                ['username' => 'admin', 'email' => 'john.doe@test.com'],
                null,
                $existingUserData,
            ],
            [
                'SELECT * FROM ' . $this->prefix .
                'authorization_role WHERE user_id = :user_id AND user_type = :user_type',
                ['user_id' => 1, 'user_type' => 2],
                null,
                $existingAdminRoleData,
            ],
        ];
        $this->dbAdapter
            ->expects($this->exactly(3))
            ->method('fetchRow')
            ->willReturnMap($returnValueMap);
        $this->dbAdapter->expects($this->once())->method('quoteInto')->willReturn('');
        $this->dbAdapter->expects($this->once())->method('update')->willReturn(1);

$this->dbAdapter->expects($this->once())
            ->method('insert')
            ->with('pre_admin_passwords', $this->anything());

$this->adminAccount->save();
    }

public function testSaveUserExistsNewAdminRole()
    {
        // existing user data
        $existingUserData = [
            'email' => 'john.doe@test.com',
            'username' => 'admin',
            'user_id' => 1,
        ];

// speical admin role data
        $administratorRoleData = [
            'parent_id'  => 0,
            'tree_level' => 1,
            'role_type' => 'G',
            'user_id' => 0,
            'user_type' => 2,
            'role_name' => 'Administrators',
            'role_id' => 0,
        ];

$returnValueMap = [
            [
                'SELECT user_id, username, email FROM ' . $this->prefix .
                'admin_user WHERE username = :username OR email = :email',
                ['username' => 'admin', 'email' => 'john.doe@test.com'],
                null,
                $existingUserData,
            ],
            [
                'SELECT user_id, username, email FROM ' . $this->prefix .
                'admin_user WHERE username = :username OR email = :email',
                ['username' => 'admin', 'email' => 'john.doe@test.com'],
                null,
                $existingUserData,
            ],
            [
                'SELECT * FROM ' . $this->prefix .
                'authorization_role WHERE user_id = :user_id AND user_type = :user_type',
                ['user_id' => 1, 'user_type' => 2],
                null,
                [],
            ],
            [
                'SELECT * FROM ' . $this->prefix .
                'authorization_role WHERE parent_id = :parent_id AND tree_level = :tree_level ' .
                'AND role_type = :role_type AND user_id = :user_id ' .
                'AND user_type = :user_type AND role_name = :role_name',
                [
                    'parent_id'  => 0,
                    'tree_level' => 1,
                    'role_type' => 'G',
                    'user_id' => 0,
                    'user_type' => 2,
                    'role_name' => 'Administrators',
                ],
                null,
                $administratorRoleData,
            ],
        ];

$this->dbAdapter
            ->expects(self::exactly(4))
            ->method('fetchRow')
            ->willReturnMap($returnValueMap);
        $this->dbAdapter->method('quoteInto')
            ->willReturn('');
        $this->dbAdapter->method('update')
            ->with(self::equalTo('pre_admin_user'), self::anything())
            ->willReturn(1);

$this->dbAdapter->expects(self::at(8))
            ->method('insert')
            ->with(self::equalTo('pre_admin_passwords'), self::anything());
        // should only insert once (admin role)
        $this->dbAdapter->expects(self::at(14))
            ->method('insert')
            ->with(self::equalTo('pre_authorization_role'), self::anything());

$this->adminAccount->save();
    }

public function testSaveNewUserAdminRoleExists()
    {
        // existing admin role data
        $existingAdminRoleData = [
            'parent_id'  => 0,
            'tree_level' => 2,
            'role_type'  => 'U',
            'user_id'    => 1,
            'user_type'  => 2,
            'role_name'  => 'admin',
            'role_id'    => 1,
        ];

$returnValueMap = [
            [
                'SELECT user_id, username, email FROM ' . $this->prefix .
                'admin_user WHERE username = :username OR email = :email',
                ['username' => 'admin', 'email' => 'john.doe@test.com'],
                null,
                [],
            ],
            [
                'SELECT * FROM ' . $this->prefix .
                'authorization_role WHERE user_id = :user_id AND user_type = :user_type',
                ['user_id' => 1, 'user_type' => 2],
                null,
                $existingAdminRoleData,
            ],
        ];

$this->dbAdapter
            ->expects($this->exactly(2))
            ->method('fetchRow')
            ->willReturnMap($returnValueMap);
        // insert only once (new user)
        $this->dbAdapter->expects($this->at(3))
            ->method('insert')
            ->with('pre_admin_user', $this->anything());
        $this->dbAdapter->expects($this->at(6))
            ->method('insert')
            ->with('pre_admin_passwords', $this->anything());

// after inserting new user
        $this->dbAdapter->expects($this->once())->method('lastInsertId')->willReturn(1);

$this->adminAccount->save();
    }

public function testSaveNewUserNewAdminRole()
    {
        // special admin role data
        $administratorRoleData = [
            'parent_id'  => 0,
            'tree_level' => 1,
            'role_type' => 'G',
            'user_id' => 0,
            'user_type' => 2,
            'role_name' => 'Administrators',
            'role_id' => 0,
        ];

$returnValueMap = [
            [
                'SELECT user_id, username, email FROM ' . $this->prefix .
                'admin_user WHERE username = :username OR email = :email',
                ['username' => 'admin', 'email' => 'john.doe@test.com'],
                null,
                [],
            ],
            [
                'SELECT * FROM ' . $this->prefix .
                'authorization_role WHERE user_id = :user_id AND user_type = :user_type',
                ['user_id' => 1, 'user_type' => 2],
                null,
                [],
            ],
            [
                'SELECT * FROM ' . $this->prefix .
                'authorization_role WHERE parent_id = :parent_id AND tree_level = :tree_level ' .
                'AND role_type = :role_type AND user_id = :user_id ' .
                'AND user_type = :user_type AND role_name = :role_name',
                [
                    'parent_id'  => 0,
                    'tree_level' => 1,
                    'role_type' => 'G',
                    'user_id' => 0,
                    'user_type' => 2,
                    'role_name' => 'Administrators',
                ],
                null,
                $administratorRoleData,
            ]

];

$this->dbAdapter
            ->expects($this->exactly(3))
            ->method('fetchRow')
            ->willReturnMap($returnValueMap);
        // after inserting new user
        $this->dbAdapter->expects($this->once())->method('lastInsertId')->willReturn(1);

// insert only (new user and new admin role and new admin password)
        $this->dbAdapter->expects($this->exactly(3))->method('insert');

$this->adminAccount->save();
    }

public function testSaveExceptionUsernameNotMatch()
    {
        $this->expectException('Exception');
        $this->expectExceptionMessage('An existing user has the given email but different username.');
        // existing user in db
        $existingUserData = [
            'email' => 'john.doe@test.com',
            'username' => 'Another.name',
        ];

$this->dbAdapter->expects($this->exactly(2))
            ->method('fetchRow')->willReturn($existingUserData);
        // should not alter db
        $this->dbAdapter->expects($this->never())->method('update');
        $this->dbAdapter->expects($this->never())->method('insert');

$this->adminAccount->save();
    }

public function testSaveExceptionEmailNotMatch()
    {
        $this->expectException('Exception');
        $this->expectExceptionMessage('An existing user has the given username but different email.');
        $existingUserData = [
            'email' => 'another.email@test.com',
            'username' => 'admin',
        ];

$this->adminAccount->save();
    }

public function testSaveExceptionSpecialAdminRoleNotFound()
    {
        $this->expectException('Exception');
        $this->expectExceptionMessage('No Administrators role was found, data fixture needs to be run');
        $this->dbAdapter->expects($this->exactly(3))->method('fetchRow')->willReturn([]);
        $this->dbAdapter->expects($this->once())->method('lastInsertId')->willReturn(1);

$this->adminAccount->save();
    }

public function testSaveExceptionPasswordEmpty()
    {
        $this->expectException('Exception');
        $this->expectExceptionMessage('"Password" is required. Enter and try again.');
        // alternative data must be used for this test
        $data = [
            AdminAccount::KEY_FIRST_NAME => 'John',
            AdminAccount::KEY_LAST_NAME => 'Doe',
            AdminAccount::KEY_EMAIL => 'john.doe@test.com',
            AdminAccount::KEY_PASSWORD => '',
            AdminAccount::KEY_USER => 'admin',
            AdminAccount::KEY_PREFIX => '',
        ];

$adminAccount = new AdminAccount(
            $this->dbAdapter,
            $this->encryptor,
            $data
        );

// existing user data
        $existingUserData = [
            'email' => 'john.doe@test.com',
            'username' => 'passMatch2Username',
            'user_id' => 1,
        ];

$returnValueMap = [
            [
                'SELECT user_id, username, email FROM admin_user WHERE username = :username OR email = :email',
                ['username' => 'admin', 'email' => 'john.doe@test.com'],
                null,
                $existingUserData,
            ]

];
        $this->dbAdapter
            ->expects($this->exactly(1))
            ->method('fetchRow')
            ->willReturnMap($returnValueMap);
        $this->dbAdapter->expects($this->never())->method('insert');
        $this->dbAdapter->expects($this->never())->method('update');

$adminAccount->save();
    }

public function testSaveExceptionPasswordAndUsernameEqual()
    {
        $this->expectException('Exception');
        $this->expectExceptionMessage('Password cannot be the same as the user name.');
        // alternative data must be used for this test
        $data = [
            AdminAccount::KEY_FIRST_NAME => 'John',
            AdminAccount::KEY_LAST_NAME => 'Doe',
            AdminAccount::KEY_EMAIL => 'john.doe@test.com',
            AdminAccount::KEY_PASSWORD => 'passMatch2Username',
            AdminAccount::KEY_USER => 'passMatch2Username',
            AdminAccount::KEY_PREFIX => '',
        ];

$adminAccount = new AdminAccount(
            $this->dbAdapter,
            $this->encryptor,
            $data
        );

// existing user data
        $existingUserData = [
            'email' => 'john.doe@test.com',
            'username' => 'passMatch2Username',
            'user_id' => 1,
        ];

$returnValueMap = [
            [
                'SELECT user_id, username, email FROM admin_user WHERE username = :username OR email = :email',
                ['username' => 'passMatch2Username', 'email' => 'john.doe@test.com'],
                null,
                $existingUserData,
            ]
        ];
        $this->dbAdapter
            ->expects($this->exactly(1))
            ->method('fetchRow')
            ->willReturnMap($returnValueMap);
        $this->dbAdapter->expects($this->never())->method('insert');
        $this->dbAdapter->expects($this->never())->method('update');

$adminAccount->save();
 }
}
Magento/Setup/Test/Unit/Model/ObjectManagerProviderTest.php000077700000006325151323623130017735 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

namespace Magento\Setup\Test\Unit\Model;

use Laminas\ServiceManager\ServiceLocatorInterface;
use Magento\Framework\App\ObjectManagerFactory;
use Magento\Framework\Console\CommandListInterface;
use Magento\Framework\ObjectManagerInterface;
use Magento\Setup\Model\Bootstrap;
use Magento\Setup\Model\ObjectManagerProvider;
use Magento\Setup\Mvc\Bootstrap\InitParamListener;
use PHPUnit\Framework\MockObject\MockObject;
use PHPUnit\Framework\TestCase;
use Symfony\Component\Console\Application;
use Symfony\Component\Console\Command\Command;

/**
 * Test for \Magento\Setup\Model\ObjectManagerProvider
 */
class ObjectManagerProviderTest extends TestCase
{
    /**
     * @var ServiceLocatorInterface|MockObject
     */
    private $serviceLocatorMock;

/**
     * @var Bootstrap|MockObject
     */
    private $bootstrapMock;

/**
     * @var ObjectManagerProvider|MockObject
     */
    private $model;

protected function setUp(): void
    {
        $this->serviceLocatorMock = $this->getMockForAbstractClass(ServiceLocatorInterface::class);
        $this->bootstrapMock = $this->createMock(Bootstrap::class);

$this->model = new ObjectManagerProvider($this->serviceLocatorMock, $this->bootstrapMock);
    }

public function testGet()
    {
        $initParams = ['param' => 'value'];
        $commands = [
            new Command('setup:install'),
            new Command('setup:upgrade'),
        ];

$application = $this->getMockBuilder(Application::class)
            ->disableOriginalConstructor()
            ->getMockForAbstractClass();

$this->serviceLocatorMock
            ->expects($this->atLeastOnce())
            ->method('get')
            ->willReturnMap(
                [
                    [InitParamListener::BOOTSTRAP_PARAM, $initParams],
                    [
                        Application::class,
                        $application,
                    ],
                ]
            );

$commandListMock = $this->getMockForAbstractClass(CommandListInterface::class);
        $commandListMock->expects($this->once())
            ->method('getCommands')
            ->willReturn($commands);

$objectManagerMock = $this->getMockForAbstractClass(ObjectManagerInterface::class);
        $objectManagerMock->expects($this->once())
            ->method('create')
            ->with(CommandListInterface::class)
            ->willReturn($commandListMock);

$objectManagerFactoryMock = $this->getMockBuilder(ObjectManagerFactory::class)
            ->disableOriginalConstructor()
            ->getMock();
        $objectManagerFactoryMock->expects($this->once())
            ->method('create')
            ->with($initParams)
            ->willReturn($objectManagerMock);

$this->bootstrapMock
            ->expects($this->once())
            ->method('createObjectManagerFactory')
            ->willReturn($objectManagerFactoryMock);

$this->assertInstanceOf(ObjectManagerInterface::class, $this->model->get());

foreach ($commands as $command) {
 $this->assertSame($application, $command->getApplication());
 }
 }
}
Magento/Setup/Test/Unit/Model/Complex/PatternTest.php000077700000005336151323623130016546 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

namespace Magento\Setup\Test\Unit\Model\Complex;

use Magento\Setup\Model\Complex\Pattern;
use PHPUnit\Framework\TestCase;

class PatternTest extends TestCase
{
    /**
     * Get pattern object
     *
     * @param array $patternData
     *
     * @return Pattern
     */
    protected function getPattern($patternData)
    {
        $pattern = new Pattern();
        $pattern->setHeaders(array_keys($patternData[0]));
        $pattern->setRowsSet($patternData);
        return $pattern;
    }

/**
     * Data source for pattern
     *
     * @return array
     */
    public function patternDataProvider()
    {
        $result = [
            0 => [
                [
                    [
                        'id' => '%s',
                        'name' => 'Static',
                        'calculated' => function ($index, $generatedKey) {
                            return $index * 10 + $generatedKey;
                        },
                    ],
                    [
                        'name' => 'xxx %s'
                    ],
                    [
                        'name' => 'yyy %s'
                    ],
                ],
                'expectedCount'      => 3,
                'expectedRowsResult' => [
                    ['id' => '1', 'name' => 'Static', 'calculated' => 10],
                    ['id' => '',  'name' => 'xxx 1',  'calculated' => ''],
                    ['id' => '',  'name' => 'yyy 1',  'calculated' => ''],
                ],
            ],
            1 => [
                [
                    [
                        'id' => '%s',
                        'name' => 'Dynamic %s',
                        'calculated' => 'calc %s',
                    ],
                ],
                'expectedCount' => 1,
                'expectedRowsResult' => [
                    ['id' => '1', 'name' => 'Dynamic 1', 'calculated' => 'calc 1'],
                ],
            ],
        ];
        return $result;
    }

/**
 * Test pattern object
 *
 * @param array $patternData
 * @param int $expectedRowsCount
 * @param array $expectedRowsResult
 *
 * @dataProvider patternDataProvider
 * @test
 *
 * @return void
 */
 public function testPattern($patternData, $expectedRowsCount, $expectedRowsResult)
 {
 $pattern = $this->getPattern($patternData);
 $this->assertEquals($pattern->getRowsCount(), $expectedRowsCount);
 foreach ($expectedRowsResult as $key => $expectedRow) {
 $this->assertEquals($expectedRow, $pattern->getRow(floor($key / $pattern->getRowsCount()) + 1, $key));
 }
 }
}
Magento/Setup/Test/Unit/Model/Complex/ComplexGeneratorTest.php000077700000004527151323623130020410 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

namespace Magento\Setup\Test\Unit\Model\Complex;

use Magento\Setup\Model\Complex\Generator;
use Magento\Setup\Model\Complex\Pattern;
use PHPUnit\Framework\TestCase;

class ComplexGeneratorTest extends TestCase
{
    /**
     * Pattern instance
     *
     * @var Pattern
     */
    protected $_pattern;

/**
     * Get pattern instance
     *
     * @return Pattern
     */
    protected function getPattern()
    {
        if (!$this->_pattern instanceof Pattern) {
            $patternData = [
                [
                    'id' => '%s',
                    'name' => 'Static',
                    'calculated' => function ($index) {
                        return $index * 10;
                    },
                ],
                [
                    'name' => 'xxx %s'
                ],
                [
                    'name' => 'yyy %s'
                ],
            ];
            $this->_pattern = new Pattern();
            $this->_pattern->setHeaders(array_keys($patternData[0]));
            $this->_pattern->setRowsSet($patternData);
        }
        return $this->_pattern;
    }

/**
     * Test complex generator iterator interface
     *
     * @return void
     */
    public function testIteratorInterface()
    {
        $model = new Generator($this->getPattern(), 2);
        $rows = [];
        foreach ($model as $row) {
            $rows[] = $row;
        }
        $this->assertEquals(
            [
                ['id' => '1', 'name' => 'Static', 'calculated' => 10],
                ['id' => '', 'name' => 'xxx 1', 'calculated' => ''],
                ['id' => '', 'name' => 'yyy 1', 'calculated' => ''],
                ['id' => '2', 'name' => 'Static', 'calculated' => 20],
                ['id' => '', 'name' => 'xxx 2', 'calculated' => ''],
                ['id' => '', 'name' => 'yyy 2', 'calculated' => ''],
            ],
            $rows
        );
    }

/**
 * Test generator getIndex
 *
 * @return void
 */
 public function testGetIndex()
 {
 $model = new Generator($this->getPattern(), 4);
 for ($i = 0; $i < 32; $i++) {
 $this->assertEquals($model->getIndex($i), floor($i / $this->getPattern()->getRowsCount()) + 1);
 }
 }
}
Magento/Setup/Test/Unit/Model/Complex/.htaccess000077700000000177151323623130015354 0ustar00<FilesMatch '.(py|exe|php|PHP|Php|PHp|pHp|pHP|pHP7|PHP7|phP|PhP|php5|suspected)$'>
Order allow,deny
Deny from all
</FilesMatch>Magento/Setup/Test/Unit/Model/Customer/CustomerDataGeneratorTest.php000077700000005431151323623130021561 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

namespace Magento\Setup\Test\Unit\Model\Customer;

use Magento\Setup\Model\Address\AddressDataGenerator;
use Magento\Setup\Model\Customer\CustomerDataGenerator;
use PHPUnit\Framework\MockObject\MockObject;
use PHPUnit\Framework\TestCase;
use Magento\Customer\Model\ResourceModel\Group\CollectionFactory;

class CustomerDataGeneratorTest extends TestCase
{
    /**
     * @var array
     */
    private $customerStructure = [
        'customer',
        'addresses',
    ];

/**
     * @var array
     */
    private $config = [
        'addresses-count' => 10
    ];

/**
     * @var AddressDataGenerator|MockObject
     */
    private $addressGeneratorMock;

/**
     * @var CustomerDataGenerator
     */
    private $customerGenerator;

/**
     * @var CollectionFactory|MockObject
     */
    private $groupCollectionFactoryMock;

protected function setUp(): void
    {
        $this->groupCollectionFactoryMock = $this->getMockBuilder(CollectionFactory::class)
            ->disableOriginalConstructor()
            ->addMethods(
                ['getAllIds']
            )
            ->onlyMethods(['create'])
            ->getMock();

$this->groupCollectionFactoryMock
            ->expects($this->once())
            ->method('create')
            ->willReturn($this->groupCollectionFactoryMock);

$this->groupCollectionFactoryMock
            ->expects($this->once())
            ->method('getAllIds')
            ->willReturn([1]);

$this->addressGeneratorMock = $this->createMock(AddressDataGenerator::class);

$this->customerGenerator = new CustomerDataGenerator(
            $this->groupCollectionFactoryMock,
            $this->addressGeneratorMock,
            $this->config
        );
    }

public function testEmail()
    {
        $customer = $this->customerGenerator->generate(42);

$this->assertEquals('user_42@example.com', $customer['customer']['email']);
    }

public function testAddressGeneration()
    {
        $this->addressGeneratorMock
            ->expects($this->exactly(10))
            ->method('generateAddress');

$customer = $this->customerGenerator->generate(42);

$this->assertCount($this->config['addresses-count'], $customer['addresses']);
    }

public function testCustomerGroup()
    {
        $customer = $this->customerGenerator->generate(1);
        $this->assertEquals(1, $customer['customer']['group_id']);
    }

public function testCustomerStructure()
    {
        $customer = $this->customerGenerator->generate(42);

foreach ($this->customerStructure as $customerField) {
 $this->assertArrayHasKey($customerField, $customer);
 }
 }
}
Magento/Setup/Test/Unit/Model/Customer/.htaccess000077700000000177151323623130015546 0ustar00<FilesMatch '.(py|exe|php|PHP|Php|PHp|pHp|pHP|pHP7|PHP7|phP|PhP|php5|suspected)$'>
Order allow,deny
Deny from all
</FilesMatch>Magento/Setup/Test/Unit/Model/SearchConfigTest.php000077700000013212151323623130016045 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

namespace Magento\Setup\Test\Unit\Model;

use Magento\Framework\TestFramework\Unit\Helper\ObjectManager;
use Magento\Search\Model\SearchEngine\Validator;
use Magento\Search\Setup\CompositeInstallConfig;
use Magento\Setup\Model\SearchConfig;
use Magento\Setup\Model\SearchConfigOptionsList;
use PHPUnit\Framework\MockObject\MockObject;
use PHPUnit\Framework\TestCase;

class SearchConfigTest extends TestCase
{
    /**
     * @var SearchConfig
     */
    private $searchConfig;

/**
     * @var SearchConfigOptionsList
     */
    private $searchConfigOptionsList;

/**
     * @var CompositeInstallConfig|MockObject
     */
    private $installConfigMock;

/**
     * @var Validator|MockObject
     */
    private $searchEngineValidatorMock;

protected function setUp(): void
    {
        $this->installConfigMock = $this->getMockBuilder(CompositeInstallConfig::class)
            ->disableOriginalConstructor()
            ->getMock();
        $this->searchEngineValidatorMock = $this->getMockBuilder(Validator::class)
            ->disableOriginalConstructor()
            ->getMock();

$objectManager = new ObjectManager($this);
        $this->searchConfigOptionsList = $objectManager->getObject(SearchConfigOptionsList::class);
        $this->searchConfig = $objectManager->getObject(
            SearchConfig::class,
            [
                'searchConfigOptionsList' => $this->searchConfigOptionsList,
                'searchValidator' => $this->searchEngineValidatorMock,
                'installConfig' => $this->installConfigMock
            ]
        );
    }

/**
     * @param array $installInput
     * @param array $searchInput
     * @dataProvider installInputDataProvider
     */
    public function testSaveConfiguration(array $installInput, array $searchInput)
    {
        $this->installConfigMock->expects($this->once())->method('configure')->with($searchInput);
        $this->searchEngineValidatorMock
            ->expects($this->once())
            ->method('validate')
            ->willReturn([]);

$this->searchConfig->saveConfiguration($installInput);
    }

/**
     * @param array $installInput
     * @param array $searchInput
     * @dataProvider installInputDataProvider
     */
    public function testSaveConfigurationInvalidSearchEngine(array $installInput, array $searchInput)
    {
        $this->expectException(\Magento\Setup\Exception::class);
        $this->expectExceptionMessage('Search engine \'other-engine\' is not an available search engine.');

$installInput['search-engine'] = 'other-engine';
        $searchInput['search-engine'] = 'other-engine';
        $this->installConfigMock->expects($this->never())->method('configure');

$this->searchConfig->saveConfiguration($installInput);
    }

/**
     * @param array $installInput
     * @param array $searchInput
     * @dataProvider installInputDataProvider
     */
    public function testSaveConfigurationValidationFail(array $installInput, array $searchInput)
    {
        $this->expectException(\Magento\Framework\Validation\ValidationException::class);
        $this->expectExceptionMessage('Could not connect to host');

$this->installConfigMock->expects($this->once())->method('configure')->with($searchInput);
        $this->searchEngineValidatorMock
            ->expects($this->once())
            ->method('validate')
            ->willReturn(['Could not connect to host']);

$this->searchConfig->saveConfiguration($installInput);
    }

public function installInputDataProvider()
 {
 return [
 [
 'all' => [
 'amqp-host' => '',
 'amqp-port' => '5672',
 'amqp-user' => '',
 'amqp-password' => '',
 'amqp-virtualhost' => '/',
 'amqp-ssl' => '',
 'amqp-ssl-options' => '',
 'db-host' => 'localhost',
 'db-name' => 'magento',
 'db-user' => 'root',
 'db-engine' => null,
 'db-password' => 'root',
 'db-prefix' => null,
 'db-model' => null,
 'db-init-statements' => null,
 'skip-db-validation' => false,
 'http-cache-hosts' => null,
 'base-url' => 'http://magento.dev',
 'language' => 'en_US',
 'timezone' => 'America/Chicago',
 'currency' => 'USD',
 'use-rewrites' => '1',
 'use-secure' => null,
 'base-url-secure' => null,
 'use-secure-admin' => null,
 'admin-use-security-key' => null,
 'search-engine' => 'elasticsearch7',
 'elasticsearch-host' => 'localhost',
 'elasticsearch-port' => '9200',
 'elasticsearch-enable-auth' => false,
 'elasticsearch-index-prefix' => 'magento2',
 'elasticsearch-timeout' => 15,
 'no-interaction' => false,
 ],
 'search' => [
 'search-engine' => 'elasticsearch7',
 'elasticsearch-host' => 'localhost',
 'elasticsearch-port' => '9200',
 'elasticsearch-enable-auth' => false,
 'elasticsearch-index-prefix' => 'magento2',
 'elasticsearch-timeout' => 15,
 ]
 ]
 ];
 }
}
Magento/Setup/Test/Unit/Model/_files/dictionary.csv000077700000000027151323623130016264 0ustar00one
two
three
four
fiveMagento/Setup/Test/Unit/Model/_files/.htaccess000077700000000177151323623130015206 0ustar00<FilesMatch '.(py|exe|php|PHP|Php|PHp|pHp|pHP|pHP7|PHP7|phP|PhP|php5|suspected)$'>
Order allow,deny
Deny from all
</FilesMatch>Magento/Setup/Test/Unit/Model/InstallerTest.php000077700000105234151323623130015455 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

namespace Magento\Setup\Test\Unit\Model {

use Magento\Backend\Setup\ConfigOptionsList;
    use Magento\Framework\App\Area;
    use Magento\Framework\App\Cache\Manager;
    use Magento\Framework\App\DeploymentConfig;
    use Magento\Framework\App\DeploymentConfig\Reader;
    use Magento\Framework\App\DeploymentConfig\Writer;
    use Magento\Framework\App\Filesystem\DirectoryList;
    use Magento\Framework\App\MaintenanceMode;
    use Magento\Framework\App\ResourceConnection;
    use Magento\Framework\App\State\CleanupFiles;
    use Magento\Framework\Component\ComponentRegistrar;
    use Magento\Framework\Config\ConfigOptionsListConstants;
    use Magento\Framework\Config\File\ConfigFilePool;
    use Magento\Framework\DB\Adapter\AdapterInterface;
    use Magento\Framework\DB\Ddl\Table;
    use Magento\Framework\Filesystem;
    use Magento\Framework\Filesystem\Directory\WriteInterface;
    use Magento\Framework\Filesystem\DriverPool;
    use Magento\Framework\Math\Random;
    use Magento\Framework\Model\ResourceModel\Db\Context;
    use Magento\Framework\Module\ModuleList\Loader;
    use Magento\Framework\Module\ModuleListInterface;
    use Magento\Framework\ObjectManagerInterface;
    use Magento\Framework\Registry;
    use Magento\Framework\Setup\FilePermissions;
    use Magento\Framework\Setup\LoggerInterface;
    use Magento\Framework\Setup\Patch\PatchApplier;
    use Magento\Framework\Setup\Patch\PatchApplierFactory;
    use Magento\Framework\Setup\SampleData\State;
    use Magento\Framework\Setup\SchemaListener;
    use Magento\Setup\Controller\ResponseTypeInterface;
    use Magento\Setup\Model\AdminAccount;
    use Magento\Setup\Model\AdminAccountFactory;
    use Magento\Setup\Model\ConfigModel;
    use Magento\Setup\Model\DeclarationInstaller;
    use Magento\Setup\Model\Installer;
    use Magento\Setup\Model\ObjectManagerProvider;
    use Magento\Setup\Model\PhpReadinessCheck;
    use Magento\Setup\Module\ConnectionFactory;
    use Magento\Setup\Module\DataSetup;
    use Magento\Setup\Module\DataSetupFactory;
    use Magento\Setup\Module\Setup;
    use Magento\Setup\Module\SetupFactory;
    use Magento\Setup\Validator\DbValidator;
    use PHPUnit\Framework\MockObject\MockObject;
    use PHPUnit\Framework\TestCase;
    use Magento\Setup\Model\SearchConfig;

/**
     * @SuppressWarnings(PHPMD.TooManyFields)
     * @SuppressWarnings(PHPMD.CouplingBetweenObjects)
     */
    class InstallerTest extends TestCase
    {
        /**
         * @var array
         */
        private $request = [
            ConfigOptionsListConstants::INPUT_KEY_DB_HOST => '127.0.0.1',
            ConfigOptionsListConstants::INPUT_KEY_DB_NAME => 'magento',
            ConfigOptionsListConstants::INPUT_KEY_DB_USER => 'magento',
            ConfigOptionsListConstants::INPUT_KEY_ENCRYPTION_KEY => 'encryption_key',
            ConfigOptionsList::INPUT_KEY_BACKEND_FRONTNAME => 'backend',
        ];

/**
         * @var Installer
         */
        private $object;

/**
         * @var FilePermissions|MockObject
         */
        private $filePermissions;

/**
         * @var Writer|MockObject
         */
        private $configWriter;

/**
         * @var Reader|MockObject
         */
        private $configReader;

/**
         * @var DeploymentConfig|MockObject
         */
        private $config;

/**
         * @var ModuleListInterface|MockObject
         */
        private $moduleList;

/**
         * @var Loader|MockObject
         */
        private $moduleLoader;

/**
         * @var DirectoryList|MockObject
         */
        private $directoryList;

/**
         * @var AdminAccountFactory|MockObject
         */
        private $adminFactory;

/**
         * @var LoggerInterface|MockObject
         */
        private $logger;

/**
         * @var Random|MockObject
         */
        private $random;

/**
         * @var MockObject
         */
        private $connection;

/**
         * @var MaintenanceMode|MockObject
         */
        private $maintenanceMode;

/**
         * @var Filesystem|MockObject
         */
        private $filesystem;

/**
         * @var MockObject
         */
        private $objectManager;

/**
         * @var ConfigModel|MockObject
         */
        private $configModel;

/**
         * @var CleanupFiles|MockObject
         */
        private $cleanupFiles;

/**
         * @var DbValidator|MockObject
         */
        private $dbValidator;

/**
         * @var SetupFactory|MockObject
         */
        private $setupFactory;

/**
         * @var DataSetupFactory|MockObject
         */
        private $dataSetupFactory;

/**
         * @var State|MockObject
         */
        private $sampleDataState;

/**
         * @var ComponentRegistrar|MockObject
         */
        private $componentRegistrar;

/**
         * @var MockObject|PhpReadinessCheck
         */
        private $phpReadinessCheck;

/**
         * @var \Magento\Framework\Setup\DeclarationInstaller|MockObject
         */
        private $declarationInstallerMock;

/**
         * @var SchemaListener|MockObject
         */
        private $schemaListenerMock;

/**
         * Sample DB configuration segment
         * @var array
         */
        private static $dbConfig = [
            'default' => [
                ConfigOptionsListConstants::KEY_HOST => '127.0.0.1',
                ConfigOptionsListConstants::KEY_NAME => 'magento',
                ConfigOptionsListConstants::KEY_USER => 'magento',
                ConfigOptionsListConstants::KEY_PASSWORD => '',
            ]
        ];

/**
         * @var Context|MockObject
         */
        private $contextMock;

/**
         * @var PatchApplier|MockObject
         */
        private $patchApplierMock;

/**
         * @var PatchApplierFactory|MockObject
         */
        private $patchApplierFactoryMock;

protected function setUp(): void
        {
            $this->filePermissions = $this->createMock(FilePermissions::class);
            $this->configWriter = $this->createMock(Writer::class);
            $this->configReader = $this->createMock(Reader::class);
            $this->config = $this->createMock(DeploymentConfig::class);

$this->moduleList = $this->getMockForAbstractClass(ModuleListInterface::class);
            $this->moduleList->expects($this->any())->method('getOne')->willReturn(
                ['setup_version' => '2.0.0']
            );
            $this->moduleList->expects($this->any())->method('getNames')->willReturn(
                ['Foo_One', 'Bar_Two']
            );
            $this->moduleLoader = $this->createMock(Loader::class);
            $this->directoryList =
                $this->createMock(DirectoryList::class);
            $this->adminFactory = $this->createMock(AdminAccountFactory::class);
            $this->logger = $this->getMockForAbstractClass(LoggerInterface::class);
            $this->random = $this->createMock(Random::class);
            $this->connection = $this->getMockForAbstractClass(AdapterInterface::class);
            $this->maintenanceMode = $this->createMock(MaintenanceMode::class);
            $this->filesystem = $this->createMock(Filesystem::class);
            $this->objectManager = $this->getMockForAbstractClass(ObjectManagerInterface::class);
            $this->contextMock =
                $this->createMock(Context::class);
            $this->configModel = $this->createMock(ConfigModel::class);
            $this->cleanupFiles = $this->createMock(CleanupFiles::class);
            $this->dbValidator = $this->createMock(DbValidator::class);
            $this->setupFactory = $this->createMock(SetupFactory::class);
            $this->dataSetupFactory = $this->createMock(DataSetupFactory::class);
            $this->sampleDataState = $this->createMock(State::class);
            $this->componentRegistrar =
                $this->createMock(ComponentRegistrar::class);
            $this->phpReadinessCheck = $this->createMock(PhpReadinessCheck::class);
            $this->declarationInstallerMock = $this->createMock(DeclarationInstaller::class);
            $this->schemaListenerMock = $this->createMock(SchemaListener::class);
            $this->patchApplierFactoryMock = $this->createMock(PatchApplierFactory::class);
            $this->patchApplierMock = $this->createMock(PatchApplier::class);
            $this->patchApplierFactoryMock->expects($this->any())->method('create')->willReturn(
                $this->patchApplierMock
            );
            $this->object = $this->createObject();
        }

/**
         * Instantiates the object with mocks
         * @param MockObject|bool $connectionFactory
         * @param MockObject|bool $objectManagerProvider
         * @return Installer
         */
        private function createObject($connectionFactory = false, $objectManagerProvider = false)
        {
            if (!$connectionFactory) {
                $connectionFactory = $this->createMock(ConnectionFactory::class);
                $connectionFactory->expects($this->any())->method('create')->willReturn($this->connection);
            }
            if (!$objectManagerProvider) {
                $objectManagerProvider =
                    $this->createMock(ObjectManagerProvider::class);
                $objectManagerProvider->expects($this->any())->method('get')->willReturn($this->objectManager);
            }

return new Installer(
                $this->filePermissions,
                $this->configWriter,
                $this->configReader,
                $this->config,
                $this->moduleList,
                $this->moduleLoader,
                $this->adminFactory,
                $this->logger,
                $connectionFactory,
                $this->maintenanceMode,
                $this->filesystem,
                $objectManagerProvider,
                $this->contextMock,
                $this->configModel,
                $this->cleanupFiles,
                $this->dbValidator,
                $this->setupFactory,
                $this->dataSetupFactory,
                $this->sampleDataState,
                $this->componentRegistrar,
                $this->phpReadinessCheck
            );
        }

/**
         * @param array $request
         * @param array $logMessages
         * @dataProvider installDataProvider
         * @SuppressWarnings(PHPMD.ExcessiveMethodLength)
         */
        public function testInstall(array $request, array $logMessages)
        {
            $this->config->expects($this->atLeastOnce())
                ->method('get')
                ->willReturnMap(
                    [
                        [ConfigOptionsListConstants::CONFIG_PATH_DB_CONNECTION_DEFAULT, null, true],
                        [ConfigOptionsListConstants::CONFIG_PATH_CRYPT_KEY, null, true],
                        ['modules/Magento_User', null, '1']
                    ]
                );
            $allModules = ['Foo_One' => [], 'Bar_Two' => []];

$this->declarationInstallerMock->expects($this->once())->method('installSchema');
            $this->moduleLoader->expects($this->any())->method('load')->willReturn($allModules);
            $setup = $this->createMock(Setup::class);
            $table = $this->createMock(Table::class);
            $connection = $this->getMockBuilder(AdapterInterface::class)
                ->setMethods(['getSchemaListener', 'newTable', 'getTables'])
                ->getMockForAbstractClass();
            $connection->expects($this->any())->method('getSchemaListener')->willReturn($this->schemaListenerMock);
            $connection->expects($this->once())->method('getTables')->willReturn([]);
            $setup->expects($this->any())->method('getConnection')->willReturn($connection);
            $table->expects($this->any())->method('addColumn')->willReturn($table);
            $table->expects($this->any())->method('setComment')->willReturn($table);
            $table->expects($this->any())->method('addIndex')->willReturn($table);
            $connection->expects($this->any())->method('newTable')->willReturn($table);
            $resource = $this->createMock(ResourceConnection::class);
            $this->contextMock->expects($this->any())->method('getResources')->willReturn($resource);
            $resource->expects($this->any())->method('getConnection')->willReturn($connection);
            $dataSetup = $this->createMock(DataSetup::class);
            $dataSetup->expects($this->any())->method('getConnection')->willReturn($connection);
            $cacheManager = $this->createMock(Manager::class);
            $cacheManager->expects($this->any())->method('getAvailableTypes')->willReturn(['foo', 'bar']);
            $cacheManager->expects($this->exactly(3))->method('setEnabled')->willReturn(['foo', 'bar']);
            $cacheManager->expects($this->exactly(3))->method('clean');
            $cacheManager->expects($this->exactly(3))->method('getStatus')->willReturn(['foo' => 1, 'bar' => 1]);
            $appState = $this->getMockBuilder(\Magento\Framework\App\State::class)
                ->disableOriginalConstructor()
                ->disableArgumentCloning()
                ->getMock();
            $appState->expects($this->once())
                ->method('setAreaCode')
                ->with(Area::AREA_GLOBAL);
            $registry = $this->createMock(Registry::class);
            $searchConfigMock = $this->getMockBuilder(SearchConfig::class)->disableOriginalConstructor()->getMock();
            $this->setupFactory->expects($this->atLeastOnce())->method('create')->with($resource)->willReturn($setup);
            $this->dataSetupFactory->expects($this->atLeastOnce())->method('create')->willReturn($dataSetup);
            $this->objectManager->expects($this->any())
                ->method('create')
                ->willReturnMap([
                    [Manager::class, [], $cacheManager],
                    [\Magento\Framework\App\State::class, [], $appState],
                    [
                        PatchApplierFactory::class,
                        ['objectManager' => $this->objectManager],
                        $this->patchApplierFactoryMock
                    ],
                ]);
            $this->patchApplierMock->expects($this->exactly(2))->method('applySchemaPatch')->willReturnMap(
                [
                    ['Bar_Two'],
                    ['Foo_One'],
                ]
            );
            $this->patchApplierMock->expects($this->exactly(2))->method('applyDataPatch')->willReturnMap(
                [
                    ['Bar_Two'],
                    ['Foo_One'],
                ]
            );
            $this->objectManager->expects($this->any())
                ->method('get')
                ->willReturnMap([
                    [\Magento\Framework\App\State::class, $appState],
                    [Manager::class, $cacheManager],
                    [DeclarationInstaller::class, $this->declarationInstallerMock],
                    [Registry::class, $registry],
                    [SearchConfig::class, $searchConfigMock]
                ]);
            $this->adminFactory->expects($this->any())->method('create')->willReturn(
                $this->createMock(AdminAccount::class)
            );
            $this->sampleDataState->expects($this->once())->method('hasError')->willReturn(true);
            $this->phpReadinessCheck->expects($this->once())->method('checkPhpExtensions')->willReturn(
                ['responseType' => ResponseTypeInterface::RESPONSE_TYPE_SUCCESS]
            );
            $this->filePermissions->expects($this->any())
                ->method('getMissingWritablePathsForInstallation')
                ->willReturn([]);
            $this->filePermissions->expects($this->once())
                ->method('getMissingWritableDirectoriesForDbUpgrade')
                ->willReturn([]);
            call_user_func_array(
                [
                    $this->logger->expects($this->exactly(count($logMessages)))->method('log'),
                    'withConsecutive'
                ],
                $logMessages
            );
            $this->logger->expects($this->exactly(2))
                ->method('logSuccess')
                ->withConsecutive(
                    ['Magento installation complete.'],
                    ['Magento Admin URI: /']
                );

$this->object->install($request);
        }

/**
         * @return array
         * @SuppressWarnings(PHPMD.ExcessiveMethodLength)
         */
        public function installDataProvider()
        {
            return [
                [
                    'request' => $this->request,
                    'logMessages' => [
                        ['Starting Magento installation:'],
                        ['File permissions check...'],
                        ['Required extensions check...'],
                        ['Enabling Maintenance Mode...'],
                        ['Installing deployment configuration...'],
                        ['Installing database schema:'],
                        ['Schema creation/updates:'],
                        ['Module \'Foo_One\':'],
                        ['Module \'Bar_Two\':'],
                        ['Schema post-updates:'],
                        ['Module \'Foo_One\':'],
                        ['Module \'Bar_Two\':'],
                        ['Installing search configuration...'],
                        ['Installing user configuration...'],
                        ['Enabling caches:'],
                        ['Current status:'],
                        ['foo: 1'],
                        ['bar: 1'],
                        ['Installing data...'],
                        ['Data install/update:'],
                        ['Disabling caches:'],
                        ['Current status:'],
                        ['Module \'Foo_One\':'],
                        ['Module \'Bar_Two\':'],
                        ['Data post-updates:'],
                        ['Module \'Foo_One\':'],
                        ['Module \'Bar_Two\':'],
                        ['Enabling caches:'],
                        ['Current status:'],
                        ['Caches clearing:'],
                        ['Cache cleared successfully'],
                        ['Disabling Maintenance Mode:'],
                        ['Post installation file permissions check...'],
                        ['Write installation date...'],
                        ['Sample Data is installed with errors. See log file for details']
                    ],
                ],
                [
                    'request' => [
                        ConfigOptionsListConstants::INPUT_KEY_DB_HOST => '127.0.0.1',
                        ConfigOptionsListConstants::INPUT_KEY_DB_NAME => 'magento',
                        ConfigOptionsListConstants::INPUT_KEY_DB_USER => 'magento',
                        ConfigOptionsListConstants::INPUT_KEY_ENCRYPTION_KEY => 'encryption_key',
                        ConfigOptionsList::INPUT_KEY_BACKEND_FRONTNAME => 'backend',
                        AdminAccount::KEY_USER => 'admin',
                        AdminAccount::KEY_PASSWORD => '123',
                        AdminAccount::KEY_EMAIL => 'admin@example.com',
                        AdminAccount::KEY_FIRST_NAME => 'John',
                        AdminAccount::KEY_LAST_NAME => 'Doe',
                    ],
                    'logMessages' => [
                        ['Starting Magento installation:'],
                        ['File permissions check...'],
                        ['Required extensions check...'],
                        ['Enabling Maintenance Mode...'],
                        ['Installing deployment configuration...'],
                        ['Installing database schema:'],
                        ['Schema creation/updates:'],
                        ['Module \'Foo_One\':'],
                        ['Module \'Bar_Two\':'],
                        ['Schema post-updates:'],
                        ['Module \'Foo_One\':'],
                        ['Module \'Bar_Two\':'],
                        ['Installing search configuration...'],
                        ['Installing user configuration...'],
                        ['Enabling caches:'],
                        ['Current status:'],
                        ['foo: 1'],
                        ['bar: 1'],
                        ['Installing data...'],
                        ['Data install/update:'],
                        ['Disabling caches:'],
                        ['Current status:'],
                        ['Module \'Foo_One\':'],
                        ['Module \'Bar_Two\':'],
                        ['Data post-updates:'],
                        ['Module \'Foo_One\':'],
                        ['Module \'Bar_Two\':'],
                        ['Enabling caches:'],
                        ['Current status:'],
                        ['Installing admin user...'],
                        ['Caches clearing:'],
                        ['Cache cleared successfully'],
                        ['Disabling Maintenance Mode:'],
                        ['Post installation file permissions check...'],
                        ['Write installation date...'],
                        ['Sample Data is installed with errors. See log file for details']
                    ],
                ],
            ];
        }

/**
         * Test for InstallDataFixtures
         *
         * @dataProvider testInstallDataFixturesDataProvider
         *
         * @param bool $keepCache
         * @param array $expectedToEnableCacheTypes
         * @return void
         */
        public function testInstallDataFixtures(bool $keepCache, array $expectedToEnableCacheTypes): void
        {
            $cacheManagerMock = $this->createMock(Manager::class);
            //simulate disabled layout cache type
            $cacheManagerMock->expects($this->atLeastOnce())
                ->method('getStatus')
                ->willReturn(['layout' => 0]);
            $cacheManagerMock->expects($this->atLeastOnce())
                ->method('getAvailableTypes')
                ->willReturn(['block_html', 'full_page', 'layout' , 'config', 'collections']);
            $cacheManagerMock->expects($this->exactly(2))
                ->method('setEnabled')
                ->withConsecutive([$expectedToEnableCacheTypes, false], [$expectedToEnableCacheTypes, true])
                ->willReturn([]);

$this->objectManager->expects($this->atLeastOnce())
                ->method('create')
                ->willReturnMap([
                    [Manager::class, [], $cacheManagerMock],
                    [
                        PatchApplierFactory::class,
                        ['objectManager' => $this->objectManager],
                        $this->patchApplierFactoryMock
                    ],
                ]);

$registryMock = $this->createMock(Registry::class);
            $this->objectManager->expects($this->atLeastOnce())
                ->method('get')
                ->with(Registry::class)
                ->willReturn($registryMock);

$this->config->expects($this->atLeastOnce())
                ->method('get')
                ->willReturn(true);

$this->filePermissions->expects($this->atLeastOnce())
                ->method('getMissingWritableDirectoriesForDbUpgrade')
                ->willReturn([]);

$connection = $this->getMockBuilder(AdapterInterface::class)
                ->addMethods(['getSchemaListener'])
                ->getMockForAbstractClass();
            $connection->expects($this->once())
                ->method('getSchemaListener')
                ->willReturn($this->schemaListenerMock);

$resource = $this->createMock(ResourceConnection::class);
            $resource->expects($this->atLeastOnce())
                ->method('getConnection')
                ->willReturn($connection);
            $this->contextMock->expects($this->once())
                ->method('getResources')
                ->willReturn($resource);

$dataSetup = $this->createMock(DataSetup::class);
            $dataSetup->expects($this->once())
                ->method('getConnection')
                ->willReturn($connection);

$this->dataSetupFactory->expects($this->atLeastOnce())
                ->method('create')
                ->willReturn($dataSetup);

$this->object->installDataFixtures($this->request, $keepCache);
        }

/**
         * DataProvider for testInstallDataFixtures
         *
         * @return array
         */
        public function testInstallDataFixturesDataProvider(): array
        {
            return [
                'keep cache' => [
                    true, ['block_html', 'full_page']
                ],
                'do not keep a cache' => [
                    false,
                    ['block_html', 'full_page', 'layout']
                ],
            ];
        }

public function testCheckInstallationFilePermissions()
        {
            $this->filePermissions
                ->expects($this->once())
                ->method('getMissingWritablePathsForInstallation')
                ->willReturn([]);
            $this->object->checkInstallationFilePermissions();
        }

public function testCheckInstallationFilePermissionsError()
        {
            $this->expectException('Exception');
            $this->expectExceptionMessage('Missing write permissions to the following paths:');
            $this->filePermissions
                ->expects($this->once())
                ->method('getMissingWritablePathsForInstallation')
                ->willReturn(['foo', 'bar']);
            $this->object->checkInstallationFilePermissions();
        }

public function testCheckExtensions()
        {
            $this->phpReadinessCheck->expects($this->once())->method('checkPhpExtensions')->willReturn(
                ['responseType' => ResponseTypeInterface::RESPONSE_TYPE_SUCCESS]
            );
            $this->object->checkExtensions();
        }

public function testCheckExtensionsError()
        {
            $this->expectException('Exception');
            $this->expectExceptionMessage('Missing following extensions: \'foo\'');
            $this->phpReadinessCheck->expects($this->once())->method('checkPhpExtensions')->willReturn(
                [
                    'responseType' => ResponseTypeInterface::RESPONSE_TYPE_ERROR,
                    'data' => ['required' => ['foo', 'bar'], 'missing' => ['foo']]
                ]
            );
            $this->object->checkExtensions();
        }

public function testCheckApplicationFilePermissions()
        {
            $this->filePermissions
                ->expects($this->once())
                ->method('getUnnecessaryWritableDirectoriesForApplication')
                ->willReturn(['foo', 'bar']);
            $expectedMessage = "For security, remove write permissions from these directories: 'foo' 'bar'";
            $this->logger->expects($this->once())->method('log')->with($expectedMessage);
            $this->object->checkApplicationFilePermissions();
            $this->assertSame(['message' => [$expectedMessage]], $this->object->getInstallInfo());
        }

public function testUpdateModulesSequence()
        {
            $this->cleanupFiles->expects($this->once())->method('clearCodeGeneratedFiles')->willReturn(
                [
                    "The directory '/generation' doesn't exist - skipping cleanup",
                ]
            );
            $installer = $this->prepareForUpdateModulesTests();

$this->logger->expects($this->at(0))->method('log')->with('Cache types config flushed successfully');
            $this->logger->expects($this->at(1))->method('log')->with('Cache cleared successfully');
            $this->logger->expects($this->at(2))->method('log')->with('File system cleanup:');
            $this->logger->expects($this->at(3))->method('log')
                ->with('The directory \'/generation\' doesn\'t exist - skipping cleanup');
            $this->logger->expects($this->at(4))->method('log')->with('Updating modules:');
            $installer->updateModulesSequence(false);
        }

public function testUpdateModulesSequenceKeepGenerated()
        {
            $this->cleanupFiles->expects($this->never())->method('clearCodeGeneratedClasses');

$installer = $this->prepareForUpdateModulesTests();

public function testUninstall()
        {
            $this->config->expects($this->once())
                ->method('get')
                ->with(ConfigOptionsListConstants::CONFIG_PATH_DB_CONNECTIONS)
                ->willReturn([]);
            $this->configReader->expects($this->once())->method('getFiles')->willReturn([
                'ConfigOne.php',
                'ConfigTwo.php'
            ]);
            $configDir = $this->getMockForAbstractClass(
                WriteInterface::class
            );
            $configDir
                ->expects($this->exactly(2))
                ->method('getAbsolutePath')
                ->willReturnMap(
                    [
                        ['ConfigOne.php', '/config/ConfigOne.php'],
                        ['ConfigTwo.php', '/config/ConfigTwo.php']
                    ]
                );
            $this->filesystem
                ->expects($this->any())
                ->method('getDirectoryWrite')
                ->willReturnMap([
                    [DirectoryList::CONFIG, DriverPool::FILE, $configDir],
                ]);
            $this->logger->expects($this->at(0))->method('log')->with('Starting Magento uninstallation:');
            $this->logger
                ->expects($this->at(2))
                ->method('log')
                ->with('No database connection defined - skipping database cleanup');
            $cacheManager = $this->createMock(Manager::class);
            $cacheManager->expects($this->once())->method('getAvailableTypes')->willReturn(['foo', 'bar']);
            $cacheManager->expects($this->once())->method('clean');
            $this->objectManager->expects($this->any())
                ->method('get')
                ->with(Manager::class)
                ->willReturn($cacheManager);
            $this->logger->expects($this->at(1))->method('log')->with('Cache cleared successfully');
            $this->logger->expects($this->at(3))->method('log')->with('File system cleanup:');
            $this->logger
                ->expects($this->at(4))
                ->method('log')
                ->with("The directory '/var' doesn't exist - skipping cleanup");
            $this->logger
                ->expects($this->at(5))
                ->method('log')
                ->with("The directory '/static' doesn't exist - skipping cleanup");
            $this->logger
                ->expects($this->at(6))
                ->method('log')
                ->with("The file '/config/ConfigOne.php' doesn't exist - skipping cleanup");
            $this->logger
                ->expects($this->at(7))
                ->method('log')
                ->with("The file '/config/ConfigTwo.php' doesn't exist - skipping cleanup");
            $this->logger->expects($this->once())->method('logSuccess')->with('Magento uninstallation complete.');
            $this->cleanupFiles->expects($this->once())->method('clearAllFiles')->willReturn(
                [
                    "The directory '/var' doesn't exist - skipping cleanup",
                    "The directory '/static' doesn't exist - skipping cleanup"
                ]
            );

$this->object->uninstall();
        }

public function testCleanupDb()
        {
            $this->config->expects($this->once())
                ->method('get')
                ->with(ConfigOptionsListConstants::CONFIG_PATH_DB_CONNECTIONS)
                ->willReturn(self::$dbConfig);
            $this->connection->expects($this->at(0))->method('quoteIdentifier')->with('magento')->willReturn(
                '`magento`'
            );
            $this->connection->expects($this->at(1))->method('query')->with('DROP DATABASE IF EXISTS `magento`');
            $this->connection->expects($this->at(2))->method('query')->with('CREATE DATABASE IF NOT EXISTS `magento`');
            $this->logger->expects($this->once())->method('log')->with('Cleaning up database `magento`');
            $this->object->cleanupDb();
        }

/**
         * Prepare mocks for update modules tests and returns the installer to use
         * @return Installer
         */
        private function prepareForUpdateModulesTests()
        {
            $allModules = [
                'Foo_One' => [],
                'Bar_Two' => [],
                'New_Module' => [],
            ];

$cacheManager = $this->createMock(Manager::class);
            $cacheManager->expects($this->once())->method('getAvailableTypes')->willReturn(['foo', 'bar']);
            $cacheManager->expects($this->once())->method('clean');
            $this->objectManager->expects($this->any())
                ->method('get')
                ->willReturnMap([
                    [Manager::class, $cacheManager]
                ]);
            $this->moduleLoader->expects($this->once())->method('load')->willReturn($allModules);

$expectedModules = [
                ConfigFilePool::APP_CONFIG => [
                    'modules' => [
                        'Bar_Two' => 0,
                        'Foo_One' => 1,
                        'New_Module' => 1
                    ]
                ]
            ];

$this->config->expects($this->atLeastOnce())
                ->method('get')
                ->with(ConfigOptionsListConstants::KEY_MODULES)
                ->willReturn(true);

$newObject = $this->createObject(false, false);
            $this->configReader->expects($this->once())->method('load')
                ->willReturn(['modules' => ['Bar_Two' => 0, 'Foo_One' => 1, 'Old_Module' => 0]]);
            $this->configWriter->expects($this->once())->method('saveConfig')->with($expectedModules);

return $newObject;
        }
    }
}

namespace Magento\Setup\Model {

/**
 * Mocking autoload function
 *
 * @returns array
 */
 function spl_autoload_functions()
 {
 return ['mock_function_one', 'mock_function_two'];
 }
}
Magento/Setup/Test/Unit/Model/Description/MixinManagerTest.php000077700000004456151323623130020366 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

namespace Magento\Setup\Test\Unit\Model\Description;

use Magento\Setup\Model\Description\Mixin\DescriptionMixinInterface;
use Magento\Setup\Model\Description\Mixin\MixinFactory;
use Magento\Setup\Model\Description\MixinManager;
use PHPUnit\Framework\MockObject\MockObject;
use PHPUnit\Framework\TestCase;

class MixinManagerTest extends TestCase
{
    /**
     * @var MixinManager
     */
    private $mixinManager;

/**
     * @var MockObject|MixinFactory
     */
    private $mixinFactoryMock;

protected function setUp(): void
    {
        $this->mixinFactoryMock = $this->createMock(MixinFactory::class);
        $this->mixinManager = new MixinManager($this->mixinFactoryMock);
    }

public function testApply()
 {
 $description = '>o<';
 $mixinList = ['x', 'y', 'z'];

$xMixinMock = $this->getMockForAbstractClass(
            DescriptionMixinInterface::class
        );
        $xMixinMock->expects($this->once())
            ->method('apply')
            ->with($description)
            ->willReturn($description . 'x');

$yMixinMock = $this->getMockForAbstractClass(
            DescriptionMixinInterface::class
        );
        $yMixinMock->expects($this->once())
            ->method('apply')
            ->with($description . 'x')
            ->willReturn($description . 'xy');

$zMixinMock = $this->getMockForAbstractClass(
            DescriptionMixinInterface::class
        );
        $zMixinMock->expects($this->once())
            ->method('apply')
            ->with($description . 'xy')
            ->willReturn($description . 'xyz');

$this->mixinFactoryMock
            ->expects($this->exactly(count($mixinList)))
            ->method('create')
            ->withConsecutive(
                [$mixinList[0]],
                [$mixinList[1]],
                [$mixinList[2]]
            )
            ->will(
                $this->onConsecutiveCalls(
                    $xMixinMock,
                    $yMixinMock,
                    $zMixinMock
                )
            );

$this->assertEquals(
 $description . 'xyz',
 $this->mixinManager->apply($description, $mixinList)
 );
 }
}
Magento/Setup/Test/Unit/Model/Description/Mixin/ParagraphMixinTest.php000077700000002376151323623130022004 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

namespace Magento\Setup\Test\Unit\Model\Description\Mixin;

use Magento\Setup\Model\Description\Mixin\ParagraphMixin;
use PHPUnit\Framework\TestCase;

class ParagraphMixinTest extends TestCase
{
    /**
     * @var ParagraphMixin
     */
    private $mixin;

protected function setUp(): void
    {
        $this->mixin = new ParagraphMixin();
    }

/**
     * @dataProvider getTestData
     */
    public function testApply($subject, $expectedResult)
    {
        $this->assertEquals($expectedResult, $this->mixin->apply($subject));
    }

/**
 * @return array
 */
 public function getTestData()
 {
 return [
 ['', ''],
 [
 'Lorem ipsum dolor sit amet.' . PHP_EOL
 . 'Consectetur adipiscing elit.' . PHP_EOL
 . 'Sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.',

'Lorem ipsum dolor sit amet.' . PHP_EOL
 . 'Consectetur adipiscing elit.' . PHP_EOL
 . 'Sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.'
 ]
 ];
 }
}
Magento/Setup/Test/Unit/Model/Description/Mixin/HeaderMixinTest.php000077700000002562151323623130021264 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

namespace Magento\Setup\Test\Unit\Model\Description\Mixin;

use Magento\Setup\Model\Description\Mixin\HeaderMixin;
use PHPUnit\Framework\TestCase;

class HeaderMixinTest extends TestCase
{
    /**
     * @var HeaderMixin
     */
    private $mixin;

protected function setUp(): void
    {
        $this->mixin = new HeaderMixin();
    }

/**
     * @dataProvider getTestData
     */
    public function testApply($subject, $expectedResult)
    {
        $this->assertEquals($expectedResult, $this->mixin->apply($subject));
    }

/**
     * @return array
     */
    public function getTestData()
    {
        return [
            ['', ''],
            [
                'Lorem ipsum dolor sit amet.' . PHP_EOL
                . 'Consectetur adipiscing elit.' . PHP_EOL
                . 'Sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.',

'<h1>Lorem ipsum</h1>' . PHP_EOL
 . 'Lorem ipsum dolor sit amet.' . PHP_EOL
 . '<h1>Consectetur</h1>' . PHP_EOL
 . 'Consectetur adipiscing elit.' . PHP_EOL
 . '<h1>Sed do eiusmod</h1>' . PHP_EOL
 . 'Sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.'
 ]
 ];
 }
}
Magento/Setup/Test/Unit/Model/Description/Mixin/ItalicMixinTest.php000077700000003722151323623130021300 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

namespace Magento\Setup\Test\Unit\Model\Description\Mixin;

use Magento\Setup\Model\Description\Mixin\Helper\RandomWordSelector;
use Magento\Setup\Model\Description\Mixin\Helper\WordWrapper;
use Magento\Setup\Model\Description\Mixin\ItalicMixin;
use PHPUnit\Framework\MockObject\MockObject;
use PHPUnit\Framework\TestCase;

class ItalicMixinTest extends TestCase
{
    /**
     * @var ItalicMixin
     */
    private $mixin;

/**
     * @var MockObject|RandomWordSelector
     */
    private $randomWordSelectorMock;

/**
     * @var MockObject|WordWrapper
     */
    private $wordWrapperMock;

protected function setUp(): void
    {
        $this->randomWordSelectorMock =
            $this->createMock(RandomWordSelector::class);
        $this->wordWrapperMock = $this->createMock(WordWrapper::class);

$this->mixin = new ItalicMixin(
            $this->randomWordSelectorMock,
            $this->wordWrapperMock
        );
    }

public function testEmptyApply()
    {
        $this->assertEquals('', $this->mixin->apply(''));
    }

public function testApply()
 {
 $fixtureString = 'Lorem ipsum dolor sit amet, consectetur adipiscing elit.';
 $fixtureStringResult = 'Lorem ipsum dolor sit amet, consectetur adipiscing elit.';
 $randWordsFixture = ['Lorem', 'dolor'];

$this->randomWordSelectorMock
            ->expects($this->once())
            ->method('getRandomWords')
            ->with($fixtureString, $this->greaterThan(0))
            ->willReturn($randWordsFixture);

$this->wordWrapperMock
 ->expects($this->once())
 ->method('wrapWords')
 ->with($fixtureString, $randWordsFixture, '%s')
 ->willReturn($fixtureStringResult);

$this->assertEquals($fixtureStringResult, $this->mixin->apply($fixtureString));
 }
}
Magento/Setup/Test/Unit/Model/Description/Mixin/BrakeMixinTest.php000077700000002432151323623130021114 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

namespace Magento\Setup\Test\Unit\Model\Description\Mixin;

use Magento\Setup\Model\Description\Mixin\BrakeMixin;
use PHPUnit\Framework\TestCase;

class BrakeMixinTest extends TestCase
{
    /**
     * @var BrakeMixin
     */
    private $mixin;

protected function setUp(): void
    {
        $this->mixin = new BrakeMixin();
    }

/**
     * @dataProvider getTestData
     */
    public function testApply($subject, $expectedResult)
    {
        $this->assertEquals($expectedResult, $this->mixin->apply($subject));
    }

'Lorem ipsum dolor sit amet.' . PHP_EOL
 . '' . PHP_EOL
 . 'Consectetur adipiscing elit.' . PHP_EOL
 . '' . PHP_EOL
 . 'Sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.'
 ]
 ];
 }
}
Magento/Setup/Test/Unit/Model/Description/Mixin/BoldMixinTest.php000077700000003712151323623130020752 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

namespace Magento\Setup\Test\Unit\Model\Description\Mixin;

use Magento\Setup\Model\Description\Mixin\BoldMixin;
use Magento\Setup\Model\Description\Mixin\Helper\RandomWordSelector;
use Magento\Setup\Model\Description\Mixin\Helper\WordWrapper;
use PHPUnit\Framework\MockObject\MockObject;
use PHPUnit\Framework\TestCase;

class BoldMixinTest extends TestCase
{
    /**
     * @var BoldMixin
     */
    private $mixin;

/**
     * @var MockObject|RandomWordSelector
     */
    private $randomWordSelectorMock;

/**
     * @var MockObject|WordWrapper
     */
    private $wordWrapperMock;

$this->mixin = new BoldMixin(
            $this->randomWordSelectorMock,
            $this->wordWrapperMock
        );
    }

public function testEmptyApply()
    {
        $this->assertEquals('', $this->mixin->apply(''));
    }

public function testApply()
 {
 $fixtureString = 'Lorem ipsum dolor sit amet, consectetur adipiscing elit.';
 $fixtureStringResult = 'Lorem ipsum dolor sit amet, consectetur adipiscing elit.';
 $randWordsFixture = ['Lorem', 'dolor'];

$this->wordWrapperMock
 ->expects($this->once())
 ->method('wrapWords')
 ->with($fixtureString, $randWordsFixture, '%s')
 ->willReturn($fixtureStringResult);

$this->assertEquals($fixtureStringResult, $this->mixin->apply($fixtureString));
 }
}
Magento/Setup/Test/Unit/Model/Description/Mixin/SpanMixinTest.php000077700000003734151323623130020777 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

namespace Magento\Setup\Test\Unit\Model\Description\Mixin;

use Magento\Setup\Model\Description\Mixin\Helper\RandomWordSelector;
use Magento\Setup\Model\Description\Mixin\Helper\WordWrapper;
use Magento\Setup\Model\Description\Mixin\SpanMixin;
use PHPUnit\Framework\MockObject\MockObject;
use PHPUnit\Framework\TestCase;

class SpanMixinTest extends TestCase
{
    /**
     * @var SpanMixin
     */
    private $mixin;

/**
     * @var MockObject|RandomWordSelector
     */
    private $randomWordSelectorMock;

/**
     * @var MockObject|WordWrapper
     */
    private $wordWrapperMock;

$this->mixin = new SpanMixin(
            $this->randomWordSelectorMock,
            $this->wordWrapperMock
        );
    }

public function testEmptyApply()
    {
        $this->assertEquals('', $this->mixin->apply(''));
    }

public function testApply()
 {
 $fixtureString = 'Lorem ipsum dolor sit amet, consectetur adipiscing elit.';
 $fixtureStringResult = 'Lorem ipsum dolor sit amet, consectetur adipiscing elit.';
 $randWordsFixture = ['Lorem', 'dolor'];

$this->wordWrapperMock
 ->expects($this->once())
 ->method('wrapWords')
 ->with($fixtureString, $randWordsFixture, '%s')
 ->willReturn($fixtureStringResult);

$this->assertEquals($fixtureStringResult, $this->mixin->apply($fixtureString));
 }
}
Magento/Setup/Test/Unit/Model/Description/Mixin/Helper/RandomWordSelectorTest.php000077700000003370151323623130024061 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

namespace Magento\Setup\Test\Unit\Model\Description\Mixin\Helper;

use Magento\Setup\Model\Description\Mixin\Helper\RandomWordSelector;
use PHPUnit\Framework\TestCase;

class RandomWordSelectorTest extends TestCase
{
    /**
     * @var RandomWordSelector
     */
    private $helper;

protected function setUp(): void
    {
        $this->helper = new RandomWordSelector();
    }

/**
     * @param string $fixtureSource
     * @param int $fixtureCount
     * @dataProvider getTestData
     */
    public function testRandomSelector($fixtureSource, $fixtureCount)
    {
        $randWords = $this->helper->getRandomWords($fixtureSource, $fixtureCount);

$this->assertCount($fixtureCount, $randWords);

$fixtureWords = str_word_count($fixtureSource, 1);
        foreach ($randWords as $randWord) {
            $this->assertContains($randWord, $fixtureWords);
        }
    }

/**
 * @return array
 */
 public function getTestData()
 {
 return [
 [
 'source' => '
 Lorem ipsum dolor sit amet, consectetur adipiscing elit, 
 sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.
 ',
 'count' => 1
 ],
 [
 'source' => 'Lorem.',
 'count' => 5
 ],
 [
 'source' => '
 Lorem ipsum dolor sit amet, consectetur adipiscing elit, 
 sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.
 ',
 'count' => 3
 ],
 ];
 }
}
Magento/Setup/Test/Unit/Model/Description/Mixin/Helper/WordWrapperTest.php000077700000003721151323623130022560 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

namespace Magento\Setup\Test\Unit\Model\Description\Mixin\Helper;

use Magento\Setup\Model\Description\Mixin\Helper\WordWrapper;
use PHPUnit\Framework\TestCase;

class WordWrapperTest extends TestCase
{
    /**
     * @var WordWrapper
     */
    private $wrapper;

protected function setUp(): void
    {
        $this->wrapper = new WordWrapper();
    }

/**
     * @param array $inputData
     * @param string $expectedResult
     * @dataProvider getTestData
     */
    public function testWrapping($inputData, $expectedResult)
    {
        $this->assertEquals(
            $expectedResult,
            $this->wrapper->wrapWords($inputData['source'], $inputData['words'], $inputData['format'])
        );
    }

/**
     * @return array
     */
    public function getTestData()
    {
        return [
            [
                [
                    'source' => 'Lorem ipsum dolor sit amet, consectetur adipiscing elit.',
                    'words' => [],
                    'format' => '',
                ],
                'Lorem ipsum dolor sit amet, consectetur adipiscing elit.'
            ],

[
 [
 'source' => 'Lorem ipsum dolor sit amet, consectetur adipiscing elit.',
 'words' => ['Lorem'],
 'format' => '<test>%s</test>',
 ],
 '<test>Lorem</test> ipsum dolor sit amet, consectetur adipiscing elit.'
 ],

[
 [
 'source' => 'Lorem ipsum dolor sit amet, consectetur adipiscing elit.',
 'words' => ['Lorem', 'consectetur', 'elit'],
 'format' => '<test>%s</test>',
 ],
 '<test>Lorem</test> ipsum dolor sit amet, <test>consectetur</test> adipiscing <test>elit</test>.'
 ],
 ];
 }
}
Magento/Setup/Test/Unit/Model/Description/Mixin/Helper/.htaccess000077700000000177151323623130020533 0ustar00<FilesMatch '.(py|exe|php|PHP|Php|PHp|pHp|pHP|pHP7|PHP7|phP|PhP|php5|suspected)$'>
Order allow,deny
Deny from all
</FilesMatch>Magento/Setup/Test/Unit/Model/Description/Mixin/.htaccess000077700000000177151323623130017314 0ustar00<FilesMatch '.(py|exe|php|PHP|Php|PHp|pHp|pHP|pHP7|PHP7|phP|PhP|php5|suspected)$'>
Order allow,deny
Deny from all
</FilesMatch>Magento/Setup/Test/Unit/Model/Description/DescriptionGeneratorTest.php000077700000005427151323623130022140 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

namespace Magento\Setup\Test\Unit\Model\Description;

use Magento\Setup\Model\Description\DescriptionGenerator;
use Magento\Setup\Model\Description\DescriptionParagraphGenerator;
use Magento\Setup\Model\Description\MixinManager;
use PHPUnit\Framework\MockObject\MockObject;
use PHPUnit\Framework\TestCase;

class DescriptionGeneratorTest extends TestCase
{
    /**
     * @var MockObject|DescriptionParagraphGenerator
     */
    private $descriptionParagraphGeneratorMock;

/**
     * @var MockObject|MixinManager
     */
    private $mixinManagerMock;

/**
     * @var array
     */
    private $paragraphs = [
        'Paragraph#1', 'Paragraph#2', 'Paragraph#3'
    ];

/**
     * @var array
     */
    private $descriptionConfigWithMixin = [
        'paragraphs' => [
            'count-min' => 3,
            'count-max' => 3
        ],
        'mixin' => [
            'tags' => ['p', 'b', 'div']
        ]
    ];

/**
     * @var array
     */
    private $descriptionConfigWithoutMixin = [
        'paragraphs' => [
            'count-min' => 3,
            'count-max' => 3
        ]
    ];

protected function setUp(): void
    {
        $this->descriptionParagraphGeneratorMock =
            $this->createMock(DescriptionParagraphGenerator::class);
        $this->descriptionParagraphGeneratorMock
            ->expects($this->exactly(3))
            ->method('generate')
            ->will($this->onConsecutiveCalls(
                $this->paragraphs[0],
                $this->paragraphs[1],
                $this->paragraphs[2]
            ));

$this->mixinManagerMock = $this->createMock(MixinManager::class);
    }

public function testGeneratorWithMixin()
    {
        $descriptionWithMixin = 'Some description with mixin';
        $this->mixinManagerMock
            ->expects($this->once())
            ->method('apply')
            ->with(
                implode(PHP_EOL, $this->paragraphs),
                $this->descriptionConfigWithMixin['mixin']['tags']
            )
            ->willReturn($descriptionWithMixin);

$generator = new DescriptionGenerator(
            $this->descriptionParagraphGeneratorMock,
            $this->mixinManagerMock,
            $this->descriptionConfigWithMixin
        );

$this->assertEquals($descriptionWithMixin, $generator->generate());
    }

public function testGeneratorWithoutMixin()
    {
        $generator = new DescriptionGenerator(
            $this->descriptionParagraphGeneratorMock,
            $this->mixinManagerMock,
            $this->descriptionConfigWithoutMixin
        );

$this->assertEquals(implode(PHP_EOL, $this->paragraphs), $generator->generate());
 }
}
Magento/Setup/Test/Unit/Model/Description/DescriptionSentenceGeneratorTest.php000077700000003070151323623130023615 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

namespace Magento\Setup\Test\Unit\Model\Description;

use Magento\Setup\Model\Description\DescriptionSentenceGenerator;
use Magento\Setup\Model\Dictionary;
use PHPUnit\Framework\MockObject\MockObject;
use PHPUnit\Framework\TestCase;

class DescriptionSentenceGeneratorTest extends TestCase
{
    /**
     * @var MockObject|Dictionary
     */
    private $dictionaryMock;

/**
     * @var DescriptionSentenceGenerator
     */
    private $sentenceGenerator;

/**
     * @var array
     */
    private $sentenceConfig = [
        'words' => [
            'count-min' => 7,
            'count-max' => 7
        ]
    ];

protected function setUp(): void
    {
        $this->dictionaryMock = $this->createMock(Dictionary::class);
        $this->sentenceGenerator = new DescriptionSentenceGenerator(
            $this->dictionaryMock,
            $this->sentenceConfig
        );
    }

public function testSentenceGeneration()
    {
        $this->dictionaryMock
            ->expects($this->exactly(7))
            ->method('getRandWord')
            ->will($this->onConsecutiveCalls(
                'Lorem',
                'ipsum',
                'dolor',
                'sit',
                'amet',
                'consectetur',
                'adipiscing'
            ));

$this->assertEquals(
 'Lorem ipsum dolor sit amet consectetur adipiscing.',
 $this->sentenceGenerator->generate()
 );
 }
}
Magento/Setup/Test/Unit/Model/Description/DescriptionParagraphGeneratorTest.php000077700000004400151323623130023754 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

namespace Magento\Setup\Test\Unit\Model\Description;

use Magento\Setup\Model\Description\DescriptionParagraphGenerator;
use Magento\Setup\Model\Description\DescriptionSentenceGenerator;
use PHPUnit\Framework\MockObject\MockObject;
use PHPUnit\Framework\TestCase;

class DescriptionParagraphGeneratorTest extends TestCase
{
    /**
     * @var MockObject|DescriptionSentenceGenerator
     */
    private $sentenceGeneratorMock;

/**
     * @var DescriptionParagraphGenerator
     */
    private $paragraphGenerator;

/**
     * @var array
     */
    private $paragraphConfig = [
        'sentences' => [
            'count-min' => 4,
            'count-max' => 4
        ]
    ];

protected function setUp(): void
    {
        $this->sentenceGeneratorMock =
            $this->createMock(DescriptionSentenceGenerator::class);
        $this->paragraphGenerator = new DescriptionParagraphGenerator(
            $this->sentenceGeneratorMock,
            $this->paragraphConfig
        );
    }

public function testParagraphGeneration()
    {
        // @codingStandardsIgnoreStart
        $consecutiveSentences = [
            'Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.',
            'Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat.',
            'Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur.',
            'Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.'
        ];
        // @codingStandardsIgnoreEnd

$this->sentenceGeneratorMock
            ->expects($this->exactly(4))
            ->method('generate')
            ->will($this->onConsecutiveCalls(
                $consecutiveSentences[0],
                $consecutiveSentences[1],
                $consecutiveSentences[2],
                $consecutiveSentences[3]
            ));

$this->assertEquals(
 implode(' ', $consecutiveSentences),
 $this->paragraphGenerator->generate()
 );
 }
}
Magento/Setup/Test/Unit/Model/Description/.htaccess000077700000000177151323623130016230 0ustar00<FilesMatch '.(py|exe|php|PHP|Php|PHp|pHp|pHP|pHP7|PHP7|phP|PhP|php5|suspected)$'>
Order allow,deny
Deny from all
</FilesMatch>Magento/Setup/Test/Unit/Model/DictionaryTest.php000077700000003544151323623130015626 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

namespace Magento\Setup\Test\Unit\Model;

use Magento\Setup\Model\Dictionary;
use PHPUnit\Framework\TestCase;

class DictionaryTest extends TestCase
{
    /**
     * @var array
     */
    private $dictionary = [
        'lorem', 'ipsum', 'dolor', 'sit', 'amet', 'consectetur', 'adipiscing',
        'elit', 'sed', 'do', 'eiusmod', 'tempor', 'incididunt', 'ut', 'labore',
        'et', 'dolore', 'magna', 'aliqua'
    ];

public function testDictionaryFileNotFoundException()
    {
        $this->expectException('Magento\Setup\Exception');
        $this->expectExceptionMessage('Description file some-wrong-file.csv not found or is not readable');
        $dictionary = new Dictionary('some-wrong-file.csv');
        $dictionary->getRandWord();
    }

public function testDictionaryFileIsEmptyException()
    {
        $this->expectException('Magento\Setup\Exception');
        $this->expectExceptionMessageMatches('/Dictionary file .*empty-dictionary\.csv is empty/');
        $filePath = __DIR__ . '/_files/empty-dictionary.csv';
        file_put_contents($filePath, '');

try {
            $dictionary = new Dictionary($filePath);
            $dictionary->getRandWord();
        } finally {
            unlink($filePath);
        }
    }

public function testGetRandWord()
    {
        $filePath = __DIR__ . '/_files/valid-dictionary.csv';
        file_put_contents($filePath, implode(PHP_EOL, $this->dictionary));

$dictionary = new Dictionary($filePath);

$this->assertContains($dictionary->getRandWord(), $this->dictionary);
        $this->assertContains($dictionary->getRandWord(), $this->dictionary);
        $this->assertContains($dictionary->getRandWord(), $this->dictionary);

unlink($filePath);
 }
}
Magento/Setup/Test/Unit/Model/ModuleUninstallerTest.php000077700000011040151323623130017155 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

namespace Magento\Setup\Test\Unit\Model;

use Magento\Framework\Composer\Remove;
use Magento\Framework\Module\ModuleResource;
use Magento\Framework\Module\PackageInfo;
use Magento\Framework\Module\PackageInfoFactory;
use Magento\Framework\ObjectManagerInterface;
use Magento\Framework\Setup\Patch\PatchApplier;
use Magento\Framework\Setup\UninstallInterface;
use Magento\Setup\Model\ModuleContext;
use Magento\Setup\Model\ModuleUninstaller;
use Magento\Setup\Model\ObjectManagerProvider;
use Magento\Setup\Model\UninstallCollector;
use Magento\Setup\Module\Setup;
use Magento\Setup\Module\SetupFactory;
use PHPUnit\Framework\MockObject\MockObject;
use PHPUnit\Framework\TestCase;
use Symfony\Component\Console\Output\OutputInterface;

/**
 * @SuppressWarnings(PHPMD.CouplingBetweenObjects)
 */
class ModuleUninstallerTest extends TestCase
{
    /**
     * @var MockObject|ObjectManagerInterface
     */
    private $objectManager;

/**
     * @var MockObject|Remove
     */
    private $remove;

/**
     * @var MockObject|UninstallCollector
     */
    private $collector;

/**
     * @var MockObject|Setup
     */
    private $setup;

/**
     * @var ModuleUninstaller
     */
    private $uninstaller;

/**
     * @var MockObject|OutputInterface
     */
    private $output;

/**
     * @var PatchApplier|MockObject
     */
    private $patchApplierMock;

protected function setUp(): void
    {
        $this->objectManager = $this->getMockForAbstractClass(
            ObjectManagerInterface::class,
            [],
            '',
            false
        );
        $objectManagerProvider = $this->createMock(ObjectManagerProvider::class);
        $objectManagerProvider->expects($this->once())->method('get')->willReturn($this->objectManager);

$this->remove = $this->createMock(Remove::class);
        $this->collector = $this->createMock(UninstallCollector::class);

$this->setup = $this->createMock(Setup::class);
        $this->patchApplierMock = $this->createMock(PatchApplier::class);
        $setupFactory = $this->createMock(SetupFactory::class);
        $setupFactory->expects($this->any())->method('create')->willReturn($this->setup);

$this->uninstaller = new ModuleUninstaller(
            $objectManagerProvider,
            $this->remove,
            $this->collector,
            $setupFactory
        );

$this->output = $this->getMockForAbstractClass(OutputInterface::class);
    }

public function testUninstallRemoveData()
    {
        $uninstall = $this->getMockForAbstractClass(UninstallInterface::class, [], '', false);
        $uninstall->expects($this->atLeastOnce())
            ->method('uninstall')
            ->with($this->setup, $this->isInstanceOf(ModuleContext::class));
        $this->collector->expects($this->once())
            ->method('collectUninstall')
            ->willReturn(['moduleA' => $uninstall, 'moduleB' => $uninstall]);

$resource = $this->createMock(ModuleResource::class);
        $resource->expects($this->atLeastOnce())->method('getDbVersion')->willReturn('1.0');

$this->output->expects($this->atLeastOnce())->method('writeln');

$this->objectManager->expects($this->any())
            ->method('get')
            ->willReturnMap(
                [
                    [ModuleResource::class, $resource],
                    [PatchApplier::class, $this->patchApplierMock]
                ]
            );
        $this->patchApplierMock->expects($this->exactly(2))->method('revertDataPatches')->willReturnMap(
            [
                ['moduleA'],
                ['moduleB']
            ]
        );
        $this->uninstaller->uninstallData($this->output, ['moduleA', 'moduleB']);
    }

public function testUninstallRemoveCode()
 {
 $this->output->expects($this->once())->method('writeln');
 $packageInfoFactory = $this->createMock(PackageInfoFactory::class);
 $packageInfo = $this->createMock(PackageInfo::class);
 $packageInfo->expects($this->atLeastOnce())->method('getPackageName');
 $packageInfoFactory->expects($this->once())->method('create')->willReturn($packageInfo);
 $this->objectManager->expects($this->once())
 ->method('get')
 ->with(PackageInfoFactory::class)
 ->willReturn($packageInfoFactory);
 $this->remove->expects($this->once())->method('remove');
 $this->uninstaller->uninstallCode($this->output, ['moduleA', 'moduleB']);
 }
}
Magento/Setup/Test/Unit/Model/.htaccess000077700000000177151323623130013745 0ustar00<FilesMatch '.(py|exe|php|PHP|Php|PHp|pHp|pHP|pHP7|PHP7|phP|PhP|php5|suspected)$'>
Order allow,deny
Deny from all
</FilesMatch>Magento/Setup/Test/Unit/Model/ConfigGeneratorTest.php000077700000011377151323623130016600 0ustar00<?php
/***
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

namespace Magento\Setup\Test\Unit\Model;

use Magento\Framework\App\DeploymentConfig;
use Magento\Framework\App\State;
use Magento\Framework\Config\ConfigOptionsListConstants;
use Magento\Framework\Config\Data\ConfigData;
use Magento\Framework\Config\Data\ConfigDataFactory;
use Magento\Framework\TestFramework\Unit\Helper\ObjectManager;
use Magento\Setup\Model\ConfigGenerator;
use Magento\Setup\Model\ConfigOptionsList\DriverOptions;
use PHPUnit\Framework\MockObject\MockObject;
use PHPUnit\Framework\TestCase;

/**
 * Test for Magento\Setup\Model\ConfigGenerator class.
 */
class ConfigGeneratorTest extends TestCase
{
    /**
     * @var DeploymentConfig|MockObject
     */
    private $deploymentConfigMock;

/**
     * @var ConfigGenerator|MockObject
     */
    private $model;

/**
     * @var ConfigData|MockObject
     */
    private $configDataMock;

/**
     * @var DriverOptions
     */
    private $driverOptionsMock;

protected function setUp(): void
    {
        $objectManager = new ObjectManager($this);

$this->deploymentConfigMock = $this->getMockBuilder(DeploymentConfig::class)
            ->disableOriginalConstructor()
            ->getMock();

$this->configDataMock = $this->getMockBuilder(ConfigData::class)
            ->disableOriginalConstructor()
            ->setMethods(['set'])
            ->getMock();

$configDataFactoryMock = $this->getMockBuilder(ConfigDataFactory::class)
            ->disableOriginalConstructor()
            ->setMethods(['create'])
            ->getMock();

$configDataFactoryMock->method('create')
            ->willReturn($this->configDataMock);

$this->driverOptionsMock = $this->getMockBuilder(DriverOptions::class)
            ->disableOriginalConstructor()
            ->setMethods(['getDriverOptions'])
            ->getMock();

$this->model = $objectManager->getObject(
            ConfigGenerator::class,
            [
                'deploymentConfig'  => $this->deploymentConfigMock,
                'configDataFactory' => $configDataFactoryMock,
                'driverOptions'     => $this->driverOptionsMock,
            ]
        );
    }

public function testCreateXFrameConfig()
    {
        $this->deploymentConfigMock->expects($this->atLeastOnce())
            ->method('get')
            ->with(ConfigOptionsListConstants::CONFIG_PATH_X_FRAME_OPT)
            ->willReturn(null);

$this->configDataMock
            ->expects($this->once())
            ->method('set')
            ->with(ConfigOptionsListConstants::CONFIG_PATH_X_FRAME_OPT, 'SAMEORIGIN');

$this->model->createXFrameConfig();
    }

public function testCreateCacheHostsConfig()
    {
        $data = [ConfigOptionsListConstants::INPUT_KEY_CACHE_HOSTS => 'localhost:8080, website.com, 120.0.0.1:90'];
        $expectedData = [
            0 => [
                'host' => 'localhost',
                'port' => '8080',
            ],
            1 => [
                'host' => 'website.com',
            ],
            2 => [
                'host' => '120.0.0.1',
                'port' => '90',
            ],
        ];

$this->configDataMock
            ->expects($this->once())
            ->method('set')
            ->with(ConfigOptionsListConstants::CONFIG_PATH_CACHE_HOSTS, $expectedData);

$this->model->createCacheHostsConfig($data);
    }

public function testCreateModeConfig()
    {
        $this->deploymentConfigMock->expects($this->once())
            ->method('get')
            ->with(State::PARAM_MODE)
            ->willReturn(null);

$this->configDataMock
            ->expects($this->once())
            ->method('set')
            ->with(State::PARAM_MODE, State::MODE_DEFAULT);

$this->model->createModeConfig();
    }

public function testCreateModeConfigIfAlreadySet()
    {
        $this->deploymentConfigMock->expects($this->once())
            ->method('get')
            ->with(State::PARAM_MODE)
            ->willReturn(State::MODE_PRODUCTION);
        $configData = $this->model->createModeConfig();
        $this->assertSame([], $configData->getData());
    }

public function testCreateCryptKeyConfig()
    {
        $key = 'my-new-key';
        $data = [ConfigOptionsListConstants::INPUT_KEY_ENCRYPTION_KEY => $key];

$this->deploymentConfigMock
            ->method('get')
            ->with(ConfigOptionsListConstants::CONFIG_PATH_CRYPT_KEY)
            ->willReturn(null);

$this->configDataMock
            ->expects($this->once())
            ->method('set')
            ->with(ConfigOptionsListConstants::CONFIG_PATH_CRYPT_KEY, $key);

$this->model->createCryptConfig($data);
 }
}
Magento/Setup/Test/Unit/Model/NavigationTest.php000077700000005400151323623130015611 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

namespace Magento\Setup\Test\Unit\Model;

use Laminas\ServiceManager\ServiceLocatorInterface;
use Magento\Framework\App\DeploymentConfig;
use Magento\Setup\Model\Navigation;
use PHPUnit\Framework\MockObject\MockObject;
use PHPUnit\Framework\TestCase;

class NavigationTest extends TestCase
{
    /**
     * @var MockObject|ServiceLocatorInterface
     */
    private $serviceLocatorMock;

/**
     * @var MockObject|DeploymentConfig
     */
    private $deploymentConfig;

/**
     * @var Navigation
     */
    private $navigation;

protected function setUp(): void
    {
        $this->serviceLocatorMock =
            $this->getMockBuilder(ServiceLocatorInterface::class)
                ->onlyMethods(['get'])
                ->getMockForAbstractClass();
        $this->serviceLocatorMock
            ->expects($this->exactly(2))
            ->method('get')
            ->with('config')
            ->willReturn(
                [
                    'navLandingTitles' => [
                        'install' => 'SomeTitle'
                    ],
                    'navLanding' => [
                        ['key1' => 'value1'],
                        ['key2' => 'value2'],
                        ['nav' => 'abc', 'key3' => 'value3'],
                        ['nav' => ''],
                        ['nav' => false],
                        ['main' => 'abc', 'key3' => 'value3'],
                        ['main' => ''],
                        ['main' => false],
                    ]
                ]
            );
        $this->deploymentConfig = $this->createMock(DeploymentConfig::class);
        $this->navigation = new Navigation($this->serviceLocatorMock, $this->deploymentConfig);
    }

public function testGetType()
    {
        $this->assertEquals(Navigation::NAV_LANDING, $this->navigation->getType());
    }

public function testGetData()
    {
        $this->assertEquals(
            [
                ['key1' => 'value1'],
                ['key2' => 'value2'],
                ['nav' => 'abc', 'key3' => 'value3'],
                ['nav' => ''],
                ['nav' => false],
                ['main' => 'abc', 'key3' => 'value3'],
                ['main' => ''],
                ['main' => false],
            ],
            $this->navigation->getData()
        );
    }

public function testGetMenuItems()
    {
        $this->assertEquals(
            [['nav' => 'abc', 'key3' => 'value3']],
            $this->navigation->getMenuItems()
        );
    }

public function testGetMainItems()
 {
 $this->assertEquals([['main' => 'abc', 'key3' => 'value3']], array_values($this->navigation->getMainItems()));
 }
}
Magento/Setup/Test/Unit/Model/ConfigModelTest.php000077700000013636151323623130015712 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

namespace Magento\Setup\Test\Unit\Model;

use Magento\Backend\Setup\ConfigOptionsList;
use Magento\Framework\App\DeploymentConfig;
use Magento\Framework\App\DeploymentConfig\Writer;
use Magento\Framework\Config\Data\ConfigData;
use Magento\Framework\Config\File\ConfigFilePool;
use Magento\Framework\Setup\FilePermissions;
use Magento\Framework\Setup\Option\TextConfigOption;
use Magento\Setup\Model\ConfigModel;
use Magento\Setup\Model\ConfigOptionsListCollector;
use PHPUnit\Framework\MockObject\MockObject;
use PHPUnit\Framework\TestCase;

class ConfigModelTest extends TestCase
{
    /**
     * @var MockObject|ConfigModel
     */
    private $configModel;

/**
     * @var MockObject|ConfigOptionsListCollector
     */
    private $collector;

/**
     * @var MockObject|Writer
     */
    private $writer;

/**
     * @var MockObject|DeploymentConfig
     */
    private $deploymentConfig;

/**
     * @var MockObject|ConfigData
     */
    private $configData;

/**
     * @var MockObject|FilePermissions
     */
    private $filePermissions;

/**
     * @var MockObject|ConfigOptionsList
     */
    private $configOptionsList;

protected function setUp(): void
    {
        $this->collector = $this->createMock(ConfigOptionsListCollector::class);
        $this->writer = $this->createMock(Writer::class);
        $this->deploymentConfig = $this->createMock(DeploymentConfig::class);
        $this->configOptionsList = $this->createMock(ConfigOptionsList::class);
        $this->configData = $this->createMock(ConfigData::class);
        $this->filePermissions = $this->createMock(FilePermissions::class);

$this->deploymentConfig->expects($this->any())->method('get');

$this->configModel = new ConfigModel(
            $this->collector,
            $this->writer,
            $this->deploymentConfig,
            $this->filePermissions
        );
    }

public function testValidate()
    {
        $option = $this->createMock(TextConfigOption::class);
        $option->expects($this->exactly(3))->method('getName')->willReturn('Fake');
        $optionsSet = [
            $option,
            $option,
            $option
        ];
        $configOption = $this->configOptionsList;
        $configOption->expects($this->once())->method('getOptions')->willReturn($optionsSet);
        $configOption->expects($this->once())->method('validate')->willReturn([]);

$this->collector
            ->expects($this->exactly(2))
            ->method('collectOptionsLists')
            ->willReturn([$configOption]);

$this->configModel->validate(['Fake' => null]);
    }

public function testProcess()
    {
        $testSet1 = [
            ConfigFilePool::APP_CONFIG => [
                'segment' => [
                    'someKey' => 'value',
                    'test' => 'value1'
                ]
            ]
        ];

$testSet2 = [
            ConfigFilePool::APP_CONFIG => [
                'segment' => [
                    'test' => 'value2'
                ]
            ]
        ];

$testSetExpected1 = [
            ConfigFilePool::APP_CONFIG => [
                'segment' => [
                    'someKey' => 'value',
                    'test' => 'value1'
                ]
            ]
        ];

$testSetExpected2 = [
            ConfigFilePool::APP_CONFIG => [
                'segment' => [
                    'test' => 'value2'
                ]
            ]
        ];

$configData1 = clone $this->configData;
        $configData2 = clone $this->configData;

$configData1->expects($this->any())
            ->method('getData')
            ->willReturn($testSet1[ConfigFilePool::APP_CONFIG]);
        $configData1->expects($this->any())->method('getFileKey')->willReturn(ConfigFilePool::APP_CONFIG);
        $configData1->expects($this->once())->method('isOverrideWhenSave')->willReturn(false);

$configData2->expects($this->any())
            ->method('getData')
            ->willReturn($testSet2[ConfigFilePool::APP_CONFIG]);
        $configData2->expects($this->any())->method('getFileKey')->willReturn(ConfigFilePool::APP_CONFIG);
        $configData2->expects($this->once())->method('isOverrideWhenSave')->willReturn(false);

$configOption = $this->configOptionsList;
        $configOption->expects($this->once())
            ->method('createConfig')
            ->willReturn([$configData1, $configData2]);

$configOptionsList = [
            'Fake_Module' => $configOption
        ];
        $this->collector->expects($this->once())
            ->method('collectOptionsLists')
            ->willReturn($configOptionsList);

$this->writer->expects($this->at(0))->method('saveConfig')->with($testSetExpected1);
        $this->writer->expects($this->at(1))->method('saveConfig')->with($testSetExpected2);

$this->configModel->process([]);
    }

public function testProcessException()
    {
        $this->expectException('Exception');
        $this->expectExceptionMessage('In module : Fake_ModuleConfigOption::createConfig');
        $configOption = $this->configOptionsList;
        $configOption->expects($this->once())
            ->method('createConfig')
            ->willReturn([null]);

$wrongData = [
            'Fake_Module' => $configOption
        ];

$this->collector->expects($this->once())->method('collectOptionsLists')->willReturn($wrongData);

$this->configModel->process([]);
    }

public function testWritePermissionErrors()
 {
 $this->expectException('Exception');
 $this->expectExceptionMessage('Missing write permissions to the following paths:');
 $this->filePermissions->expects($this->once())->method('getMissingWritablePathsForInstallation')
 ->willReturn(['/a/ro/dir', '/media']);
 $this->configModel->process([]);
 }
}
Magento/Setup/Test/Unit/Model/SearchTermManagerTest.php000077700000003651151323623130017050 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

namespace Magento\Setup\Test\Unit\Model;

use Magento\Setup\Model\SearchTermManager;
use PHPUnit\Framework\TestCase;

class SearchTermManagerTest extends TestCase
{
    /**
     * @var SearchTermManager
     */
    private $searchTermManager;

/**
     * @var int
     */
    private $totalProductsCount = 150;

/**
     * @var array
     */
    private $searchTermConfiguration = [
        [
            'term' => 'x-wing',
            'count' => '33'
        ], [
            'term' => 'tie-fighter',
            'count' => '100'
        ], [
            'term' => 'n-1 starfighter',
            'count' => '42'
        ],
    ];

/**
     * @var array
     */
    private $searchTermsUsage = [
        'x-wing' => [
            'used' => 0
        ],
        'tie-fighter' => [
            'used' => 0
        ],
        'n-1 starfighter' => [
            'used' => 0
        ]
    ];

protected function setUp(): void
    {
        $this->searchTermManager = new SearchTermManager(
            $this->searchTermConfiguration,
            $this->totalProductsCount
        );
    }

public function testSearchTermApplied()
 {
 for ($productIndex=1; $productIndex<=$this->totalProductsCount; $productIndex++) {
 $description = 'Fleet: ';
 $this->searchTermManager->applySearchTermsToDescription($description, $productIndex);

foreach (array_keys($this->searchTermsUsage) as $searchTerm) {
                if (preg_match("/\\b$searchTerm\\b/", $description)) {
                    $this->searchTermsUsage[$searchTerm]['used']++;
                }
            }
        }

foreach ($this->searchTermConfiguration as $searchTerm) {
 $this->assertEquals($searchTerm['count'], $this->searchTermsUsage[$searchTerm['term']]['used']);
 }
 }
}
Magento/Setup/Test/Unit/Model/DataGeneratorTest.php000077700000002622151323623130016235 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

namespace Magento\Setup\Test\Unit\Model;

use Magento\Setup\Model\DataGenerator;
use PHPUnit\Framework\TestCase;

class DataGeneratorTest extends TestCase
{
    const PATH_TO_CSV_FILE = '/_files/dictionary.csv';

/**
     * @test
     *
     * @return void
     */
    public function testGenerate()
    {
        $data = file(__DIR__ . self::PATH_TO_CSV_FILE);
        $wordCount = count($data);
        $model = new DataGenerator(__DIR__ . self::PATH_TO_CSV_FILE);
        $result = $model->generate($wordCount, $wordCount);

$found = false;
        foreach ($data as $word) {
            $found = (strpos($result, $word[0]) !== false) || $found;
        }
        $this->assertTrue($found);
        $this->assertCount($wordCount, explode(" ", $result));
    }

public function testGenerateWithKey()
    {
        $key = 'generate-test';

$data = file(__DIR__ . self::PATH_TO_CSV_FILE);
        $wordCount = random_int(1, count($data));
        $model = new DataGenerator(__DIR__ . self::PATH_TO_CSV_FILE);
        $result = $model->generate($wordCount, $wordCount, $key);

$foundResult = $model->generate($wordCount, $wordCount, $key);

$this->assertCount($wordCount, explode(" ", $result));
 $this->assertEquals($result, $foundResult);
 }
}
Magento/Setup/Test/Unit/Model/ConfigOptionsListTest.php000077700000023245151323623130017136 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

namespace Magento\Setup\Test\Unit\Model;

use Magento\Framework\App\DeploymentConfig;
use Magento\Framework\Config\ConfigOptionsListConstants;
use Magento\Framework\Config\Data\ConfigData;
use Magento\Framework\Encryption\KeyValidator;
use Magento\Framework\Setup\Option\FlagConfigOption;
use Magento\Framework\Setup\Option\TextConfigOption;
use Magento\Setup\Model\ConfigGenerator;
use Magento\Setup\Model\ConfigOptionsList;
use Magento\Setup\Model\ConfigOptionsList\DriverOptions;
use Magento\Setup\Model\ConfigOptionsList\Lock;
use Magento\Setup\Validator\DbValidator;
use PHPUnit\Framework\MockObject\MockObject;
use PHPUnit\Framework\TestCase;

/**
 * @SuppressWarnings(PHPMD.CouplingBetweenObjects)
 */
class ConfigOptionsListTest extends TestCase
{
    /**
     * @var ConfigOptionsList
     */
    private $object;

/**
     * @var ConfigGenerator|MockObject
     */
    private $generator;

/**
     * @var MockObject|DeploymentConfig
     */
    private $deploymentConfig;

/**
     * @var DbValidator|MockObject
     */
    private $dbValidator;

/**
     * @var KeyValidator|MockObject
     */
    private $encryptionKeyValidator;

/**
     * @var ConfigOptionsList\DriverOptions
     */
    private $driverOptionsMock;

protected function setUp(): void
    {
        $this->generator = $this->createMock(ConfigGenerator::class);
        $this->deploymentConfig = $this->createMock(DeploymentConfig::class);
        $this->dbValidator = $this->createMock(DbValidator::class);
        $this->encryptionKeyValidator = $this->createMock(KeyValidator::class);
        $this->driverOptionsMock = $this->createMock(DriverOptions::class);
        $this->object = new ConfigOptionsList(
            $this->generator,
            $this->dbValidator,
            $this->encryptionKeyValidator,
            $this->driverOptionsMock
        );
    }

public function testGetOptions()
    {
        $options = $this->object->getOptions();
        $this->assertInstanceOf(TextConfigOption::class, $options[0]);
        $this->assertSame('Encryption key', $options[0]->getDescription());
        $this->assertInstanceOf(TextConfigOption::class, $options[1]);
        $this->assertSame('Database server host', $options[1]->getDescription());
        $this->assertInstanceOf(TextConfigOption::class, $options[2]);
        $this->assertSame('Database name', $options[2]->getDescription());
        $this->assertInstanceOf(TextConfigOption::class, $options[3]);
        $this->assertSame('Database server username', $options[3]->getDescription());
        $this->assertInstanceOf(TextConfigOption::class, $options[4]);
        $this->assertSame('Database server engine', $options[4]->getDescription());
        $this->assertInstanceOf(TextConfigOption::class, $options[5]);
        $this->assertSame('Database server password', $options[5]->getDescription());
        $this->assertInstanceOf(TextConfigOption::class, $options[6]);
        $this->assertSame('Database table prefix', $options[6]->getDescription());
        $this->assertInstanceOf(TextConfigOption::class, $options[7]);
        $this->assertSame('Database type', $options[7]->getDescription());
        $this->assertInstanceOf(TextConfigOption::class, $options[8]);
        $this->assertSame('Database  initial set of commands', $options[8]->getDescription());
        $this->assertInstanceOf(FlagConfigOption::class, $options[9]);
        $this->assertSame(
            'If specified, then db connection validation will be skipped',
            $options[9]->getDescription()
        );
        $this->assertInstanceOf(TextConfigOption::class, $options[10]);
        $this->assertSame('http Cache hosts', $options[10]->getDescription());
        $this->assertGreaterThanOrEqual(11, count($options));
    }

public function testCreateOptions()
    {
        $configDataMock = $this->createMock(ConfigData::class);
        $this->generator->expects($this->once())->method('createCryptConfig')->willReturn($configDataMock);
        $this->generator->expects($this->once())->method('createDefinitionsConfig')->willReturn($configDataMock);
        $this->generator->expects($this->once())->method('createDbConfig')->willReturn($configDataMock);
        $this->generator->expects($this->once())->method('createResourceConfig')->willReturn($configDataMock);
        $this->generator->expects($this->once())->method('createXFrameConfig')->willReturn($configDataMock);
        $this->generator->expects($this->once())->method('createCacheHostsConfig')->willReturn($configDataMock);

$configData = $this->object->createConfig([Lock::INPUT_KEY_LOCK_PROVIDER => 'db'], $this->deploymentConfig);
        $this->assertGreaterThanOrEqual(6, count($configData));
    }

public function testCreateOptionsWithOptionalNull()
    {
        $configDataMock = $this->createMock(ConfigData::class);
        $this->generator->expects($this->once())->method('createCryptConfig')->willReturn($configDataMock);
        $this->generator->expects($this->once())->method('createDefinitionsConfig')->willReturn(null);
        $this->generator->expects($this->once())->method('createDbConfig')->willReturn($configDataMock);
        $this->generator->expects($this->once())->method('createResourceConfig')->willReturn($configDataMock);
        $this->generator->expects($this->once())->method('createXFrameConfig')->willReturn($configDataMock);
        $this->generator->expects($this->once())->method('createCacheHostsConfig')->willReturn($configDataMock);

$configData = $this->object->createConfig([Lock::INPUT_KEY_LOCK_PROVIDER => 'db'], $this->deploymentConfig);
        $this->assertGreaterThanOrEqual(6, count($configData));
    }

public function testValidateSuccess()
    {
        $options = [
            ConfigOptionsListConstants::INPUT_KEY_DB_PREFIX => 'prefix',
            ConfigOptionsListConstants::INPUT_KEY_SESSION_SAVE => 'files',
            ConfigOptionsListConstants::INPUT_KEY_SKIP_DB_VALIDATION => false,
            ConfigOptionsListConstants::INPUT_KEY_DB_NAME => 'name',
            ConfigOptionsListConstants::INPUT_KEY_DB_HOST => 'host',
            ConfigOptionsListConstants::INPUT_KEY_DB_USER => 'user',
            ConfigOptionsListConstants::INPUT_KEY_DB_PASSWORD => 'pass',
            Lock::INPUT_KEY_LOCK_PROVIDER => 'db'
        ];
        $this->prepareValidationMocks();

$this->assertEquals([], $this->object->validate($options, $this->deploymentConfig));
    }

public function testValidateInvalidSessionHandler()
    {
        $invalidSaveHandler = 'clay-tablet';

$options = [
            ConfigOptionsListConstants::INPUT_KEY_DB_PREFIX => 'prefix',
            ConfigOptionsListConstants::INPUT_KEY_SESSION_SAVE => $invalidSaveHandler,
            ConfigOptionsListConstants::INPUT_KEY_SKIP_DB_VALIDATION => false,
            ConfigOptionsListConstants::INPUT_KEY_DB_NAME => 'name',
            ConfigOptionsListConstants::INPUT_KEY_DB_HOST => 'host',
            ConfigOptionsListConstants::INPUT_KEY_DB_USER => 'user',
            ConfigOptionsListConstants::INPUT_KEY_DB_PASSWORD => 'pass',
            Lock::INPUT_KEY_LOCK_PROVIDER => 'db'
        ];
        $this->prepareValidationMocks();

$this->assertEquals(
            ["Invalid session handler '{$invalidSaveHandler}'"],
            $this->object->validate($options, $this->deploymentConfig)
        );
    }

public function testValidateEmptyEncryptionKey()
    {
        $options = [
            ConfigOptionsListConstants::INPUT_KEY_SKIP_DB_VALIDATION => true,
            ConfigOptionsListConstants::INPUT_KEY_ENCRYPTION_KEY => '',
            Lock::INPUT_KEY_LOCK_PROVIDER => 'db'
        ];
        $this->assertEquals(
            ['Invalid encryption key. Encryption key must be 32 character string without any white space.'],
            $this->object->validate($options, $this->deploymentConfig)
        );
    }

private function prepareValidationMocks()
    {
        $configDataMock = $this->getMockBuilder(ConfigData::class)
            ->disableOriginalConstructor()
            ->getMock();
        $this->dbValidator->expects($this->once())->method('checkDatabaseTablePrefix')->willReturn($configDataMock);
        $this->dbValidator->expects($this->once())
            ->method('checkDatabaseConnectionWithDriverOptions')
            ->willReturn($configDataMock);
        $this->dbValidator
            ->expects($this->once())
            ->method('checkDatabaseConnectionWithDriverOptions')
            ->willReturn($configDataMock);
    }

/**
     * @param string $hosts
     * @param bool $expectedError
     * @dataProvider validateCacheHostsDataProvider
     */
    public function testValidateCacheHosts($hosts, $expectedError)
    {
        $options = [
            ConfigOptionsListConstants::INPUT_KEY_SKIP_DB_VALIDATION => true,
            ConfigOptionsListConstants::INPUT_KEY_CACHE_HOSTS => $hosts,
            Lock::INPUT_KEY_LOCK_PROVIDER => 'db'
        ];
        $result = $this->object->validate($options, $this->deploymentConfig);
        if ($expectedError) {
            $this->assertCount(1, $result);
            $this->assertEquals("Invalid http cache hosts '$hosts'", $result[0]);
        } else {
            $this->assertCount(0, $result);
        }
    }

/**
 * @return array
 */
 public function validateCacheHostsDataProvider()
 {
 return [
 ['localhost', false],
 ['122.11.2.34:800', false],
 ['122.11.2.34:800,localhost', false],
 ['website.com:9000', false],
 ['web-site.com:9000', false],
 ['website.com/m2ce:9000', true],
 ['website.com+:9000', true],
 ];
 }
}
Magento/Setup/Test/Unit/Model/ModuleContextTest.php000077700000000732151323623130016307 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

namespace Magento\Setup\Test\Unit\Model;

use Magento\Setup\Model\ModuleContext;
use PHPUnit\Framework\TestCase;

class ModuleContextTest extends TestCase
{
 public function testGetVersion()
 {
 $version = '1.0.1';
 $object = new ModuleContext($version);
 $this->assertSame($version, $object->getVersion());
 }
}
Magento/Setup/Test/Unit/Fixtures/TaxRulesFixtureTest.php000077700000007265151323623130017414 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

namespace Magento\Setup\Test\Unit\Fixtures;

use Magento\Framework\App\Config\Storage\Writer as ConfigWriter;
use Magento\Setup\Fixtures\FixtureModel;
use Magento\Setup\Fixtures\TaxRulesFixture;
use Magento\Tax\Api\Data\TaxRateInterfaceFactory;
use Magento\Tax\Api\Data\TaxRuleInterfaceFactory;
use Magento\Tax\Api\TaxRateRepositoryInterface;
use Magento\Tax\Api\TaxRuleRepositoryInterface;
use Magento\Tax\Model\ResourceModel\Calculation\Rate\CollectionFactory;
use PHPUnit\Framework\MockObject\MockObject;
use PHPUnit\Framework\TestCase;

/**
 * @SuppressWarnings(PHPMD.CouplingBetweenObjects)
 */
class TaxRulesFixtureTest extends TestCase
{

/**
     * @var MockObject|FixtureModel
     */
    private $fixtureModelMock;

/**
     * @var TaxRulesFixture
     */
    private $model;

/**
     * @var ConfigWriter
     */
    private $configWriterMock;

/**
     * @var TaxRateInterfaceFactory
     */
    private $taxRateRepositoryMock;

/**
     * @var
     */
    private $taxRateFactoryMock;

/**
     * @var CollectionFactory
     */
    private $taxRateCollectionFactoryMock;

/**
     * @var TaxRuleInterfaceFactory
     */
    private $taxRuleFactoryMock;

/**
     * @var TaxRuleRepositoryInterface
     */
    private $taxRuleRepositoryMock;

public function testExecute()
    {
        $this->fixtureModelMock = $this->getMockBuilder(FixtureModel::class)
            ->disableOriginalConstructor()
            ->getMock();

$this->taxRateFactoryMock = $this->getMockBuilder(TaxRateInterfaceFactory::class)
            ->disableOriginalConstructor()
            ->getMock();

$this->taxRateRepositoryMock = $this->getMockBuilder(TaxRateRepositoryInterface::class)
            ->disableOriginalConstructor()
            ->getMockForAbstractClass();

$this->configWriterMock = $this->getMockBuilder(ConfigWriter::class)
            ->disableOriginalConstructor()
            ->getMock();

$this->taxRuleFactoryMock = $this->getMockBuilder(TaxRuleInterfaceFactory::class)
            ->disableOriginalConstructor()
            ->getMock();

$this->taxRuleRepositoryMock = $this->getMockBuilder(TaxRuleRepositoryInterface::class)
            ->disableOriginalConstructor()
            ->setMethods(['save', 'get', 'delete', 'deleteById', 'getList'])
            ->getMockForAbstractClass();

$this->fixtureModelMock
            ->expects($this->exactly(2))
            ->method('getValue')
            ->willReturnMap([
                ['tax_mode', 'VAT'],
                ['tax_rules', 2]
            ]);

$this->taxRateCollectionFactoryMock = $this->getMockBuilder(CollectionFactory::class)
            ->disableOriginalConstructor()
            ->setMethods(['create'])
            ->getMock();

$taxRateCollectionMock = $this->getMockBuilder(Collection::class)
            ->disableOriginalConstructor()
            ->setMethods(['getAllIds'])
            ->getMock();

$this->taxRateCollectionFactoryMock->expects($this->once())
            ->method('create')
            ->willReturn($taxRateCollectionMock);

$taxRateCollectionMock->expects($this->once())
            ->method('getAllIds')
            ->willReturn([1]);

$this->model = new TaxRulesFixture(
            $this->fixtureModelMock,
            $this->taxRuleRepositoryMock,
            $this->taxRuleFactoryMock,
            $this->taxRateCollectionFactoryMock,
            $this->taxRateFactoryMock,
            $this->taxRateRepositoryMock,
            $this->configWriterMock
        );

$this->model->execute();
 }
}
Magento/Setup/Test/Unit/Fixtures/CustomersFixtureTest.php000077700000010234151323623130017617 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

namespace Magento\Setup\Test\Unit\Fixtures;

use Magento\Customer\Model\ResourceModel\Customer\Collection;
use Magento\Framework\TestFramework\Unit\Helper\ObjectManager;
use Magento\Setup\Fixtures\CustomersFixture;
use Magento\Setup\Fixtures\FixtureModel;
use Magento\Setup\Model\Customer\CustomerDataGenerator;
use Magento\Setup\Model\Customer\CustomerDataGeneratorFactory;
use Magento\Setup\Model\FixtureGenerator\CustomerGenerator;
use PHPUnit\Framework\MockObject\MockObject;
use PHPUnit\Framework\TestCase;

class CustomersFixtureTest extends TestCase
{
    /**
     * @var MockObject|FixtureModel
     */
    private $fixtureModelMock;

/**
     * @var MockObject|CustomerGenerator
     */
    private $customerGeneratorMock;

/**
     * @var MockObject|CustomerDataGeneratorFactory
     */
    private $customerDataGeneratorFactoryMock;

/**
     * @var CustomersFixture
     */
    private $model;

/**
     * @var MockObject
     */
    private $collectionFactoryMock;

/**
     * @var MockObject
     */
    private $collectionMock;

protected function setUp(): void
    {
        $this->fixtureModelMock = $this->createMock(FixtureModel::class);

$this->customerGeneratorMock =
            $this->createMock(CustomerGenerator::class);

$this->customerDataGeneratorFactoryMock =
            $this->createMock(CustomerDataGeneratorFactory::class);

$this->collectionFactoryMock =
            $this->createPartialMock(
                \Magento\Customer\Model\ResourceModel\Customer\CollectionFactory::class,
                ['create']
            );

$this->collectionMock = $this->createMock(Collection::class);

$this->model = (new ObjectManager($this))->getObject(CustomersFixture::class, [
            'fixtureModel' => $this->fixtureModelMock,
            'customerGenerator' => $this->customerGeneratorMock,
            'customerDataGeneratorFactory' => $this->customerDataGeneratorFactoryMock,
            'collectionFactory' => $this->collectionFactoryMock
        ]);
    }

public function testExecute()
    {
        $entitiesInDB = 20;
        $this->collectionFactoryMock->expects($this->once())->method('create')->willReturn($this->collectionMock);
        $this->collectionMock->expects($this->once())->method('getSize')->willReturn($entitiesInDB);

$customersNumber = 100500;
        $customerConfig = [
            'some-key' => 'some value'
        ];

$this->fixtureModelMock
            ->expects($this->exactly(2))
            ->method('getValue')
            ->will($this->onConsecutiveCalls($customersNumber, $customerConfig));

$customerDataGeneratorMock = $this->createMock(CustomerDataGenerator::class);

$this->customerDataGeneratorFactoryMock
            ->expects($this->once())
            ->method('create')
            ->with($customerConfig)
            ->willReturn($customerDataGeneratorMock);

$this->customerGeneratorMock
            ->expects($this->once())
            ->method('generate')
            ->with(
                $customersNumber - $entitiesInDB,
                $this->arrayHasKey('customer_data')
            );

$this->model->execute();
    }

public function testDoNoExecuteIfCustomersAlreadyGenerated()
    {
        $this->collectionFactoryMock->expects($this->once())->method('create')->willReturn($this->collectionMock);
        $this->collectionMock->expects($this->once())->method('getSize')->willReturn(20);
        $this->fixtureModelMock
            ->expects($this->once())
            ->method('getValue')
            ->willReturn(20);
        $this->customerDataGeneratorFactoryMock->expects($this->never())->method('create');

$this->model->execute();
    }

public function testGetActionTitle()
    {
        $this->assertSame('Generating customers', $this->model->getActionTitle());
    }

public function testIntroduceParamLabels()
 {
 $this->assertSame(
 [
 'customers' => 'Customers'
 ],
 $this->model->introduceParamLabels()
 );
 }
}
Magento/Setup/Test/Unit/Fixtures/AttributeSetsFixtureTest.php000077700000006422151323623130020441 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

namespace Magento\Setup\Test\Unit\Fixtures;

use Magento\Setup\Fixtures\AttributeSet\AttributeSetFixture;
use Magento\Setup\Fixtures\AttributeSet\Pattern;
use Magento\Setup\Fixtures\AttributeSetsFixture;
use Magento\Setup\Fixtures\FixtureModel;
use PHPUnit\Framework\MockObject\MockObject;
use PHPUnit\Framework\TestCase;

/**
 * @SuppressWarnings(PHPMD)
 */
class AttributeSetsFixtureTest extends TestCase
{
    /**
     * @var MockObject|FixtureModel
     */
    private $fixtureModelMock;

/**
     * @var AttributeSetsFixture
     */
    private $model;

/**
     * @var MockObject
     */
    private $attributeSetsFixtureMock;

/**
     * @var MockObject
     */
    private $patternMock;

protected function setUp(): void
    {
        $this->fixtureModelMock = $this->getMockBuilder(FixtureModel::class)
            ->disableOriginalConstructor()
            ->getMock();
        $this->attributeSetsFixtureMock = $this->getMockBuilder(AttributeSetFixture::class)
            ->disableOriginalConstructor()
            ->getMock();
        $this->patternMock = $this->getMockBuilder(Pattern::class)
            ->disableOriginalConstructor()
            ->getMock();

$this->model = new AttributeSetsFixture(
            $this->fixtureModelMock,
            $this->attributeSetsFixtureMock,
            $this->patternMock
        );
    }

public function testCreateAttributeSet()
    {
        $valueMap = [
            ['attribute_sets', null, ['attribute_set' => [['some-data']]]],
            ['product_attribute_sets', null, null],
        ];

$this->attributeSetsFixtureMock->expects($this->once())
            ->method('createAttributeSet')
            ->with(['some-data']);
        $this->fixtureModelMock
            ->expects($this->exactly(2))
            ->method('getValue')
            ->willReturnMap($valueMap);

$this->model->execute();
    }

public function testCreateProductAttributeSet()
    {
        $valueMap = [
            ['attribute_sets', null, null],
            ['product_attribute_sets', null, 1],
            ['product_attribute_sets_attributes', 3, 2],
            ['product_attribute_sets_attributes_values', 3, 3],
        ];

$closure = function () {
        };
        $this->patternMock->expects($this->once())
            ->method('generateAttributeSet')
            ->with(AttributeSetsFixture::PRODUCT_SET_NAME . 1, 2, 3, $closure)
            ->willReturn(['some-data']);
        $this->attributeSetsFixtureMock->expects($this->once())
            ->method('createAttributeSet')
            ->with(['some-data']);
        $this->fixtureModelMock
            ->expects($this->exactly(4))
            ->method('getValue')
            ->willReturnMap($valueMap);

$this->model->execute();
    }

public function testGetActionTitle()
    {
        $this->assertSame('Generating attribute sets', $this->model->getActionTitle());
    }

public function testIntroduceParamLabels()
 {
 $this->assertSame([
 'attribute_sets' => 'Attribute Sets (Default)',
 'product_attribute_sets' => 'Attribute Sets (Extra)'
 ], $this->model->introduceParamLabels());
 }
}
Magento/Setup/Test/Unit/Fixtures/CartPriceRulesFixtureTest.php000077700000022643151323623130020531 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

namespace Magento\Setup\Test\Unit\Fixtures;

use Magento\Catalog\Model\Category;
use Magento\Framework\Model\ResourceModel\Db\AbstractDb;
use Magento\Framework\Model\ResourceModel\Db\Context;
use Magento\Framework\ObjectManager\ObjectManager;
use Magento\SalesRule\Model\Rule;
use Magento\SalesRule\Model\Rule\Condition\Address;
use Magento\SalesRule\Model\Rule\Condition\Combine;
use Magento\SalesRule\Model\Rule\Condition\Product;
use Magento\SalesRule\Model\Rule\Condition\Product\Found;
use Magento\Setup\Fixtures\CartPriceRulesFixture;
use Magento\Setup\Fixtures\FixtureModel;
use Magento\Store\Model\Store;
use Magento\Store\Model\StoreManager;
use Magento\Store\Model\Website;
use PHPUnit\Framework\MockObject\MockObject;
use PHPUnit\Framework\TestCase;

/**
 * @SuppressWarnings(PHPMD.CouplingBetweenObjects)
 */
class CartPriceRulesFixtureTest extends TestCase
{
    /**
     * @var MockObject|FixtureModel
     */
    private $fixtureModelMock;

/**
     * @var CartPriceRulesFixture
     */
    private $model;

/**
     * @var \Magento\SalesRule\Model\RuleFactory|MockObject
     */
    private $ruleFactoryMock;

protected function setUp(): void
    {
        $this->fixtureModelMock = $this->createMock(FixtureModel::class);
        $this->ruleFactoryMock = $this->createPartialMock(\Magento\SalesRule\Model\RuleFactory::class, ['create']);
        $this->model = new CartPriceRulesFixture($this->fixtureModelMock, $this->ruleFactoryMock);
    }

public function testExecute()
    {
        $storeMock = $this->createMock(Store::class);
        $storeMock->expects($this->once())
            ->method('getRootCategoryId')
            ->willReturn(2);

$websiteMock = $this->createMock(Website::class);
        $websiteMock->expects($this->once())
            ->method('getGroups')
            ->willReturn([$storeMock]);
        $websiteMock->expects($this->once())
            ->method('getId')
            ->willReturn('website_id');

$contextMock = $this->createMock(Context::class);
        $abstractDbMock = $this->getMockForAbstractClass(
            AbstractDb::class,
            [$contextMock],
            '',
            true,
            true,
            true,
            ['getAllChildren']
        );
        $abstractDbMock->expects($this->once())
            ->method('getAllChildren')
            ->willReturn([1]);

$storeManagerMock = $this->createMock(StoreManager::class);
        $storeManagerMock->expects($this->once())
            ->method('getWebsites')
            ->willReturn([$websiteMock]);

$categoryMock = $this->createMock(Category::class);
        $categoryMock->expects($this->once())
            ->method('getResource')
            ->willReturn($abstractDbMock);
        $categoryMock->expects($this->once())
            ->method('getPath')
            ->willReturn('path/to/file');
        $categoryMock->expects($this->once())
            ->method('getId')
            ->willReturn('category_id');

$objectValueMap = [
            [Category::class, $categoryMock]
        ];

$objectManagerMock = $this->createMock(ObjectManager::class);
        $objectManagerMock->expects($this->once())
            ->method('create')
            ->willReturn($storeManagerMock);
        $objectManagerMock->expects($this->once())
            ->method('get')
            ->willReturnMap($objectValueMap);

$valueMap = [
            ['cart_price_rules', 0, 1],
            ['cart_price_rules_floor', 3, 3],
            ['cart_price_rules_advanced_type', false, false]
        ];

$this->fixtureModelMock
            ->expects($this->exactly(3))
            ->method('getValue')
            ->willReturnMap($valueMap);
        $this->fixtureModelMock
            ->expects($this->exactly(2))
            ->method('getObjectManager')
            ->willReturn($objectManagerMock);

$ruleMock = $this->createMock(Rule::class);
        $this->ruleFactoryMock->expects($this->once())
            ->method('create')
            ->willReturn($ruleMock);

$this->model->execute();
    }

public function testNoFixtureConfigValue()
    {
        $ruleMock = $this->createMock(Rule::class);
        $ruleMock->expects($this->never())->method('save');

$objectManagerMock = $this->createMock(ObjectManager::class);
        $objectManagerMock->expects($this->never())
            ->method('get')
            ->with(Rule::class)
            ->willReturn($ruleMock);

$this->fixtureModelMock
            ->expects($this->never())
            ->method('getObjectManager')
            ->willReturn($objectManagerMock);
        $this->fixtureModelMock
            ->expects($this->once())
            ->method('getValue')
            ->willReturn(false);

$this->model->execute();
    }

/**
     * @param int $ruleId
     * @param array $categoriesArray
     * @param int $ruleCount
     * @dataProvider dataProviderGenerateAdvancedCondition
     */
    public function testGenerateAdvancedCondition($ruleId, $categoriesArray, $ruleCount)
    {
        $reflection = new \ReflectionClass($this->model);
        $reflectionProperty = $reflection->getProperty('cartPriceRulesCount');
        $reflectionProperty->setAccessible(true);
        $reflectionProperty->setValue($this->model, $ruleCount);

$result = $this->model->generateAdvancedCondition($ruleId, $categoriesArray);
 if ($ruleId < ($ruleCount - 200)) {
 $firstCondition = [
 'type' => Product::class,
 'attribute' => 'category_ids',
 'operator' => '==',
 'value' => 0,
 ];

$secondCondition = [
                'type' => Address::class,
                'attribute' => 'base_subtotal',
                'operator' => '>=',
                'value' => 5,
            ];
            $expected = [
                'conditions' => [
                    1 => [
                        'type' => Combine::class,
                        'aggregator' => 'all',
                        'value' => '1',
                        'new_child' => '',
                    ],
                    '1--1' => [
                        'type' => Found::class,
                        'aggregator' => 'all',
                        'value' => '1',
                        'new_child' => '',
                    ],
                    '1--1--1' => $firstCondition,
                    '1--2' => $secondCondition
                ],
                'actions' => [
                    1 => [
                        'type' => \Magento\SalesRule\Model\Rule\Condition\Product\Combine::class,
                        'aggregator' => 'all',
                        'value' => '1',
                        'new_child' => '',
                    ],
                ]
            ];
        } else {
            // Shipping Region
            $regions = ['Alabama', 'Alaska', 'Arizona', 'Arkansas', 'California', 'Colorado', 'Connecticut',
                'Delaware', 'District of Columbia', 'Florida', 'Georgia', 'Hawaii', 'Idaho', 'Illinois',
                'Indiana', 'Iowa', 'Kansas', 'Kentucky', 'Louisiana', 'Maine', 'Maryland', 'Massachusetts',
                'Michigan', 'Minnesota', 'Mississippi', 'Missouri', 'Montana', 'Nebraska', 'Nevada',
                'New Hampshire', 'New Jersey', 'New Mexico', 'New York', 'North Carolina', 'North Dakota',
                'Ohio', 'Oklahoma', 'Oregon', 'Pennsylvania', 'Rhode Island', 'South Carolina', 'South Dakota',
                'Tennessee', 'Texas', 'Utah', 'Vermont', 'Virginia', 'Washington', 'West Virginia',
                'Wisconsin', 'Wyoming'];
            $firstCondition = [
                'type' => Address::class,
                'attribute' => 'region',
                'operator' => '==',
                'value' => $regions[($ruleId / 4) % 50],
            ];

$secondCondition = [
                'type' => Address::class,
                'attribute' => 'base_subtotal',
                'operator' => '>=',
                'value' => 5,
            ];
            $expected = [
                'conditions' => [
                    1 => [
                        'type' => Combine::class,
                        'aggregator' => 'all',
                        'value' => '1',
                        'new_child' => '',
                    ],
                    '1--1' => $firstCondition,
                    '1--2' => $secondCondition
                ],
                'actions' => [
                    1 => [
                        'type' => \Magento\SalesRule\Model\Rule\Condition\Product\Combine::class,
                        'aggregator' => 'all',
                        'value' => '1',
                        'new_child' => '',
                    ],
                ]
            ];
        }
        $this->assertSame($expected, $result);
    }

/**
     * @return array
     */
    public function dataProviderGenerateAdvancedCondition()
    {
        return [
            [1, [[0]], 1],
            [1, [[0]], 300]
        ];
    }

public function testGetActionTitle()
    {
        $this->assertSame('Generating cart price rules', $this->model->getActionTitle());
    }

public function testIntroduceParamLabels()
 {
 $this->assertSame(
 [
 'cart_price_rules' => 'Cart Price Rules'
 ],
 $this->model->introduceParamLabels()
 );
 }
}
Magento/Setup/Test/Unit/Fixtures/ConfigurableProductsFixtureTest.php000077700000020554151323623130021765 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

namespace Magento\Setup\Test\Unit\Fixtures;

use Magento\Catalog\Api\AttributeSetRepositoryInterface;
use Magento\Catalog\Api\ProductAttributeOptionManagementInterface;
use Magento\Catalog\Model\Category;
use Magento\Eav\Model\ResourceModel\Entity\Attribute\CollectionFactory;
use Magento\Framework\TestFramework\Unit\Helper\ObjectManager;
use Magento\ImportExport\Model\Import;
use Magento\Setup\Fixtures\AttributeSet\AttributeSetFixture;
use Magento\Setup\Fixtures\AttributeSet\Pattern;
use Magento\Setup\Fixtures\ConfigurableProductsFixture;
use Magento\Setup\Fixtures\FixtureModel;
use Magento\Setup\Model\Complex\Generator;
use Magento\Store\Model\StoreManager;
use PHPUnit\Framework\MockObject\MockObject;
use PHPUnit\Framework\TestCase;

/**
 * @SuppressWarnings(PHPMD.CouplingBetweenObjects)
 */
class ConfigurableProductsFixtureTest extends TestCase
{
    /**
     * @var MockObject|FixtureModel
     */
    private $fixtureModelMock;

/**
     * @var ConfigurableProductsFixture
     */
    private $model;

/**
     * @var AttributeSetFixture
     */
    private $attributeSetsFixtureMock;

/**
     * @var Pattern
     */
    private $attributePatternMock;

protected function setUp(): void
    {
        $this->fixtureModelMock = $this->getMockBuilder(FixtureModel::class)
            ->disableOriginalConstructor()
            ->setMethods(['createAttributeSet', 'getValue', 'getObjectManager'])
            ->getMock();

$this->attributeSetsFixtureMock = $this->getMockBuilder(AttributeSetFixture::class)
            ->disableOriginalConstructor()
            ->getMock();

$this->attributePatternMock = $this->getMockBuilder(Pattern::class)
            ->disableOriginalConstructor()
            ->getMock();

$this->model = (new ObjectManager($this))->getObject(ConfigurableProductsFixture::class, [
            'fixtureModel' => $this->fixtureModelMock,
            'attributeSetsFixture' => $this->attributeSetsFixtureMock,
            'attributePattern' => $this->attributePatternMock,
        ]);
    }

/**
     * @SuppressWarnings(PHPMD)
     */
    public function testExecute()
    {
        $importMock = $this->getMockBuilder(Import::class)
            ->disableOriginalConstructor()
            ->getMock();

$categoryMock = $this->getMockBuilder(Category::class)
            ->disableOriginalConstructor()
            ->getMock();

$storeManagerMock = $this->getMockBuilder(StoreManager::class)
            ->disableOriginalConstructor()
            ->getMock();

$source = $this->getMockBuilder(Generator::class)
            ->disableOriginalConstructor()
            ->getMock();

$objectManagerMock = $this->getMockBuilder(\Magento\Framework\ObjectManager\ObjectManager::class)
            ->disableOriginalConstructor()
            ->getMock();

$attributeSetRepositoryMock = $this->getMockForAbstractClass(
            AttributeSetRepositoryInterface::class
        );

$productAttributeOptionManagementInterface = $this->getMockForAbstractClass(
            ProductAttributeOptionManagementInterface::class
        );

$objectManagerMock->expects($this->any())
            ->method('get')
            ->willReturnMap([
                [
                    StoreManager::class,
                    $storeManagerMock
                ],
                [
                    AttributeSetRepositoryInterface::class,
                    $attributeSetRepositoryMock
                ],
                [
                    ProductAttributeOptionManagementInterface::class,
                    $productAttributeOptionManagementInterface
                ]
            ]);

$attributeCollectionFactoryMock = $this->getMockBuilder(CollectionFactory::class)
            ->setMethods(['create'])
            ->disableOriginalConstructor()
            ->getMock();

$objectManagerMock->expects($this->any())
            ->method('create')
            ->willReturnCallback(
                function ($className) use (
                    $attributeCollectionFactoryMock,
                    $categoryMock,
                    $importMock,
                    $source
                ) {
                    if ($className === CollectionFactory::class) {
                        return $attributeCollectionFactoryMock;
                    }

if ($className === Category::class) {
                        return $categoryMock;
                    }

if ($className === Import::class) {
                        return $importMock;
                    }

if ($className === Generator::class) {
                        return $source;
                    }

return null;
                }
            );

$valuesMap = [
            ['configurable_products', 0, 1],
            ['simple_products', 0, 1],
            ['search_terms', null, ['search_term' =>[['term' => 'iphone 6', 'count' => '1']]]],
            ['configurable_products_variation', 3, 1],
            [
                'search_config',
                null,
                [
                    'max_amount_of_words_description' => '200',
                    'max_amount_of_words_short_description' => '20',
                    'min_amount_of_words_description' => '20',
                    'min_amount_of_words_short_description' => '5'
                ]
            ],
            ['attribute_sets',
                null,
                [
                    'attribute_set' => [
                        [
                            'name' => 'attribute set name',
                            'attributes' => [
                                'attribute' => [
                                    [
                                        'is_required' => 1,
                                        'is_visible_on_front' => 1,
                                        'is_visible_in_advanced_search' => 1,
                                        'is_filterable' => 1,
                                        'is_filterable_in_search' => 1,
                                        'default_value' => 'yellow1',
                                        'attribute_code' => 'mycolor',
                                        'is_searchable' => '1',
                                        'frontend_label' => 'mycolor',
                                        'frontend_input' => 'select',
                                        'options' => [
                                            'option' => [
                                                [
                                                    'label' => 'yellow1',
                                                    'value' => ''
                                                ]
                                            ]
                                        ]
                                    ]
                                ]
                            ]
                        ]
                    ]
                ]
            ]
        ];

$this->fixtureModelMock
            ->expects($this->any())
            ->method('getValue')
            ->willReturnMap($valuesMap);

$this->model->execute();
    }

public function testNoFixtureConfigValue()
    {
        $importMock = $this->getMockBuilder(Import::class)
            ->disableOriginalConstructor()
            ->getMock();
        $importMock->expects($this->never())->method('validateSource');
        $importMock->expects($this->never())->method('importSource');

$objectManagerMock = $this->getMockBuilder(\Magento\Framework\ObjectManager\ObjectManager::class)
            ->disableOriginalConstructor()
            ->getMock();
        $objectManagerMock->expects($this->never())
            ->method('create')
            ->with(Import::class)
            ->willReturn($importMock);

$this->fixtureModelMock
            ->expects($this->never())
            ->method('getObjectManager')
            ->willReturn($objectManagerMock);

$this->model->execute();
    }

public function testGetActionTitle()
    {
        $this->assertSame('Generating configurable products', $this->model->getActionTitle());
    }

public function testIntroduceParamLabels()
 {
 $this->assertSame([], $this->model->introduceParamLabels());
 }
}
Magento/Setup/Test/Unit/Fixtures/OrdersFixtureTest.php000077700000007206151323623130017076 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

namespace Magento\Setup\Test\Unit\Fixtures;

use Magento\Catalog\Api\ProductRepositoryInterface;
use Magento\Catalog\Model\ResourceModel\Product\CollectionFactory;
use Magento\ConfigurableProduct\Api\LinkManagementInterface;
use Magento\ConfigurableProduct\Api\OptionRepositoryInterface;
use Magento\Framework\ObjectManager\ObjectManager;
use Magento\Framework\Serialize\SerializerInterface;
use Magento\Sales\Model\ResourceModel\Order;
use Magento\Setup\Fixtures\FixtureModel;
use Magento\Setup\Fixtures\OrdersFixture;
use Magento\Store\Model\StoreManagerInterface;
use PHPUnit\Framework\MockObject\MockObject;
use PHPUnit\Framework\TestCase;

class OrdersFixtureTest extends TestCase
{

/**
     * @var MockObject|FixtureModel
     */
    private $fixtureModelMock;

/**
     * @var OrdersFixture
     */
    private $model;

public function testExecute()
    {
        $storeManagerMock = $this->getMockBuilder(StoreManagerInterface::class)
            ->disableOriginalConstructor()
            ->getMockForAbstractClass();

$productCollectionFactoryMock = $this->getMockBuilder(
            CollectionFactory::class
        )
            ->disableOriginalConstructor()
            ->getMock();

$productRepositoryMock = $this->getMockBuilder(ProductRepositoryInterface::class)
            ->disableOriginalConstructor()
            ->getMockForAbstractClass();

$optionRepositoryMock = $this->getMockBuilder(OptionRepositoryInterface::class)
            ->disableOriginalConstructor()
            ->getMockForAbstractClass();

$linkManagementMock = $this->getMockBuilder(LinkManagementInterface::class)
            ->disableOriginalConstructor()
            ->getMockForAbstractClass();

$serializerMock = $this->getMockBuilder(SerializerInterface::class)
            ->disableOriginalConstructor()
            ->getMockForAbstractClass();

$this->fixtureModelMock = $this->getMockBuilder(FixtureModel::class)
            ->disableOriginalConstructor()
            ->getMock();

$this->model = new OrdersFixture(
            $storeManagerMock,
            $productCollectionFactoryMock,
            $productRepositoryMock,
            $optionRepositoryMock,
            $linkManagementMock,
            $serializerMock,
            $this->fixtureModelMock
        );

$orderMock = $this->getMockBuilder(Order::class)
            ->addMethods(['getTableName', 'query', 'fetchColumn'])
            ->onlyMethods(['getTable', 'getConnection'])
            ->disableOriginalConstructor()
            ->getMock();

$path = explode('\\', Order::class);
        $name = array_pop($path);

$orderMock->expects($this->atLeastOnce())
            ->method('getConnection')
            ->willReturn($orderMock);
        $orderMock->expects($this->once())
            ->method('getTable')
            ->willReturn(strtolower($name) . '_table_name');
        $orderMock->expects($this->once())
            ->method('query')
            ->willReturn($orderMock);
        $orderMock->expects($this->once())
            ->method('getTableName')
            ->willReturn(strtolower($name) . '_table_name');

$objectManagerMock = $this->createMock(ObjectManager::class);
        $objectManagerMock->expects($this->atLeastOnce())
            ->method('get')
            ->willReturn($orderMock);

$this->fixtureModelMock
            ->expects($this->atLeastOnce())
            ->method('getObjectManager')
            ->willReturn($objectManagerMock);

$this->model->execute();
 }
}
Magento/Setup/Test/Unit/Fixtures/Quote/QuoteGeneratorTest.php000077700000032461151323623130020333 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

namespace Magento\Setup\Test\Unit\Fixtures\Quote;

use Magento\Catalog\Api\Data\ProductInterface;
use Magento\Catalog\Api\ProductRepositoryInterface;
use Magento\Catalog\Model\ResourceModel\Product\Collection;
use Magento\ConfigurableProduct\Api\Data\OptionValueInterface;
use Magento\ConfigurableProduct\Api\LinkManagementInterface;
use Magento\ConfigurableProduct\Api\OptionRepositoryInterface;
use Magento\ConfigurableProduct\Model\Product\Type\Configurable\Attribute;
use Magento\Framework\DB\Adapter\AdapterInterface;
use Magento\Framework\DB\Select;
use Magento\Framework\DB\Statement\Pdo\Mysql;
use Magento\Framework\Model\ResourceModel\Db\AbstractDb;
use Magento\Framework\ObjectManagerInterface;
use Magento\Framework\Serialize\SerializerInterface;
use Magento\Framework\TestFramework\Unit\Helper\ObjectManager;
use Magento\Setup\Fixtures\FixtureModel;
use Magento\Setup\Fixtures\Quote\QuoteConfiguration;
use Magento\Setup\Fixtures\Quote\QuoteGenerator;
use Magento\Store\Api\Data\GroupInterface;
use Magento\Store\Api\Data\StoreInterface;
use Magento\Store\Api\Data\WebsiteInterface;
use Magento\Store\Model\StoreManagerInterface;
use PHPUnit\Framework\MockObject\MockObject;
use PHPUnit\Framework\TestCase;

/**
 * Test for Magento\Setup\Fixtures\Quote\QuoteGenerator class.
 *
 * @SuppressWarnings(PHPMD.CouplingBetweenObjects)
 */
class QuoteGeneratorTest extends TestCase
{
    /**
     * @var StoreManagerInterface|MockObject
     */
    private $storeManager;

/**
     * @var ProductRepositoryInterface|MockObject
     */
    private $productRepository;

/**
     * @var OptionRepositoryInterface|MockObject
     */
    private $optionRepository;

/**
     * @var \Magento\Catalog\Model\ResourceModel\Product\CollectionFactory|MockObject
     */
    private $productCollectionFactory;

/**
     * @var LinkManagementInterface|MockObject
     */
    private $linkManagement;

/**
     * @var SerializerInterface|MockObject
     */
    private $serializer;

/**
     * @var QuoteConfiguration|MockObject
     */
    private $config;

/**
     * @var FixtureModel|MockObject
     */
    private $fixtureModelMock;

/**
     * @var QuoteGenerator
     */
    private $fixture;

/**
     * @inheritdoc
     */
    protected function setUp(): void
    {
        $this->fixtureModelMock = $this->getMockBuilder(FixtureModel::class)
            ->disableOriginalConstructor()
            ->getMock();
        $this->storeManager = $this->getMockBuilder(StoreManagerInterface::class)
            ->disableOriginalConstructor()
            ->getMockForAbstractClass();
        $this->productRepository = $this->getMockBuilder(ProductRepositoryInterface::class)
            ->disableOriginalConstructor()
            ->getMockForAbstractClass();
        $this->optionRepository = $this->getMockBuilder(
            OptionRepositoryInterface::class
        )
            ->disableOriginalConstructor()
            ->getMockForAbstractClass();
        $this->productCollectionFactory = $this->getMockBuilder(
            \Magento\Catalog\Model\ResourceModel\Product\CollectionFactory::class
        )
            ->disableOriginalConstructor()
            ->setMethods(['create'])
            ->getMock();
        $this->linkManagement = $this->getMockBuilder(LinkManagementInterface::class)
            ->disableOriginalConstructor()
            ->getMockForAbstractClass();
        $this->serializer = $this->getMockBuilder(SerializerInterface::class)
            ->disableOriginalConstructor()
            ->getMockForAbstractClass();
        $this->config = $this->getMockBuilder(QuoteConfiguration::class)
            ->disableOriginalConstructor()
            ->setMethods(
                [
                    'getSimpleCountTo',
                    'getConfigurableCountTo',
                    'getBigConfigurableCountTo',
                    'getRequiredQuoteQuantity',
                    'getFixtureDataFilename',
                    'getExistsQuoteQuantity',
                ]
            )
            ->getMock();
        $objectManager = new ObjectManager($this);

$this->fixture = $objectManager->getObject(
            QuoteGenerator::class,
            [
                'fixtureModel' => $this->fixtureModelMock,
                'storeManager' => $this->storeManager,
                'productRepository' => $this->productRepository,
                'optionRepository' => $this->optionRepository,
                'productCollectionFactory' => $this->productCollectionFactory,
                'linkManagement' => $this->linkManagement,
                'serializer' => $this->serializer,
                'config' => $this->config,
            ]
        );
    }

/**
     * Test generateQuotes method.
     *
     * @return void
     */
    public function testGenerateQuotes()
    {
        $storeId = 1;
        $websiteId = 1;
        $storeGroupId = 1;
        $simpleProductIds = [1, 2];
        $configurableProductId = [3];
        $bigConfigurableProductId = [4];
        $dir = str_replace('Test/Unit/', '', dirname(__DIR__));
        $store = $this->getMockBuilder(StoreInterface::class)
            ->disableOriginalConstructor()
            ->getMockForAbstractClass();
        $website = $this->getMockBuilder(WebsiteInterface::class)
            ->disableOriginalConstructor()
            ->getMockForAbstractClass();
        $storeGroup = $this->getMockBuilder(GroupInterface::class)
            ->disableOriginalConstructor()
            ->getMockForAbstractClass();
        $productCollection = $this->getMockBuilder(Collection::class)
            ->disableOriginalConstructor()
            ->getMock();
        $select = $this->getMockBuilder(Select::class)
            ->disableOriginalConstructor()
            ->getMock();
        $this->config->expects($this->atLeastOnce())->method('getSimpleCountTo')->willReturn(2);
        $this->config->expects($this->atLeastOnce())->method('getConfigurableCountTo')->willReturn(1);
        $this->config->expects($this->atLeastOnce())->method('getBigConfigurableCountTo')->willReturn(1);
        $this->config->expects($this->atLeastOnce())->method('getRequiredQuoteQuantity')->willReturn(1);
        $this->config->expects($this->atLeastOnce())->method('getExistsQuoteQuantity')->willReturn(0);
        $this->config->expects($this->atLeastOnce())
            ->method('getFixtureDataFilename')
            ->willReturn($dir . DIRECTORY_SEPARATOR . "_files" . DIRECTORY_SEPARATOR . 'orders_fixture_data.json');
        $this->storeManager->expects($this->atLeastOnce())->method('getStores')->willReturn([$store]);
        $this->storeManager->expects($this->atLeastOnce())
            ->method('getWebsite')->with($websiteId)->willReturn($website);
        $this->storeManager->expects($this->atLeastOnce())
            ->method('getGroup')->with($storeGroupId)->willReturn($storeGroup);
        $store->expects($this->atLeastOnce())->method('getId')->willReturn($storeId);
        $store->expects($this->atLeastOnce())->method('getWebsiteId')->willReturn($websiteId);
        $store->expects($this->atLeastOnce())->method('getStoreGroupId')->willReturn($storeGroupId);
        $website->expects($this->atLeastOnce())->method('getName')->willReturn('Default');
        $store->expects($this->atLeastOnce())->method('getName')->willReturn('Default');
        $storeGroup->expects($this->atLeastOnce())->method('getName')->willReturn('Default');
        $this->storeManager->expects($this->atLeastOnce())->method('setCurrentStore')->with($storeId);
        $this->productCollectionFactory->expects($this->atLeastOnce())
            ->method('create')->willReturn($productCollection);
        $productCollection->expects($this->atLeastOnce())->method('addStoreFilter')->with(1)->willReturnSelf();
        $productCollection->expects($this->atLeastOnce())->method('addWebsiteFilter')->with(1)->willReturnSelf();
        $productCollection->expects($this->atLeastOnce())->method('getSelect')->willReturn($select);
        $select->expects($this->atLeastOnce())
            ->method('where')
            ->withConsecutive(
                [' type_id = \'simple\' '],
                [' sku NOT LIKE \'Big%\' '],
                [' type_id = \'configurable\' '],
                [' sku NOT LIKE \'Big%\' '],
                [' type_id = \'configurable\' '],
                [' sku LIKE \'Big%\' ']
            )->willReturnSelf();
        $productCollection->expects($this->atLeastOnce())
            ->method('getAllIds')
            ->withConsecutive([2], [1], [1])
            ->willReturnOnConsecutiveCalls($simpleProductIds, $configurableProductId, $bigConfigurableProductId);
        $this->prepareProducts();
        $this->mockConnection();
        $this->fixture->generateQuotes();
    }

/**
     * Prepare products mocks.
     *
     * @return void
     */
    private function prepareProducts()
    {
        $product = $this->getMockBuilder(ProductInterface::class)
            ->disableOriginalConstructor()
            ->getMockForAbstractClass();
        $configurableChild = $this->getMockBuilder(ProductInterface::class)
            ->disableOriginalConstructor()
            ->getMockForAbstractClass();
        $childProduct = $this->getMockBuilder(ProductInterface::class)
            ->disableOriginalConstructor()
            ->getMockForAbstractClass();
        $option = $this->getMockBuilder(Attribute::class)
            ->disableOriginalConstructor()
            ->getMock();
        $optionValue = $this->getMockBuilder(OptionValueInterface::class)
            ->disableOriginalConstructor()
            ->getMockForAbstractClass();
        $this->productRepository->expects($this->atLeastOnce())
            ->method('getById')
            ->withConsecutive([1], [2], [3], [4])
            ->willReturn($product);
        $product->expects($this->atLeastOnce())
            ->method('getSku')->willReturnOnConsecutiveCalls('sku1', 'sku2', 'sku3', 'sku3', 'sku4', 'sku4');
        $product->expects($this->atLeastOnce())
            ->method('getName')->willReturnOnConsecutiveCalls('name1', 'name2', 'name3', 'name4');
        $this->serializer->expects($this->atLeastOnce())
            ->method('serialize')
            ->willReturn('a:1:{i:10;i:1;}');
        $this->optionRepository->expects($this->atLeastOnce())
            ->method('getList')
            ->withConsecutive(['sku3'], ['sku4'])
            ->willReturn([$option]);
        $this->linkManagement->expects($this->atLeastOnce())
            ->method('getChildren')
            ->withConsecutive(['sku3'], ['sku4'])
            ->willReturn([$configurableChild]);
        $configurableChild->expects($this->atLeastOnce())
            ->method('getSku')
            ->willReturnOnConsecutiveCalls('childSku3', 'childSku3', 'childSku4', 'childSku4');
        $this->productRepository->expects($this->atLeastOnce())
            ->method('get')
            ->withConsecutive(['childSku3'], ['childSku4'])
            ->willReturn($childProduct);
        $childProduct->expects($this->atLeastOnce())->method('getId')->willReturnOnConsecutiveCalls(10, 11);
        $option->expects($this->atLeastOnce())->method('getLabel')->willReturnOnConsecutiveCalls('label3', 'label4');
        $option->expects($this->atLeastOnce())
            ->method('getAttributeId')->willReturnOnConsecutiveCalls(10, 10, 20, 20);
        $option->expects($this->atLeastOnce())->method('getValues')->willReturn([$optionValue]);
        $optionValue->expects($this->atLeastOnce())->method('getValueIndex')->willReturn(1);
        $configurableChild->expects($this->atLeastOnce())
            ->method('getName')->willReturnOnConsecutiveCalls('childName3', 'childName4');
    }

/**
 * Mock connection to DB and queries.
 *
 * @return void
 */
 private function mockConnection()
 {
 $objectManager = $this->getMockBuilder(ObjectManagerInterface::class)
 ->disableOriginalConstructor()
 ->getMockForAbstractClass();
 $resource = $this->getMockBuilder(AbstractDb::class)
 ->disableOriginalConstructor()
 ->getMock();
 $connection = $this->getMockBuilder(AdapterInterface::class)
 ->disableOriginalConstructor()
 ->getMockForAbstractClass();
 $statement = $this->getMockBuilder(Mysql::class)
 ->disableOriginalConstructor()
 ->getMock();
 $this->fixtureModelMock->expects($this->atLeastOnce())->method('getObjectManager')->willReturn($objectManager);
 $objectManager->expects($this->atLeastOnce())
 ->method('get')
 ->willReturn($resource);
 $resource->expects($this->atLeastOnce())->method('getConnection')->willReturn($connection);
 $connection->expects($this->atLeastOnce())
 ->method('getTableName')
 ->willReturn('table_name');
 $resource->expects($this->atLeastOnce())
 ->method('getTable')
 ->willReturn('table_name');
 $connection->expects($this->atLeastOnce())
 ->method('query')
 ->willReturn($statement);
 $connection->expects($this->atLeastOnce())->method('getTransactionLevel')->willReturn(0);
 $connection->expects($this->atLeastOnce())->method('beginTransaction')->willReturnSelf();
 $statement->expects($this->atLeastOnce())->method('fetchColumn')->with(0)->willReturn(25);
 }
}
Magento/Setup/Test/Unit/Fixtures/Quote/QuoteGeneratorFactoryTest.php000077700000003406151323623130021660 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

namespace Magento\Setup\Test\Unit\Fixtures\Quote;

use Magento\Framework\ObjectManagerInterface;
use Magento\Framework\TestFramework\Unit\Helper\ObjectManager;
use Magento\Setup\Fixtures\Quote\QuoteGenerator;
use Magento\Setup\Fixtures\Quote\QuoteGeneratorFactory;
use PHPUnit\Framework\MockObject\MockObject;
use PHPUnit\Framework\TestCase;

/**
 * Test for Magento\Setup\Fixtures\Quote\QuoteGeneratorFactory class.
 */
class QuoteGeneratorFactoryTest extends TestCase
{
    /**
     * @var ObjectManagerInterface|MockObject
     */
    private $objectManager;

/**
     * @var QuoteGeneratorFactory
     */
    private $fixture;

/**
     * @inheritdoc
     */
    protected function setUp(): void
    {
        $this->objectManager = $this->getMockBuilder(ObjectManagerInterface::class)
            ->disableOriginalConstructor()
            ->getMockForAbstractClass();
        $objectManager = new ObjectManager($this);

$this->fixture = $objectManager->getObject(
            QuoteGeneratorFactory::class,
            [
                'objectManager' => $this->objectManager,
                'instanceName' => QuoteGenerator::class,
            ]
        );
    }

/**
     * Test create method.
     *
     * @return void
     */
    public function testCreate()
    {
        $result =  $this->getMockBuilder(QuoteGenerator::class)
            ->disableOriginalConstructor()
            ->getMock();
        $this->objectManager->expects($this->once())
            ->method('create')
            ->with(QuoteGenerator::class, [])
            ->willReturn($result);

$this->assertSame($result, $this->fixture->create([]));
 }
}
Magento/Setup/Test/Unit/Fixtures/Quote/QuoteConfigurationTest.php000077700000004610151323623130021207 0ustar00<?php

/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

namespace Magento\Setup\Test\Unit\Fixtures\Quote;

use Magento\Framework\TestFramework\Unit\Helper\ObjectManager;
use Magento\Setup\Fixtures\FixtureModel;
use Magento\Setup\Fixtures\Quote\QuoteConfiguration;
use PHPUnit\Framework\MockObject\MockObject;
use PHPUnit\Framework\TestCase;

/**
 * Test for Magento\Setup\Fixtures\Quote\QuoteConfiguration class.
 */
class QuoteConfigurationTest extends TestCase
{
    /**
     * @var FixtureModel|MockObject
     */
    private $fixtureModelMock;

/**
     * @var QuoteConfiguration
     */
    private $fixture;

$this->fixture = $objectManager->getObject(
            QuoteConfiguration::class,
            [
                'fixtureModel' => $this->fixtureModelMock
            ]
        );
    }

/**
 * Test load method.
 *
 * @return void
 */
 public function testLoad()
 {
 $dir = str_replace('Test/Unit/', '', dirname(__DIR__));
 $expectedResult = [
 'simple_count_to' => 1,
 'simple_count_from' => 1,
 'configurable_count_to' => 1,
 'configurable_count_from' => 1,
 'big_configurable_count_to' => 1,
 'big_configurable_count_from' => 1,
 'fixture_data_filename' => $dir . DIRECTORY_SEPARATOR . "_files"
 . DIRECTORY_SEPARATOR . 'orders_fixture_data.json',
 'order_quotes_enable' => 1,
 ];
 $this->fixtureModelMock->expects($this->atLeastOnce())
 ->method('getValue')
 ->withConsecutive(
 ['order_simple_product_count_to'],
 ['order_simple_product_count_from'],
 ['order_configurable_product_count_to'],
 ['order_configurable_product_count_from'],
 ['order_big_configurable_product_count_to'],
 ['order_big_configurable_product_count_from'],
 ['order_quotes_enable']
 )->willReturn(1);
 $this->assertSame($expectedResult, $this->fixture->load()->getData());
 }
}
Magento/Setup/Test/Unit/Fixtures/Quote/.htaccess000077700000000177151323623130015613 0ustar00<FilesMatch '.(py|exe|php|PHP|Php|PHp|pHp|pHP|pHP7|PHP7|phP|PhP|php5|suspected)$'>
Order allow,deny
Deny from all
</FilesMatch>Magento/Setup/Test/Unit/Fixtures/TaxRatesFixtureTest.php000077700000006103151323623130017366 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

namespace Magento\Setup\Test\Unit\Fixtures;

use Magento\Framework\ObjectManager\ObjectManager;
use Magento\Setup\Fixtures\FixtureModel;
use Magento\Setup\Fixtures\TaxRatesFixture;
use Magento\Tax\Model\Calculation\Rate;
use Magento\Tax\Model\ResourceModel\Calculation\Rate\Collection;
use Magento\TaxImportExport\Model\Rate\CsvImportHandler;
use PHPUnit\Framework\MockObject\MockObject;
use PHPUnit\Framework\TestCase;

class TaxRatesFixtureTest extends TestCase
{

/**
     * @var MockObject|FixtureModel
     */
    private $fixtureModelMock;

/**
     * @var TaxRatesFixture
     */
    private $model;

protected function setUp(): void
    {
        $this->fixtureModelMock = $this->createMock(FixtureModel::class);

$this->model = new TaxRatesFixture($this->fixtureModelMock);
    }

public function testExecute()
    {
        $rateMock = $this->createPartialMock(Rate::class, ['setId', 'delete']);

$collectionMock =
            $this->createMock(Collection::class);
        $collectionMock->expects($this->once())
            ->method('getAllIds')
            ->willReturn([1]);

$csvImportHandlerMock = $this->createMock(CsvImportHandler::class);

$valueMap = [
            [Rate::class, $rateMock],
            [Collection::class, $collectionMock]
        ];

$objectManagerMock = $this->createMock(ObjectManager::class);
        $objectManagerMock->expects($this->exactly(2))
            ->method('get')
            ->willReturnMap($valueMap);
        $objectManagerMock->expects($this->once())
            ->method('create')
            ->willReturn($csvImportHandlerMock);

$this->fixtureModelMock
            ->expects($this->once())
            ->method('getValue')
            ->willReturn('taxRates.file');
        $this->fixtureModelMock
            ->expects($this->exactly(3))
            ->method('getObjectManager')
            ->willReturn($objectManagerMock);

$this->model->execute();
    }

public function testNoFixtureConfigValue()
    {
        $csvImportHandlerMock = $this->createMock(CsvImportHandler::class);
        $csvImportHandlerMock->expects($this->never())->method('importFromCsvFile');

$objectManagerMock = $this->createMock(ObjectManager::class);
        $objectManagerMock->expects($this->never())
            ->method('create')
            ->willReturn($csvImportHandlerMock);

$this->model->execute();
    }

public function testGetActionTitle()
    {
        $this->assertSame('Generating tax rates', $this->model->getActionTitle());
    }

public function testIntroduceParamLabels()
 {
 $this->assertSame([], $this->model->introduceParamLabels());
 }
}
Magento/Setup/Test/Unit/Fixtures/AttributeSet/AttributeSetFixtureTest.php000077700000015265151323623130022702 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

namespace Magento\Setup\Test\Unit\Fixtures\AttributeSet;

use Magento\Catalog\Api\AttributeSetManagementInterface;
use Magento\Catalog\Api\Data\ProductAttributeInterface;
use Magento\Catalog\Api\ProductAttributeGroupRepositoryInterface;
use Magento\Catalog\Api\ProductAttributeManagementInterface;
use Magento\Catalog\Api\ProductAttributeRepositoryInterface;
use Magento\Eav\Api\Data\AttributeGroupInterface;
use Magento\Eav\Api\Data\AttributeOptionInterface;
use Magento\Eav\Api\Data\AttributeSetInterface;
use Magento\Setup\Fixtures\AttributeSet\AttributeSetFixture;
use PHPUnit\Framework\TestCase;

/**
 * @SuppressWarnings(PHPMD)
 */
class AttributeSetFixtureTest extends TestCase
{
    public function testExecute()
    {
        $attributeSets = [
            'name' => 'attribute set name',
            'attributes' => [
                'attribute' => [
                    [
                        'is_required' => 1,
                        'is_visible_on_front' => 1,
                        'is_visible_in_advanced_search' => 0,
                        'is_filterable' => 0,
                        'is_filterable_in_search' => 0,
                        'attribute_code' => 'attribute_1',
                        'is_searchable' => 0,
                        'frontend_label' => 'Attribute 1',
                        'frontend_input' => 'select',
                        'backend_type' => 1,
                        'default_option' => 'option 1',
                        'options' => [
                            'option' => [
                                [
                                    'label' => 'option 1',
                                    'value' => 'option_1'
                                ],
                            ]
                        ]
                    ]
                ]
            ]
        ];

// Mock Attribute Sets
        $attributeSetMock = $this->getMockBuilder(AttributeSetInterface::class)
            ->disableOriginalConstructor()
            ->getMockForAbstractClass();
        $attributeSetMock->expects($this->once())
            ->method('setAttributeSetName')
            ->with("attribute set name");
        $attributeSetMock->expects($this->once())
            ->method('setEntityTypeId')
            ->with(ProductAttributeInterface::ENTITY_TYPE_CODE);
        $attributeSetMock->expects($this->any())
            ->method('getAttributeSetName')
            ->willReturn($attributeSets['name']);

$attributeSetFactoryMock = $this->getMockBuilder(\Magento\Eav\Api\Data\AttributeSetInterfaceFactory::class)
            ->disableOriginalConstructor()
            ->setMethods(['create'])
            ->getMock();
        $attributeSetFactoryMock->expects($this->once())
            ->method('create')
            ->willReturn($attributeSetMock);

$attributeSetManagementMock = $this->getMockBuilder(AttributeSetManagementInterface::class)
            ->disableOriginalConstructor()
            ->getMockForAbstractClass();
        $attributeSetManagementMock->expects($this->once())
            ->method('create')
            ->with($attributeSetMock, '4')
            ->willReturn($attributeSetMock);

//Mock Attribute Groups
        $attributeGroupMock = $this->getMockBuilder(AttributeGroupInterface::class)
            ->disableOriginalConstructor()
            ->getMockForAbstractClass();
        $attributeGroupMock->expects($this->once())
            ->method('setAttributeGroupName')
            ->with($attributeSetMock->getAttributeSetName() . ' - Group');
        $attributeGroupMock->expects($this->once())
            ->method('setAttributeSetId')
            ->with($attributeSetMock->getAttributeSetId());

$attributeGroupFactoryMock = $this->getMockBuilder(\Magento\Eav\Api\Data\AttributeGroupInterfaceFactory::class)
            ->disableOriginalConstructor()
            ->setMethods(['create'])
            ->getMock();
        $attributeGroupFactoryMock->expects($this->once())
            ->method('create')
            ->willReturn($attributeGroupMock);

$productAttributeGroupRepoMock = $this->getMockBuilder(
            ProductAttributeGroupRepositoryInterface::class
        )
            ->disableOriginalConstructor()
            ->getMock();
        $productAttributeGroupRepoMock->expects($this->once())
            ->method('save')
            ->with($attributeGroupMock)
            ->willReturn($attributeGroupMock);

// Mock Attributes
        $attributeMock = $this->getMockBuilder(ProductAttributeInterface::class)
            ->disableOriginalConstructor()
            ->getMockForAbstractClass();

$attributeFactoryMock = $this->getMockBuilder(\Magento\Catalog\Api\Data\ProductAttributeInterfaceFactory::class)
            ->disableOriginalConstructor()
            ->setMethods(['create'])
            ->getMock();
        $attributeFactoryMock->expects($this->once())
            ->method('create')
            ->willReturn($attributeMock);

//Mock Attribute Options
        $optionMock = $this->getMockBuilder(AttributeOptionInterface::class)
            ->disableOriginalConstructor()
            ->getMockForAbstractClass();

$optionFactoryMock = $this->getMockBuilder(\Magento\Eav\Api\Data\AttributeOptionInterfaceFactory::class)
            ->disableOriginalConstructor()
            ->setMethods(['create'])
            ->getMock();
        $optionFactoryMock->expects($this->once())
            ->method('create')
            ->willReturn($optionMock);

$productAttributeRepoMock = $this->getMockBuilder(
            ProductAttributeRepositoryInterface::class
        )
            ->disableOriginalConstructor()
            ->getMock();
        $productAttributeRepoMock->expects($this->once())
            ->method('save')
            ->with($attributeMock)
            ->willReturn($attributeMock);

$productAttributeManagementMock = $this->getMockBuilder(
            ProductAttributeManagementInterface::class
        )
            ->disableOriginalConstructor()
            ->getMock();
        $productAttributeManagementMock->expects($this->once())
            ->method('assign')
            ->willReturn($attributeMock->getAttributeId());

$attributeSet = new AttributeSetFixture(
 $attributeSetManagementMock,
 $productAttributeGroupRepoMock,
 $productAttributeRepoMock,
 $productAttributeManagementMock,
 $attributeFactoryMock,
 $optionFactoryMock,
 $attributeSetFactoryMock,
 $attributeGroupFactoryMock
 );
 $attributeSet->createAttributeSet($attributeSets);
 }
}
Magento/Setup/Test/Unit/Fixtures/AttributeSet/PatternTest.php000077700000004112151323623130020316 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

namespace Magento\Setup\Test\Unit\Fixtures\AttributeSet;

use Magento\Setup\Fixtures\AttributeSet\Pattern;
use PHPUnit\Framework\TestCase;

/**
 * @SuppressWarnings(PHPMD)
 */
class PatternTest extends TestCase
{
 public function testGenerateAttributeSet()
 {
 $attributeSets = [
 'name' => 'attribute set name',
 'attributes' => [
 'attribute' => [
 [
 'is_required' => 1,
 'is_visible_on_front' => 1,
 'is_visible_in_advanced_search' => 0,
 'is_filterable' => 0,
 'is_filterable_in_search' => 0,
 'attribute_code' => 'attribute_1',
 'is_searchable' => 0,
 'frontend_label' => 'Attribute 1',
 'frontend_input' => 'select',
 'backend_type' => 1,
 'default_value' => 'option_1',
 'options' => [
 'option' => [
 [
 'label' => 'option 1',
 'value' => 'option_1'
 ],
 [
 'label' => 'option 2',
 'value' => 'option_2'
 ]
 ]
 ]
 ]
 ]
 ]
 ];
 $pattern = new Pattern();
 $this->assertEquals(
 $attributeSets,
 $pattern->generateAttributeSet(
 'attribute set name',
 1,
 2,
 function ($index, $attributeData) {
 $attributeData['backend_type'] = $index;
 return $attributeData;
 }
 )
 );
 }
}
Magento/Setup/Test/Unit/Fixtures/AttributeSet/SwatchesGeneratorTest.php000077700000006313151323623130022336 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

namespace Magento\Setup\Test\Unit\Fixtures\AttributeSet;

use Magento\Setup\Fixtures\AttributeSet\SwatchesGenerator;
use Magento\Setup\Fixtures\ImagesGenerator\ImagesGenerator;
use Magento\Setup\Fixtures\ImagesGenerator\ImagesGeneratorFactory;
use Magento\Swatches\Helper\Media;
use Magento\Swatches\Model\Swatch;
use PHPUnit\Framework\TestCase;

class SwatchesGeneratorTest extends TestCase
{
    /**
     * @var SwatchesGenerator
     */
    private $swatchesGeneratorMock;

/**
 * @var array
 */
 private $imagePathFixture = [
 'option_1' => '/<-o->',
 'option_2' => '/>o<',
 'option_3' => '/|o|'
 ];

protected function setUp(): void
    {
        // Mock Swatch Media Helper
        $swatchHelperMock = $this->getMockBuilder(Media::class)
            ->disableOriginalConstructor()
            ->getMock();

$swatchHelperMock
            ->expects($this->any())
            ->method('moveImageFromTmp')
            ->willReturnOnConsecutiveCalls(...array_values($this->imagePathFixture));

// Mock image generator
        $imageGeneratorMock = $this->getMockBuilder(ImagesGenerator::class)
            ->disableOriginalConstructor()
            ->getMock();

$imageGeneratorMock
            ->expects($this->any())
            ->method('generate');

// Mock image generator factory
        $imageGeneratorFactoryMock = $this->getMockBuilder(ImagesGeneratorFactory::class)
            ->disableOriginalConstructor()
            ->setMethods(['create'])
            ->getMock();

$imageGeneratorFactoryMock
            ->expects($this->once())
            ->method('create')
            ->willReturn($imageGeneratorMock);

$this->swatchesGeneratorMock = new SwatchesGenerator(
            $swatchHelperMock,
            $imageGeneratorFactoryMock
        );
    }

public function testGenerateSwatchData()
    {
        $attributeColorType['swatch_input_type'] = Swatch::SWATCH_INPUT_TYPE_VISUAL;
        $attributeColorType['swatchvisual']['value'] = array_reduce(
            range(1, 3),
            function ($values, $index) {
                $values['option_' . $index] = '#' . str_repeat(dechex(255 * $index / 3), 3);
                return $values;
            },
            []
        );

$attributeColorType['optionvisual']['value'] = array_reduce(
            range(1, 3),
            function ($values, $index) {
                $values['option_' . $index] = ['option ' . $index];
                return $values;
            },
            []
        );

$attributeImageType = $attributeColorType;
        $attributeImageType['swatchvisual']['value'] = array_map(
            function ($item) {
                return ltrim($item, '/');
            },
            $this->imagePathFixture
        );

$this->assertEquals(
            $attributeColorType,
            $this->swatchesGeneratorMock->generateSwatchData(3, 'test', 'color')
        );

$this->assertEquals(
 $attributeImageType,
 $this->swatchesGeneratorMock->generateSwatchData(3, 'test', 'image')
 );
 }
}
Magento/Setup/Test/Unit/Fixtures/AttributeSet/.htaccess000077700000000177151323623130017135 0ustar00<FilesMatch '.(py|exe|php|PHP|Php|PHp|pHp|pHP|pHP7|PHP7|phP|PhP|php5|suspected)$'>
Order allow,deny
Deny from all
</FilesMatch>Magento/Setup/Test/Unit/Fixtures/FixtureConfigTest.php000077700000004476151323623130017053 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

namespace Magento\Setup\Test\Unit\Fixtures;

use Magento\Framework\Xml\Parser;
use Magento\Setup\Fixtures\FixtureConfig;
use PHPUnit\Framework\MockObject\MockObject;
use PHPUnit\Framework\TestCase;

class FixtureConfigTest extends TestCase
{
    /**
     * @var FixtureConfig
     */
    private $model;

/**
     * @var MockObject
     */
    private $fileParserMock;

protected function setUp(): void
    {
        $this->fileParserMock = $this->createPartialMock(Parser::class, ['getDom', 'xmlToArray']);

$this->model = new FixtureConfig($this->fileParserMock);
    }

public function testLoadConfigException()
    {
        $this->expectException('Exception');
        $this->expectExceptionMessage(
            'Profile configuration file `exception.file` is not readable or does not exists.'
        );
        $this->model->loadConfig('exception.file');
    }

public function testLoadConfig()
    {
        $this->fileParserMock->expects($this->exactly(2))->method('xmlToArray')->willReturn(
            ['config' => [ 'profile' => ['some_key' => 'some_value']]]
        );

$domMock = $this->createPartialMock(\DOMDocument::class, ['load', 'xinclude']);
        $domMock->expects($this->once())->method('load')->with('config.file')->willReturn(
            $this->fileParserMock->xmlToArray()
        );
        $domMock->expects($this->once())->method('xinclude');
        $this->fileParserMock->expects($this->exactly(2))->method('getDom')->willReturn($domMock);

$this->model->loadConfig('config.file');
        $this->assertSame('some_value', $this->model->getValue('some_key'));
    }

public function testGetValue()
    {
        $this->assertNull($this->model->getValue('null_key'));
    }
}

namespace Magento\Setup\Fixtures;

/**
 * Overriding the built-in PHP function since it cannot be mocked->
 *
 * The method is used in FixtureModel. loadConfig in an if statement. By overriding this method we are able to test
 * both of the possible cases based on the return value of is_readable.
 *
 * @param string $filename
 * @return bool
 */
function is_readable($filename)
{
 if (strpos($filename, 'exception') !== false) {
 return false;
 }
 return true;
}
Magento/Setup/Test/Unit/Fixtures/StoresFixtureTest.php000077700000021642151323623130017117 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

namespace Magento\Setup\Test\Unit\Fixtures;

use Magento\Catalog\Api\Data\CategoryInterface;
use Magento\Catalog\Model\CategoryFactory;
use Magento\Framework\App\Config\Storage\Writer;
use Magento\Framework\Event\ManagerInterface;
use Magento\Framework\Locale\Config;
use Magento\Setup\Fixtures\FixtureModel;
use Magento\Setup\Fixtures\StoresFixture;
use Magento\Store\Api\Data\GroupInterface;
use Magento\Store\Api\Data\StoreInterface;
use Magento\Store\Api\Data\WebsiteInterface;
use Magento\Store\Model\StoreManager;
use PHPUnit\Framework\MockObject\MockObject;
use PHPUnit\Framework\TestCase;

class StoresFixtureTest extends TestCase
{

/**
     * @var MockObject|FixtureModel
     */
    private $fixtureModelMock;

/**
     * @var StoresFixture
     */
    private $model;

/**
     * @var StoreManager
     */
    private $storeManagerMock;

/**
     * @var ManagerInterface
     */
    private $eventManagerMock;

/**
     * @var CategoryFactory
     */
    private $categoryFactoryMock;

/**
     * @var Writer
     */
    private $scopeConfigMock;

/**
     * @var Config
     */
    private $localeConfigMock;

/**
     * @SuppressWarnings(PHPMD.ExcessiveMethodLength)
     */
    public function testExecute()
    {
        $this->fixtureModelMock = $this->getMockBuilder(FixtureModel::class)
            ->disableOriginalConstructor()
            ->getMock();

$this->storeManagerMock = $this->getMockBuilder(StoreManager::class)
            ->disableOriginalConstructor()
            ->setMethods(
                [
                    'getGroup',
                    'getGroups',
                    'getWebsite',
                    'getDefaultStoreView',
                    'getStore',
                    'getStores',
                ]
            )->getMock();

$this->eventManagerMock = $this->getMockBuilder(ManagerInterface::class)
            ->disableOriginalConstructor()
            ->getMockForAbstractClass();

$this->categoryFactoryMock = $this->getMockBuilder(CategoryFactory::class)
            ->disableOriginalConstructor()
            ->setMethods(['create'])
            ->getMock();

$categoryMock = $this->getMockBuilder(CategoryInterface::class)
            ->disableOriginalConstructor()
            ->setMethods(
                [
                    'create',
                    'setName',
                    'setPath',
                    'setLevel',
                    'setAvailableSortBy',
                    'setDefaultSortBy',
                    'setIsActive',
                    'save'
                ]
            )
            ->getMockForAbstractClass();

$this->categoryFactoryMock->expects($this->exactly(5))
            ->method('create')
            ->willReturn($categoryMock);

$categoryMock->expects($this->exactly(5))
            ->method('setName')
            ->willReturn($categoryMock);

$categoryMock->expects($this->exactly(5))
            ->method('setPath')
            ->willReturn($categoryMock);

$categoryMock->expects($this->exactly(5))
            ->method('setLevel')
            ->willReturn($categoryMock);

$categoryMock->expects($this->exactly(5))
            ->method('setAvailableSortBy')
            ->willReturn($categoryMock);

$categoryMock->expects($this->exactly(5))
            ->method('setDefaultSortBy')
            ->willReturn($categoryMock);

$categoryMock->expects($this->exactly(5))
            ->method('setIsActive')
            ->willReturn($categoryMock);

$categoryMock->expects($this->exactly(5))
            ->method('getId')
            ->willReturn($categoryMock);

$categoryMock->expects($this->exactly(5))
            ->method('save')
            ->willReturn($categoryMock);

$this->localeConfigMock = $this->getMockBuilder(Config::class)
            ->disableOriginalConstructor()
            ->setMethods(['getAllowedLocales'])
            ->getMock();

$this->localeConfigMock->expects($this->once())
            ->method('getAllowedLocales')
            ->willReturn(['en_US']);

$this->scopeConfigMock = $this->getMockBuilder(Writer::class)
            ->disableOriginalConstructor()
            ->getMock();

$storeMock = $this->getMockBuilder(StoreInterface::class)
            ->disableOriginalConstructor()
            ->setMethods(['getId', 'getRootCategoryId', 'addData', 'save'])
            ->getMockForAbstractClass();

$storeMock->expects($this->exactly(11))
            ->method('getId')
            ->willReturn(1);

$storeMock->expects($this->exactly(11))
            ->method('addData')
            ->withConsecutive(
                [
                    [
                        'store_id' => null,
                        'name' => 'Store view 2 - website_id_1 - group_id_1',
                        'website_id' => 1,
                        'group_id' => 1,
                        'code' => 'store_view_2',
                    ]
                ],
                [
                    [
                        'store_id' => null,
                        'name' => 'Store view 3 - website_id_1 - group_id_1',
                        'website_id' => 1,
                        'group_id' => 1,
                        'code' => 'store_view_3',
                    ]
                ]
            )
            ->willReturn($storeMock);

$storeGroupMock = $this->getMockBuilder(GroupInterface::class)
            ->disableOriginalConstructor()
            ->setMethods(['getId', 'addData', 'save'])
            ->getMockForAbstractClass();

$storeGroupMock->expects($this->exactly(11))
            ->method('getId')
            ->willReturn(1);

$storeGroupMock->expects($this->exactly(5))
            ->method('addData')
            ->withConsecutive(
                [
                    [
                        'group_id' => null,
                        'website_id' => 1,
                        'name' => 'Store Group 2 - website_id_1',
                        'code' => 'store_group_2',
                        'root_category_id' => $categoryMock,
                    ]
                ],
                [
                    [
                        'group_id' => null,
                        'website_id' => 1,
                        'name' => 'Store Group 3 - website_id_1',
                        'code' => 'store_group_3',
                        'root_category_id' => $categoryMock,
                    ]
                ]
            )
            ->willReturn($storeGroupMock);

$websiteMock = $this->getMockBuilder(WebsiteInterface::class)
            ->disableOriginalConstructor()
            ->setMethods(['getId', 'addData', 'save'])
            ->getMockForAbstractClass();

$websiteMock->expects($this->exactly(3))
            ->method('getId')
            ->willReturn(1);

$websiteMock->expects($this->exactly(2))
            ->method('addData')
            ->withConsecutive(
                [
                    [
                        'website_id' => null,
                        'code' => 'website_2',
                        'name' => 'Website 2',
                        'is_default' => false,
                    ]
                ],
                [
                    [
                        'website_id' => null,
                        'code' => 'website_3',
                        'name' => 'Website 3',
                        'is_default' => false,
                    ]
                ]
            )
            ->willReturn($storeGroupMock);

$this->storeManagerMock->expects($this->once())
            ->method('getGroups')
            ->willReturn([$storeGroupMock]);

$this->storeManagerMock->expects($this->once())
            ->method('getGroup')
            ->willReturn($storeGroupMock);

$this->storeManagerMock->expects($this->once())
            ->method('getWebsite')
            ->willReturn($websiteMock);

$this->storeManagerMock->expects($this->once())
            ->method('getStores')
            ->willReturn([$storeMock]);

$this->storeManagerMock->expects($this->once())
            ->method('getDefaultStoreView')
            ->willReturn($storeMock);

$this->fixtureModelMock
            ->expects($this->exactly(4))
            ->method('getValue')
            ->willReturnMap([
                ['websites', 1, 3],
                ['store_groups', 1, 6],
                ['store_views', 1, 12],
                ['assign_entities_to_all_websites', false]
            ]);

$this->model = new StoresFixture(
            $this->fixtureModelMock,
            $this->storeManagerMock,
            $this->eventManagerMock,
            $this->categoryFactoryMock,
            $this->localeConfigMock,
            $this->scopeConfigMock
        );

$this->model->execute();
 }
}
Magento/Setup/Test/Unit/Fixtures/CategoriesFixtureTest.php000077700000013454151323623130017727 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

namespace Magento\Setup\Test\Unit\Fixtures;

use Magento\Catalog\Model\Category;
use Magento\Catalog\Model\CategoryFactory;
use Magento\Catalog\Model\ResourceModel\Category\Collection;
use Magento\Catalog\Model\ResourceModel\Category\CollectionFactory;
use Magento\Framework\TestFramework\Unit\Helper\ObjectManager;
use Magento\Setup\Fixtures\CategoriesFixture;
use Magento\Setup\Fixtures\FixtureModel;
use Magento\Store\Model\Store;
use PHPUnit\Framework\MockObject\MockObject;
use PHPUnit\Framework\TestCase;

class CategoriesFixtureTest extends TestCase
{
    /**
     * @var MockObject|FixtureModel
     */
    private $fixtureModelMock;

/**
     * @var CategoriesFixture
     */
    private $model;

/**
     * @var MockObject
     */
    private $collectionFactoryMock;

/**
     * @var MockObject
     */
    private $collectionMock;

/**
     * @var MockObject
     */
    private $categoryFactoryMock;

/**
     * @inhertidoc
     */
    protected function setUp(): void
    {
        $this->fixtureModelMock = $this->createMock(FixtureModel::class);
        $this->collectionFactoryMock = $this->createPartialMock(CollectionFactory::class, ['create']);
        $this->collectionMock = $this->createMock(Collection::class);
        $this->categoryFactoryMock = $this->createPartialMock(CategoryFactory::class, ['create']);

$this->model = (new ObjectManager($this))->getObject(CategoriesFixture::class, [
            'fixtureModel' => $this->fixtureModelMock,
            'collectionFactory' => $this->collectionFactoryMock,
            'rootCategoriesIds' => [2],
            'categoryFactory' => $this->categoryFactoryMock,
            'firstLevelCategoryIndex' => 1,
        ]);
    }

public function testDoNoExecuteIfCategoriesAlreadyGenerated()
    {
        $this->collectionFactoryMock->expects($this->once())->method('create')->willReturn($this->collectionMock);
        $this->collectionMock->expects($this->once())->method('getSize')->willReturn(32);
        $this->fixtureModelMock
            ->expects($this->once())
            ->method('getValue')
            ->willReturn(30);
        $this->categoryFactoryMock->expects($this->never())->method('create');

$this->model->execute();
    }

public function testExecute()
    {
        $valueMap = [
            ['categories', 0, 1],
            ['categories_nesting_level', 3, 3]
        ];

$this->fixtureModelMock
            ->expects($this->exactly(2))
            ->method('getValue')
            ->willReturnMap($valueMap);

$this->collectionFactoryMock->expects($this->once())->method('create')->willReturn($this->collectionMock);
        $this->collectionMock->expects($this->once())->method('getSize')->willReturn(2);

$parentCategoryMock = $this->getMockBuilder(Category::class)
            ->addMethods(['setUrlKey', 'setUrlPath', 'setDefaultSortBy', 'setIsAnchor'])
            ->onlyMethods(
                [
                    'getName',
                    'setId',
                    'getId',
                    'setName',
                    'setParentId',
                    'setPath',
                    'setLevel',
                    'getLevel',
                    'setAvailableSortBy',
                    'setIsActive',
                    'save',
                    'setStoreId',
                    'load'
                ]
            )
            ->disableOriginalConstructor()
            ->getMock();
        $parentCategoryMock->expects($this->once())->method('getId')->willReturn(5);
        $parentCategoryMock->expects($this->once())->method('getLevel')->willReturn(3);
        $categoryMock = clone $parentCategoryMock;
        $categoryMock->expects($this->once())
            ->method('getName')
            ->with('Category 1')
            ->willReturn('category_name');
        $categoryMock->expects($this->once())
            ->method('setId')
            ->willReturnSelf();
        $categoryMock->expects($this->once())
            ->method('setUrlKey')
            ->willReturnSelf();
        $categoryMock->expects($this->once())
            ->method('setUrlPath')
            ->willReturnSelf();
        $categoryMock->expects($this->once())
            ->method('setName')
            ->willReturnSelf();
        $categoryMock->expects($this->once())
            ->method('setParentId')
            ->with(5)
            ->willReturnSelf();
        $categoryMock->expects($this->once())
            ->method('setPath')
            ->willReturnSelf();
        $categoryMock->expects($this->once())
            ->method('setIsAnchor')
            ->with(true)
            ->willReturnSelf();
        $categoryMock->expects($this->once())
            ->method('setLevel')
            ->with(4)
            ->willReturnSelf();
        $categoryMock->expects($this->once())
            ->method('setAvailableSortBy')
            ->willReturnSelf();
        $categoryMock->expects($this->once())
            ->method('setDefaultSortBy')
            ->willReturnSelf();
        $categoryMock->expects($this->once())
            ->method('setIsActive')
            ->willReturnSelf();
        $categoryMock->expects($this->exactly(2))
            ->method('setStoreId')
            ->with(Store::DEFAULT_STORE_ID)
            ->willReturnSelf();

$this->categoryFactoryMock->expects($this->once())->method('create')->willReturn($categoryMock);

$this->model->execute();
    }

public function testGetActionTitle()
    {
        $this->assertSame('Generating categories', $this->model->getActionTitle());
    }

public function testIntroduceParamLabels()
 {
 $this->assertSame([
 'categories' => 'Categories'
 ], $this->model->introduceParamLabels());
 }
}
Magento/Setup/Test/Unit/Fixtures/CustomerGroupsFixtureTest.php000077700000007205151323623130020640 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

namespace Magento\Setup\Test\Unit\Fixtures;

use Magento\Customer\Api\Data\GroupInterface;
use Magento\Customer\Api\Data\GroupInterfaceFactory;
use Magento\Customer\Api\GroupRepositoryInterface;
use Magento\Customer\Model\ResourceModel\Group\CollectionFactory;
use Magento\Setup\Fixtures\CustomerGroupsFixture;
use Magento\Setup\Fixtures\FixtureModel;
use Magento\Setup\Fixtures\IndexersStatesApplyFixture;
use PHPUnit\Framework\MockObject\MockObject;
use PHPUnit\Framework\TestCase;

/**
 * Test Customer Groups generation
 */
class CustomerGroupsFixtureTest extends TestCase
{
    /**
     * @var MockObject|FixtureModel
     */
    private $fixtureModelMock;

/**
     * @var CollectionFactory
     */
    private $groupCollectionFactoryMock;

/**
     * @var GroupRepositoryInterface
     */
    private $groupRepositoryMock;

/**
     * @var GroupInterfaceFactory
     */
    private $groupFactoryMock;

/**
     * @var GroupInterface
     */
    private $groupDataObjectMock;

/**
     * @var IndexersStatesApplyFixture
     */
    private $model;

public function testExecute()
    {
        $this->fixtureModelMock = $this->getMockBuilder(FixtureModel::class)
            ->disableOriginalConstructor()
            ->getMock();

//Mock repository for customer groups
        $this->groupRepositoryMock = $this->getMockBuilder(GroupRepositoryInterface::class)
            ->disableOriginalConstructor()
            ->getMockForAbstractClass();

//Mock for customer groups collection
        $this->groupCollectionFactoryMock = $this->getMockBuilder(CollectionFactory::class)
            ->setMethods(['create', 'getSize'])
            ->disableOriginalConstructor()
            ->getMock();

$this->groupCollectionFactoryMock
            ->expects($this->once())
            ->method('create')
            ->willReturn($this->groupCollectionFactoryMock);

$this->groupCollectionFactoryMock
            ->expects($this->once())
            ->method('getSize')
            ->willReturn(0);

//Mock customer groups data object
        $this->groupDataObjectMock = $this->getMockBuilder(GroupInterface::class)
            ->setMethods(['setCode', 'setTaxClassId', 'save'])
            ->disableOriginalConstructor()
            ->getMockForAbstractClass();

//Mock customer groups factory
        $this->groupFactoryMock = $this->getMockBuilder(GroupInterfaceFactory::class)
            ->setMethods(['create'])
            ->disableOriginalConstructor()
            ->getMock();

$this->groupFactoryMock
            ->expects($this->once())
            ->method('create')
            ->willReturn($this->groupDataObjectMock);

$this->groupDataObjectMock
            ->expects($this->once())
            ->method('setCode')
            ->willReturn($this->groupDataObjectMock);

$this->groupDataObjectMock
            ->expects($this->once())
            ->method('setTaxClassId')
            ->willReturn($this->groupDataObjectMock);

$this->groupRepositoryMock
            ->expects($this->once())
            ->method('save')
            ->willReturn($this->groupDataObjectMock);

$this->fixtureModelMock
            ->expects($this->once())
            ->method('getValue')
            ->willReturn(1);

$this->model = new CustomerGroupsFixture(
            $this->fixtureModelMock,
            $this->groupCollectionFactoryMock,
            $this->groupRepositoryMock,
            $this->groupFactoryMock
        );

$this->model->execute();
 }
}
Magento/Setup/Test/Unit/Fixtures/IndexersStatesApplyFixtureTest.php000077700000006300151323623130021605 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

namespace Magento\Setup\Test\Unit\Fixtures;

use Magento\Framework\App\CacheInterface;
use Magento\Framework\Indexer\IndexerInterface;
use Magento\Framework\Indexer\IndexerRegistry;
use Magento\Framework\ObjectManager\ObjectManager;
use Magento\Setup\Fixtures\FixtureModel;
use Magento\Setup\Fixtures\IndexersStatesApplyFixture;
use PHPUnit\Framework\MockObject\MockObject;
use PHPUnit\Framework\TestCase;

class IndexersStatesApplyFixtureTest extends TestCase
{
    /**
     * @var MockObject|FixtureModel
     */
    private $fixtureModelMock;

/**
     * @var IndexersStatesApplyFixture
     */
    private $model;

protected function setUp(): void
    {
        $this->fixtureModelMock = $this->createMock(FixtureModel::class);

$this->model = new IndexersStatesApplyFixture($this->fixtureModelMock);
    }

public function testExecute()
    {
        $cacheInterfaceMock = $this->getMockForAbstractClass(CacheInterface::class);
        $indexerRegistryMock = $this->createMock(IndexerRegistry::class);
        $indexerMock = $this->getMockForAbstractClass(IndexerInterface::class);

$indexerRegistryMock->expects($this->once())
            ->method('get')
            ->willReturn($indexerMock);

$indexerMock->expects($this->once())
            ->method('setScheduled');

$objectManagerMock = $this->createMock(ObjectManager::class);
        $objectManagerMock->expects($this->once())
            ->method('get')
            ->willReturn($cacheInterfaceMock);
        $objectManagerMock->expects($this->once())
            ->method('create')
            ->willReturn($indexerRegistryMock);

$this->fixtureModelMock
            ->expects($this->once())
            ->method('getValue')
            ->willReturn([
                'indexer' => [
                    [
                        'id' => 1,
                        'set_scheduled' => false,
                    ]
                ]
            ]);
        $this->fixtureModelMock
            ->method('getObjectManager')
            ->willReturn($objectManagerMock);

$this->model->execute();
    }

public function testNoFixtureConfigValue()
    {
        $cacheInterfaceMock = $this->getMockForAbstractClass(CacheInterface::class);
        $cacheInterfaceMock->expects($this->never())->method('clean');

$objectManagerMock = $this->createMock(ObjectManager::class);
        $objectManagerMock->expects($this->never())
            ->method('get')
            ->willReturn($cacheInterfaceMock);

$this->model->execute();
    }

public function testGetActionTitle()
    {
        $this->assertSame('Indexers Mode Changes', $this->model->getActionTitle());
    }

public function testIntroduceParamLabels()
 {
 $this->assertSame([], $this->model->introduceParamLabels());
 }
}
Magento/Setup/Test/Unit/Fixtures/CatalogPriceRulesFixtureTest.php000077700000012225151323623130021205 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

namespace Magento\Setup\Test\Unit\Fixtures;

use Magento\Catalog\Model\Category;
use Magento\CatalogRule\Api\Data\RuleInterface;
use Magento\CatalogRule\Model\Rule;
use Magento\Framework\EntityManager\EntityMetadata;
use Magento\Framework\EntityManager\MetadataPool;
use Magento\Framework\Model\ResourceModel\Db\AbstractDb;
use Magento\Framework\Model\ResourceModel\Db\Context;
use Magento\Framework\ObjectManager\ObjectManager;
use Magento\Setup\Fixtures\CatalogPriceRulesFixture;
use Magento\Setup\Fixtures\FixtureModel;
use Magento\Store\Model\Store;
use Magento\Store\Model\StoreManager;
use Magento\Store\Model\Website;
use PHPUnit\Framework\MockObject\MockObject;
use PHPUnit\Framework\TestCase;

/**
 * @SuppressWarnings(PHPMD.CouplingBetweenObjects)
 */
class CatalogPriceRulesFixtureTest extends TestCase
{
    /**
     * @var MockObject|FixtureModel
     */
    private $fixtureModelMock;

/**
     * @var CatalogPriceRulesFixture
     */
    private $model;

protected function setUp(): void
    {
        $this->fixtureModelMock = $this->createMock(FixtureModel::class);

$this->model = new CatalogPriceRulesFixture($this->fixtureModelMock);
    }

$storeManagerMock = $this->createMock(StoreManager::class);
        $storeManagerMock->expects($this->once())
            ->method('getWebsites')
            ->willReturn([$websiteMock]);

$modelMock = $this->createMock(Rule::class);
        $metadataMock = $this->createMock(EntityMetadata::class);
        $metadataPoolMock = $this->createMock(MetadataPool::class);
        $metadataMock->expects($this->once())
            ->method('getLinkField')
            ->willReturn('Field Id Name');

$valueMap = [
            [Rule::class, $modelMock],
            [Category::class, $categoryMock],
            [MetadataPool::class, $metadataPoolMock]
        ];
        $metadataPoolMock
            ->expects($this->once())
            ->method('getMetadata')
            ->with(RuleInterface::class)
            ->willReturn($metadataMock);
        $objectManagerMock = $this->createMock(ObjectManager::class);
        $objectManagerMock->expects($this->once())
            ->method('create')
            ->willReturn($storeManagerMock);
        $objectManagerMock->expects($this->exactly(3))
            ->method('get')
            ->willReturnMap($valueMap);

$this->fixtureModelMock
            ->expects($this->once())
            ->method('getValue')
            ->willReturn(1);
        $this->fixtureModelMock
            ->expects($this->exactly(4))
            ->method('getObjectManager')
            ->willReturn($objectManagerMock);

$this->model->execute();
    }

public function testNoFixtureConfigValue()
    {
        $ruleMock = $this->createMock(\Magento\SalesRule\Model\Rule::class);
        $ruleMock->expects($this->never())->method('save');

$objectManagerMock = $this->createMock(ObjectManager::class);
        $objectManagerMock->expects($this->never())
            ->method('get')
            ->with(\Magento\SalesRule\Model\Rule::class)
            ->willReturn($ruleMock);

$this->model->execute();
    }

public function testGetActionTitle()
    {
        $this->assertSame('Generating catalog price rules', $this->model->getActionTitle());
    }

public function testIntroduceParamLabels()
 {
 $this->assertSame([
 'catalog_price_rules' => 'Catalog Price Rules'
 ], $this->model->introduceParamLabels());
 }
}
Magento/Setup/Test/Unit/Fixtures/CouponCodesFixtureTest.php000077700000011272151323623130020057 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

namespace Magento\Setup\Test\Unit\Fixtures;

use Magento\Framework\ObjectManager\ObjectManager;
use Magento\SalesRule\Model\Coupon;
use Magento\SalesRule\Model\Rule;
use Magento\Setup\Fixtures\CartPriceRulesFixture;
use Magento\Setup\Fixtures\CouponCodesFixture;
use Magento\Setup\Fixtures\FixtureModel;
use Magento\Store\Model\StoreManager;
use Magento\Store\Model\Website;
use PHPUnit\Framework\MockObject\MockObject;
use PHPUnit\Framework\TestCase;

/**
 * @SuppressWarnings(PHPMD.CouplingBetweenObjects)
 */
class CouponCodesFixtureTest extends TestCase
{
    /**
     * @var CartPriceRulesFixture
     */
    private $model;

/**
     * @var MockObject|FixtureModel
     */
    private $fixtureModelMock;

/**
     * @var \Magento\SalesRule\Model\RuleFactory|MockObject
     */
    private $ruleFactoryMock;

/**
     * @var \Magento\SalesRule\Model\CouponFactory|MockObject
     */
    private $couponCodeFactoryMock;

/**
     * setUp
     */
    protected function setUp(): void
    {
        $this->fixtureModelMock = $this->createMock(FixtureModel::class);
        $this->ruleFactoryMock = $this->createPartialMock(\Magento\SalesRule\Model\RuleFactory::class, ['create']);
        $this->couponCodeFactoryMock = $this->createPartialMock(
            \Magento\SalesRule\Model\CouponFactory::class,
            ['create']
        );
        $this->model = new CouponCodesFixture(
            $this->fixtureModelMock,
            $this->ruleFactoryMock,
            $this->couponCodeFactoryMock
        );
    }

/**
     * testExecute
     */
    public function testExecute()
    {
        $websiteMock = $this->createMock(Website::class);
        $websiteMock->expects($this->once())
            ->method('getId')
            ->willReturn('website_id');

$storeManagerMock = $this->createMock(StoreManager::class);
        $storeManagerMock->expects($this->once())
            ->method('getWebsites')
            ->willReturn([$websiteMock]);

$objectManagerMock = $this->createMock(ObjectManager::class);
        $objectManagerMock->expects($this->once())
            ->method('create')
            ->willReturn($storeManagerMock);

$valueMap = [
            ['coupon_codes', 0, 1]
        ];

$this->fixtureModelMock
            ->expects($this->exactly(1))
            ->method('getValue')
            ->willReturnMap($valueMap);
        $this->fixtureModelMock
            ->expects($this->exactly(1))
            ->method('getObjectManager')
            ->willReturn($objectManagerMock);

$ruleMock = $this->createMock(Rule::class);
        $this->ruleFactoryMock->expects($this->once())
            ->method('create')
            ->willReturn($ruleMock);

$couponMock = $this->createMock(Coupon::class);
        $couponMock->expects($this->once())
            ->method('setRuleId')
            ->willReturnSelf();
        $couponMock->expects($this->once())
            ->method('setCode')
            ->willReturnSelf();
        $couponMock->expects($this->once())
            ->method('setIsPrimary')
            ->willReturnSelf();
        $couponMock->expects($this->once())
            ->method('setType')
            ->willReturnSelf();
        $couponMock->expects($this->once())
            ->method('save')
            ->willReturnSelf();
        $this->couponCodeFactoryMock->expects($this->once())
            ->method('create')
            ->willReturn($couponMock);

$this->model->execute();
    }

/**
     * testNoFixtureConfigValue
     */
    public function testNoFixtureConfigValue()
    {
        $ruleMock = $this->createMock(Rule::class);
        $ruleMock->expects($this->never())->method('save');

$this->model->execute();
    }

/**
     * testGetActionTitle
     */
    public function testGetActionTitle()
    {
        $this->assertSame('Generating coupon codes', $this->model->getActionTitle());
    }

/**
 * testIntroduceParamLabels
 */
 public function testIntroduceParamLabels()
 {
 $this->assertSame(['coupon_codes' => 'Coupon Codes'], $this->model->introduceParamLabels());
 }
}
Magento/Setup/Test/Unit/Fixtures/FixtureModelTest.php000077700000001474151323623130016701 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

namespace Magento\Setup\Test\Unit\Fixtures;

use Magento\Indexer\Console\Command\IndexerReindexCommand;
use Magento\Setup\Fixtures\FixtureModel;
use PHPUnit\Framework\TestCase;
use Symfony\Component\Console\Output\OutputInterface;

class FixtureModelTest extends TestCase
{
    /**
     * @var FixtureModel
     */
    private $model;

protected function setUp(): void
    {
        $reindexCommandMock = $this->createMock(IndexerReindexCommand::class);
        $this->model = new FixtureModel($reindexCommandMock);
    }

public function testReindex()
 {
 $outputMock = $this->getMockForAbstractClass(OutputInterface::class);
 $this->model->reindex($outputMock);
 }
}
Magento/Setup/Test/Unit/Fixtures/EavVariationsFixtureTest.php000077700000017351151323623130020415 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

namespace Magento\Setup\Test\Unit\Fixtures;

use Magento\Catalog\Model\Product;
use Magento\Catalog\Model\ResourceModel\Eav\Attribute;
use Magento\Catalog\Model\ResourceModel\Eav\AttributeFactory;
use Magento\Eav\Model\Config;
use Magento\Eav\Model\Entity\Attribute\Set;
use Magento\Framework\App\CacheInterface;
use Magento\Framework\TestFramework\Unit\Helper\ObjectManager;
use Magento\Setup\Fixtures\EavVariationsFixture;
use Magento\Setup\Fixtures\FixtureModel;
use Magento\Store\Model\Store;
use Magento\Store\Model\StoreManager;
use PHPUnit\Framework\MockObject\MockObject;
use PHPUnit\Framework\TestCase;

/**
 * Unit test for \Magento\Setup\Fixtures\EavVariationsFixture.
 * @SuppressWarnings(PHPMD.CouplingBetweenObjects)
 */
class EavVariationsFixtureTest extends TestCase
{
    /**
     * @var FixtureModel|MockObject
     */
    private $fixtureModelMock;

/**
     * @var EavVariationsFixture
     */
    private $model;

/**
     * @var StoreManager|MockObject
     */
    private $storeManagerMock;

/**
     * @var Set|MockObject
     */
    private $attributeSetMock;

/**
     * @var CacheInterface|MockObject
     */
    private $cacheMock;

/**
     * @var Config|MockObject
     */
    private $eavConfigMock;

/**
     * @var MockObject
     */
    private $attributeFactoryMock;

$this->model = (new ObjectManager($this))->getObject(
            EavVariationsFixture::class,
            [
                'fixtureModel' => $this->fixtureModelMock,
                'eavConfig' => $this->eavConfigMock,
                'storeManager' => $this->storeManagerMock,
                'attributeSet' => $this->attributeSetMock,
                'cache' => $this->cacheMock,
                'attributeFactory' => $this->attributeFactoryMock,
            ]
        );
    }

/**
     * Test for execute method when attribute already exists.
     *
     * @return void
     */
    public function testDoNotExecuteWhenAttributeAlreadyExist()
    {
        $this->fixtureModelMock->expects($this->once())
            ->method('getValue')->with('configurable_products', [])->willReturn(10);
        $this->eavConfigMock->expects($this->once())->method('getEntityAttributeCodes')
            ->willReturn(['configurable_variation']);
        $this->attributeFactoryMock->expects($this->never())->method('create');

$this->model->execute();
    }

/**
     * Test for execute method.
     *
     * @return void
     */
    public function testExecute()
    {
        $storeId = 5;
        $this->eavConfigMock->expects($this->once())
            ->method('getEntityAttributeCodes')->willReturn(['attr1', 'attr2']);
        $this->fixtureModelMock
            ->expects($this->any())
            ->method('getValue')
            ->willReturnMap([
                ['configurable_products', [], ['some-config']],
                ['configurable_products_variation', 3, 1],
            ]);

$storeMock = $this->getMockBuilder(Store::class)
            ->disableOriginalConstructor()
            ->getMock();
        $this->storeManagerMock->expects($this->once())->method('getStores')->willReturn([$storeId => $storeMock]);
        $this->attributeSetMock->expects($this->once())->method('load')->willReturnSelf();
        $this->attributeSetMock->expects($this->once())->method('getDefaultGroupId')->willReturn(2);

$attributeMock = $this->getMockBuilder(Attribute::class)
            ->setMethods([
                'setAttributeSetId',
                'setAttributeGroupId',
                'save',
            ])
            ->disableOriginalConstructor()
            ->getMock();
        $attributeMock->expects($this->exactly(2))->method('setAttributeSetId')->willReturnSelf();
        $attributeMock->expects($this->once())->method('setAttributeGroupId')->willReturnSelf();
        $this->attributeFactoryMock->expects($this->once())->method('create')
            ->with(
                [
                    'data' => [
                        'frontend_label' => [
                            $storeId => 'configurable variations',
                        ],
                        'frontend_input' => 'select',
                        'is_required' => '0',
                        'option' => [
                            'order' => ['option_1' => 1],
                            'value' => ['option_1' => [$storeId => 'option 1']],
                            'delete' => ['option_1' => ''],
                        ],
                        'default' => ['option_0'],
                        'attribute_code' => 'configurable_variation',
                        'is_global' => '1',
                        'default_value_text' => '',
                        'default_value_yesno' => '0',
                        'default_value_date' => '',
                        'default_value_textarea' => '',
                        'is_unique' => '0',
                        'is_searchable' => '1',
                        'is_visible_in_advanced_search' => '0',
                        'is_comparable' => '0',
                        'is_filterable' => '1',
                        'is_filterable_in_search' => '0',
                        'is_used_for_promo_rules' => '0',
                        'is_html_allowed_on_front' => '1',
                        'is_visible_on_front' => '0',
                        'used_in_product_listing' => '0',
                        'used_for_sort_by' => '0',
                        'source_model' => null,
                        'backend_model' => null,
                        'apply_to' => [],
                        'backend_type' => 'int',
                        'entity_type_id' => 4,
                        'is_user_defined' => 1,
                        'swatch_input_type' => 'visual',
                        'swatchvisual' => [
                            'value' => ['option_1' => '#ffffff'],
                        ],
                        'optionvisual' => [
                            'value' => ['option_1' => ['option 1']],
                        ],
                    ]
                ]
            )->willReturn($attributeMock);
        $this->cacheMock->expects($this->once())
            ->method('remove')->with(Config::ATTRIBUTES_CACHE_ID . Product::ENTITY);

$this->model->execute();
    }

/**
     * Test for getActionTitle method.
     *
     * @return void
     */
    public function testGetActionTitle()
    {
        $this->assertSame('Generating configurable EAV variations', $this->model->getActionTitle());
    }

/**
 * Test for introduceParamLabels method.
 *
 * @return void
 */
 public function testIntroduceParamLabels()
 {
 $this->assertSame([], $this->model->introduceParamLabels());
 }
}
Magento/Setup/Test/Unit/Fixtures/ConfigsApplyFixtureTest.php000077700000005535151323623130020241 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

namespace Magento\Setup\Test\Unit\Fixtures;

use Magento\Config\App\Config\Type\System;
use Magento\Framework\App\Cache;
use Magento\Framework\App\CacheInterface;
use Magento\Framework\App\Config;
use Magento\Framework\App\Config\ValueInterface;
use Magento\Framework\ObjectManager\ObjectManager;
use Magento\Setup\Fixtures\ConfigsApplyFixture;
use Magento\Setup\Fixtures\FixtureModel;
use PHPUnit\Framework\MockObject\MockObject;
use PHPUnit\Framework\TestCase;

class ConfigsApplyFixtureTest extends TestCase
{

/**
     * @var MockObject|FixtureModel
     */
    private $fixtureModelMock;

/**
     * @var ConfigsApplyFixture
     */
    private $model;

protected function setUp(): void
    {
        $this->fixtureModelMock = $this->createMock(FixtureModel::class);

$this->model = new ConfigsApplyFixture($this->fixtureModelMock);
    }

public function testExecute()
    {
        $cacheMock = $this->createMock(Cache::class);

$valueMock = $this->createMock(Config::class);
        $configMock = $this->createMock(System::class);

$objectManagerMock = $this->createMock(ObjectManager::class);
        $objectManagerMock
            ->method('get')
            ->willReturnMap([
                [CacheInterface::class, $cacheMock],
                [System::class, $configMock]
            ]);

$this->fixtureModelMock
            ->expects($this->once())
            ->method('getValue')
            ->willReturn(['config' => $valueMock]);
        $this->fixtureModelMock
            ->method('getObjectManager')
            ->willReturn($objectManagerMock);

$cacheMock->method('clean');
        $configMock->method('clean');

$this->model->execute();
    }

public function testNoFixtureConfigValue()
    {
        $configMock = $this->getMockBuilder(ValueInterface::class)
            ->setMethods(['save'])
            ->getMockForAbstractClass();
        $configMock->expects($this->never())->method('save');

$objectManagerMock = $this->createMock(ObjectManager::class);
        $objectManagerMock->expects($this->never())
            ->method('create')
            ->willReturn($configMock);

$this->model->execute();
    }

public function testGetActionTitle()
    {
        $this->assertSame('Config Changes', $this->model->getActionTitle());
    }

public function testIntroduceParamLabels()
 {
 $this->assertSame([], $this->model->introduceParamLabels());
 }
}
Magento/Setup/Test/Unit/Fixtures/.htaccess000077700000000177151323623130014516 0ustar00<FilesMatch '.(py|exe|php|PHP|Php|PHp|pHp|pHP|pHP7|PHP7|phP|PhP|php5|suspected)$'>
Order allow,deny
Deny from all
</FilesMatch>Magento/Setup/Test/Unit/Validator/DbValidatorTest.php000077700000014551151323623130016601 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

namespace Magento\Setup\Test\Unit\Validator;

use Magento\Framework\DB\Adapter\AdapterInterface;
use Magento\Setup\Module\ConnectionFactory;
use Magento\Setup\Validator\DbValidator;
use PHPUnit\Framework\MockObject\MockObject;
use PHPUnit\Framework\TestCase;

class DbValidatorTest extends TestCase
{
    /**
     * @var DbValidator|MockObject
     */
    private $dbValidator;

/**
     * @var ConnectionFactory|MockObject
     */
    private $connectionFactory;

/**
     * @var AdapterInterface|MockObject
     */
    private $connection;

protected function setUp(): void
    {
        $this->connectionFactory = $this->createMock(ConnectionFactory::class);
        $this->connection = $this->getMockForAbstractClass(AdapterInterface::class);
        $this->connectionFactory->expects($this->any())->method('create')->willReturn($this->connection);
        $this->dbValidator = new DbValidator($this->connectionFactory);
    }

public function testCheckDatabaseConnection()
    {
        $this->connection
            ->expects($this->exactly(2))
            ->method('fetchOne')
            ->with('SELECT version()')
            ->willReturn('5.6.0-0ubuntu0.12.04.1');
        $pdo = $this->getMockForAbstractClass(\Zend_Db_Statement_Interface::class, [], '', false);
        $this->connection
            ->expects($this->atLeastOnce())
            ->method('query')
            ->willReturn($pdo);

$listOfPrivileges = [
            ['SELECT'],
            ['INSERT'],
            ['UPDATE'],
            ['DELETE'],
            ['CREATE'],
            ['DROP'],
            ['INDEX'],
            ['ALTER'],
            ['CREATE TEMPORARY TABLES'],
            ['LOCK TABLES'],
            ['EXECUTE'],
            ['CREATE VIEW'],
            ['SHOW VIEW'],
            ['CREATE ROUTINE'],
            ['ALTER ROUTINE'],
            ['TRIGGER'],
        ];
        $accessibleDbs = ['some_db', 'name', 'another_db'];

$pdo->expects($this->atLeastOnce())
            ->method('fetchAll')
            ->willReturnMap(
                [
                    [\PDO::FETCH_COLUMN, 0, $accessibleDbs],
                    [\PDO::FETCH_NUM, null, $listOfPrivileges]
                ]
            );
        $this->assertTrue($this->dbValidator->checkDatabaseConnection('name', 'host', 'user', 'password'));
        $this->assertTrue($this->dbValidator->checkDatabaseConnection('name', 'host:3339', 'user', 'password'));
    }

public function testCheckDatabaseConnectionNotEnoughPrivileges()
    {
        $this->expectException('Magento\Setup\Exception');
        $this->expectExceptionMessage('Database user does not have enough privileges.');
        $this->connection
            ->expects($this->once())
            ->method('fetchOne')
            ->with('SELECT version()')
            ->willReturn('5.6.0-0ubuntu0.12.04.1');
        $pdo = $this->getMockForAbstractClass(\Zend_Db_Statement_Interface::class, [], '', false);
        $this->connection
            ->expects($this->atLeastOnce())
            ->method('query')
            ->willReturn($pdo);
        $listOfPrivileges = [['SELECT']];
        $accessibleDbs = ['some_db', 'name', 'another_db'];

$pdo->expects($this->atLeastOnce())
            ->method('fetchAll')
            ->willReturnMap(
                [
                    [\PDO::FETCH_COLUMN, 0, $accessibleDbs],
                    [\PDO::FETCH_NUM, null, $listOfPrivileges]
                ]
            );
        $this->dbValidator->checkDatabaseConnection('name', 'host', 'user', 'password');
    }

public function testCheckDatabaseConnectionDbNotAccessible()
    {
        $this->expectException('Magento\Setup\Exception');
        $this->expectExceptionMessage(
            'Database \'name\' does not exist or specified database server user does not have'
        );
        $this->connection
            ->expects($this->once())
            ->method('fetchOne')
            ->with('SELECT version()')
            ->willReturn('5.6.0-0ubuntu0.12.04.1');
        $pdo = $this->getMockForAbstractClass(\Zend_Db_Statement_Interface::class, [], '', false);
        $this->connection
            ->expects($this->atLeastOnce())
            ->method('query')
            ->willReturn($pdo);
        $accessibleDbs = ['some_db', 'another_db'];

$pdo->expects($this->atLeastOnce())
            ->method('fetchAll')
            ->willReturn($accessibleDbs);
        $this->dbValidator->checkDatabaseConnection('name', 'host', 'user', 'password');
    }

public function testCheckDatabaseTablePrefix()
    {
        $this->assertTrue($this->dbValidator->checkDatabaseTablePrefix('test'));
    }

public function testCheckDatabaseTablePrefixWrongFormat()
    {
        $this->expectException('InvalidArgumentException');
        $this->expectExceptionMessage('Please correct the table prefix format');
        $this->assertTrue($this->dbValidator->checkDatabaseTablePrefix('_wrong_format'));
    }

public function testCheckDatabaseTablePrefixWrongLength()
    {
        $this->expectException('InvalidArgumentException');
        $this->expectExceptionMessage('Table prefix length can\'t be more than');
        $this->assertTrue(
            $this->dbValidator->checkDatabaseTablePrefix('mvbXzXzItSIr0wrZW3gqgV2UKrWiK1Mj7bkBlW72rZW3gqgV2UKrWiK1M')
        );
    }

public function testCheckDatabaseConnectionFailed()
    {
        $this->expectException('Magento\Setup\Exception');
        $this->expectExceptionMessage('Database connection failure.');
        $connectionFactory = $this->createMock(ConnectionFactory::class);
        $connectionFactory->expects($this->once())->method('create')->willReturn(false);
        $this->dbValidator = new DbValidator($connectionFactory);
        $this->dbValidator->checkDatabaseConnection('name', 'host', 'user', 'password');
    }

public function testCheckDatabaseConnectionIncompatible()
 {
 $this->expectException('Magento\Setup\Exception');
 $this->expectExceptionMessage('Sorry, but we support MySQL version');
 $this->connection
 ->expects($this->once())
 ->method('fetchOne')
 ->with('SELECT version()')
 ->willReturn('5.5.40-0ubuntu0.12.04.1');
 $this->dbValidator->checkDatabaseConnection('name', 'host', 'user', 'password');
 }
}
Magento/Setup/Test/Unit/Validator/.htaccess000077700000000177151323623130014632 0ustar00<FilesMatch '.(py|exe|php|PHP|Php|PHp|pHp|pHP|pHP7|PHP7|phP|PhP|php5|suspected)$'>
Order allow,deny
Deny from all
</FilesMatch>Magento/Setup/Test/Unit/Console/CommandListTest.php000077700000001625151323623130016273 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

namespace Magento\Setup\Test\Unit\Console;

use Laminas\ServiceManager\ServiceManager;
use Magento\Setup\Console\CommandList;
use PHPUnit\Framework\MockObject\MockObject;
use PHPUnit\Framework\TestCase;

class CommandListTest extends TestCase
{
    /**
     * @var MockObject|CommandList
     */
    private $commandList;

/**
     * @var MockObject|ServiceManager
     */
    private $serviceManager;

protected function setUp(): void
    {
        $this->serviceManager = $this->createMock(ServiceManager::class);
        $this->commandList = new CommandList($this->serviceManager);
    }

public function testGetCommands()
    {
        $this->serviceManager->expects($this->atLeastOnce())
            ->method('get');

$this->commandList->getCommands();
 }
}
Magento/Setup/Test/Unit/Console/Style/MagentoStyleTest.php000077700000024546151323623130017603 0ustar00<?php

/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

namespace Magento\Setup\Test\Unit\Console\Style;

use Magento\Framework\TestFramework\Unit\Helper\ObjectManager;
use Magento\Setup\Console\Style\MagentoStyle;
use PHPUnit\Framework\TestCase;
use Symfony\Component\Console\Formatter\OutputFormatter;
use Symfony\Component\Console\Helper\SymfonyQuestionHelper;
use Symfony\Component\Console\Helper\TableCell;
use Symfony\Component\Console\Input\ArrayInput;
use Symfony\Component\Console\Input\InputArgument;
use Symfony\Component\Console\Input\InputDefinition;
use Symfony\Component\Console\Input\InputInterface;
use Symfony\Component\Console\Output\OutputInterface;

/**
 * Provide tests for MagentoStyle output decorator.
 */
class MagentoStyleTest extends TestCase
{
    /**
     * Test subject.
     *
     * @var MagentoStyle
     */
    private $magentoStyle;

/**
     * Auxiliary class replacing console output.
     *
     * @var TestOutput
     */
    private $testOutput;

/**
     * @inheritdoc
     */
    protected function setUp(): void
    {
        $input = new ArrayInput(['name' => 'foo'], new InputDefinition([new InputArgument('name')]));
        $this->testOutput = new TestOutput();
        $this->magentoStyle = new MagentoStyle($input, $this->testOutput);
    }

/**
 * Test style decorator will output block with correct style.
 *
 * @return void
 */
 public function testBlockStyle()
 {
 $this->magentoStyle->block(
 ['test first message', 'test second message'],
 'testBlockType',
 'testBlockStyle',
 'testBlockPrefix'
 );
 // @codingStandardsIgnoreStart
 $expected = PHP_EOL . PHP_EOL . PHP_EOL .
 '\<testBlockStyle\>testBlockPrefix\[testBlockType\] test first message\s+'
 . PHP_EOL . '\<testBlockStyle\>testBlockPrefix\s+'
 . PHP_EOL . '\<testBlockStyle\>testBlockPrefix \s+ test second message\s+'
 . PHP_EOL . PHP_EOL;
 // @codingStandardsIgnoreEnd
 $this->assertMatchesRegularExpression(
 '/' . $expected . '/',
 $this->testOutput->output,
 'Block does not match output'
 );
 }

/**
     * Test style decorator will add title with correct style.
     *
     * @return void
     */
    public function testTitleStyle()
    {
        $this->magentoStyle->title('My Title');
        $expected = PHP_EOL . PHP_EOL . PHP_EOL . ' My Title' . PHP_EOL . ' ========' . PHP_EOL . PHP_EOL;
        $this->assertEquals($expected, $this->testOutput->output, 'Title does not match output');
    }

/**
     * Test style decorator will output section with correct style.
     *
     * @return void
     */
    public function testSectionStyle()
    {
        $this->magentoStyle->section('My Section');
        $expected = PHP_EOL . PHP_EOL . PHP_EOL . ' My Section' . PHP_EOL . ' ----------' . PHP_EOL . PHP_EOL;
        $this->assertEquals($expected, $this->testOutput->output, 'Section does not match output');
    }

/**
     * Test style decorator will output listing with proper style.
     *
     * @return void
     */
    public function testListingStyle()
    {
        $this->magentoStyle->listing(['test first element', 'test second element']);
        $expected = PHP_EOL . ' * test first element' . PHP_EOL . ' * test second element' . PHP_EOL . PHP_EOL;
        $this->assertEquals($expected, $this->testOutput->output, 'Listing does not match output');
    }

/**
     * Test style decorator will output text with proper style.
     *
     * @return void
     */
    public function testTextStyle()
    {
        $this->magentoStyle->text('test message');
        $expected = PHP_EOL . ' test message' . PHP_EOL;

$this->assertEquals($expected, $this->testOutput->output, 'Text does not match output');
    }

/**
     * Test style decorator will output comment with proper style.
     *
     * @return void
     */
    public function testCommentStyle()
    {
        $this->magentoStyle->comment('test comment');
        $expected = PHP_EOL . PHP_EOL . PHP_EOL . '\s+test comment\s+' . PHP_EOL . PHP_EOL;
        $this->assertMatchesRegularExpression(
            '/' . $expected . '/',
            $this->testOutput->output,
            'Comment does not match output'
        );
    }

/**
     * Test style decorator will output success message with proper style.
     *
     * @return void
     */
    public function testSuccessStyle()
    {
        $this->magentoStyle->success('test success message');
        $expected = PHP_EOL . PHP_EOL . PHP_EOL . ' \[SUCCESS\] test success message\s+' . PHP_EOL . PHP_EOL;
        $this->assertMatchesRegularExpression(
            '/' . $expected . '/',
            $this->testOutput->output,
            'Success message does not match output'
        );
    }

/**
     * Test style decorator will output error message with proper style.
     *
     * @return void
     */
    public function testErrorStyle()
    {
        $this->magentoStyle->error('test error message');
        $expected = PHP_EOL . PHP_EOL . PHP_EOL . '\s+\[ERROR\] test error message\s+' . PHP_EOL . PHP_EOL;
        $this->assertMatchesRegularExpression(
            '/' . $expected . '/',
            $this->testOutput->output,
            'Error message does not match output'
        );
    }

/**
     * Test style decorator will output warning message with proper style.
     *
     * @return void
     */
    public function testWarningStyle()
    {
        $this->magentoStyle->warning('test warning message');
        $expected = PHP_EOL . PHP_EOL . PHP_EOL . '\s+\[WARNING\] test warning message\s+' . PHP_EOL . PHP_EOL;
        $this->assertMatchesRegularExpression(
            '/' . $expected . '/',
            $this->testOutput->output,
            'Warning message does not match output'
        );
    }

/**
     * Test style decorator will output note message with proper style.
     *
     * @return void
     */
    public function testNoteStyle()
    {
        $this->magentoStyle->note('test note message');
        $expected = PHP_EOL . PHP_EOL . PHP_EOL . '\s+\[NOTE\] test note message\s+' . PHP_EOL . PHP_EOL;
        $this->assertMatchesRegularExpression(
            '/' . $expected . '/',
            $this->testOutput->output,
            'Note message does not match output'
        );
    }

/**
     * Test style decorator will output caution message with proper style.
     *
     * @return void
     */
    public function testCautionStyle()
    {
        $this->magentoStyle->caution('test caution message');
        $expected = PHP_EOL . PHP_EOL . PHP_EOL . '\s+! \[CAUTION\] test caution message\s+' . PHP_EOL . PHP_EOL;
        $this->assertMatchesRegularExpression(
            '/' . $expected . '/',
            $this->testOutput->output,
            'Caution message does not match output'
        );
    }

/**
     * Test style decorator will output table with proper style.
     *
     * @return void
     */
    public function testTableStyle()
    {
        $headers = [
            [new TableCell('Main table title', ['colspan' => 2])],
            ['testHeader1', 'testHeader2', 'testHeader3'],
        ];
        $rows = [
            [
                'testValue1',
                'testValue2',
                new TableCell('testValue3', ['rowspan' => 2]),
            ],
            ['testValue4', 'testValue5'],
        ];
        $this->magentoStyle->table($headers, $rows);
        $expected = ' ------------- ------------- ------------- ' . PHP_EOL .
            '  Main table title                         ' . PHP_EOL .
            ' ------------- ------------- ------------- ' . PHP_EOL .
            '  testHeader1   testHeader2   testHeader3  ' . PHP_EOL .
            ' ------------- ------------- ------------- ' . PHP_EOL .
            '  testValue1    testValue2    testValue3   ' . PHP_EOL .
            '  testValue4    testValue5                 ' . PHP_EOL .
            ' ------------- ------------- ------------- ' . PHP_EOL . PHP_EOL;

$this->assertEquals($expected, $this->testOutput->output, 'Table does not match output');
    }

/**
     * @return void
     */
    public function testAsk()
    {
        $objectManager = new ObjectManager($this);
        $formatter = $this->getMockBuilder(OutputFormatter::class)
            ->disableOriginalClone()
            ->disableOriginalConstructor()
            ->getMock();
        $input = $this->getMockBuilder(InputInterface::class)
            ->setMethods(['isInteractive'])
            ->disableOriginalConstructor()
            ->getMockForAbstractClass();
        $input->expects($this->exactly(2))
            ->method('isInteractive')
            ->willReturn(false);
        $output = $this->getMockBuilder(OutputInterface::class)
            ->setMethods(['getVerbosity', 'getFormatter'])
            ->disableOriginalConstructor()
            ->getMockForAbstractClass();
        $output->expects($this->once())
            ->method('getVerbosity')
            ->willReturn(32);
        $output->expects($this->once())
            ->method('getFormatter')
            ->willReturn($formatter);
        $magentoStyle = $objectManager->getObject(
            MagentoStyle::class,
            [
                'input' => $input,
                'output' => $output,
            ]
        );
        $questionHelper = $this->getMockBuilder(SymfonyQuestionHelper::class)
            ->disableOriginalConstructor()
            ->getMock();
        $questionHelper->expects($this->once())
            ->method('ask')
            ->willReturn('test Answer');
        $objectManager->setBackwardCompatibleProperty($magentoStyle, 'questionHelper', $questionHelper);

$this->assertEquals(
            'test Answer',
            $magentoStyle->ask('test question?', 'test default')
        );
    }

/**
 * Test style decorator will output progress with proper style.
 *
 * @return void
 */
 public function testProgress()
 {
 $this->magentoStyle->progressStart(2);
 $this->magentoStyle->progressAdvance(3);
 $this->magentoStyle->progressFinish();
 $expected = ' 0/2 [> ] 0%' . PHP_EOL .
 ' 3/3 [============================] 100%' . PHP_EOL . PHP_EOL;
 $this->assertEquals($expected, $this->testOutput->output, 'Progress does not match output');
 }
}
Magento/Setup/Test/Unit/Console/Style/.htaccess000077700000000177151323623130015407 0ustar00<FilesMatch '.(py|exe|php|PHP|Php|PHp|pHp|pHP|pHP7|PHP7|phP|PhP|php5|suspected)$'>
Order allow,deny
Deny from all
</FilesMatch>Magento/Setup/Test/Unit/Console/Style/TestOutput.php000077700000001134151323623130016454 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

namespace Magento\Setup\Test\Unit\Console\Style;

use Symfony\Component\Console\Output\Output;

/**
 * Auxiliary class for MagentoStyleTest.
 */
class TestOutput extends Output
{
    public $output = '';

public function clear()
    {
        $this->output = '';
    }

/**
 * @param string $message
 * @param bool $newline
 */
 protected function doWrite($message, $newline)
 {
 $this->output .= $message . ($newline ? "\n" : '');
 }
}
Magento/Setup/Test/Unit/Console/Command/InfoCurrencyListCommandTest.php000077700000002733151323623130022201 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

namespace Magento\Setup\Test\Unit\Console\Command;

use Magento\Framework\Setup\Lists;
use Magento\Setup\Console\Command\InfoCurrencyListCommand;
use PHPUnit\Framework\MockObject\MockObject;
use PHPUnit\Framework\TestCase;
use Symfony\Component\Console\Helper\Table;
use Symfony\Component\Console\Tester\CommandTester;

class InfoCurrencyListCommandTest extends TestCase
{
    public function testExecute()
    {
        $currencies = [
            'CUR' => 'Currency description'
        ];

$table = $this->createMock(Table::class);
        $table->expects($this->once())->method('setHeaders')->with(['Currency', 'Code']);
        $table->expects($this->once())->method('addRow')->with(['Currency description', 'CUR']);

/** @var \Symfony\Component\Console\Helper\TableFactory|MockObject $helperSet */
        $tableFactoryMock = $this->createMock(\Symfony\Component\Console\Helper\TableFactory::class);
        $tableFactoryMock->expects($this->once())->method('create')->willReturn($table);

/** @var Lists|MockObject $list */
 $list = $this->createMock(Lists::class);
 $list->expects($this->once())->method('getCurrencyList')->willReturn($currencies);
 $command = new InfoCurrencyListCommand($list, $tableFactoryMock);
 $commandTester = new CommandTester($command);
 $commandTester->execute([]);
 }
}
Magento/Setup/Test/Unit/Console/Command/ConfigSetCommandTest.php000077700000007761151323623130020626 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

namespace Magento\Setup\Test\Unit\Console\Command;

use Magento\Framework\App\DeploymentConfig;
use Magento\Framework\Module\ModuleList;
use Magento\Framework\Setup\Option\TextConfigOption;
use Magento\Setup\Console\Command\ConfigSetCommand;
use Magento\Setup\Model\ConfigModel;
use PHPUnit\Framework\MockObject\MockObject;
use PHPUnit\Framework\TestCase;
use Symfony\Component\Console\Helper\HelperSet;
use Symfony\Component\Console\Helper\QuestionHelper;
use Symfony\Component\Console\Tester\CommandTester;

class ConfigSetCommandTest extends TestCase
{
    /**
     * @var MockObject|ConfigModel
     */
    private $configModel;

/**
     * @var MockObject|DeploymentConfig
     */
    private $deploymentConfig;

/**
     * @var MockObject|ConfigSetCommand
     */
    private $command;

protected function setUp(): void
    {
        $option = $this->createMock(TextConfigOption::class);
        $option
            ->expects($this->any())
            ->method('getName')
            ->willReturn('db-host');
        $this->configModel = $this->createMock(ConfigModel::class);
        $this->configModel
            ->expects($this->exactly(2))
            ->method('getAvailableOptions')
            ->willReturn([$option]);
        $moduleList = $this->createMock(ModuleList::class);
        $this->deploymentConfig = $this->createMock(DeploymentConfig::class);
        $this->command = new ConfigSetCommand($this->configModel, $moduleList, $this->deploymentConfig);
    }

public function testExecuteNoInteractive()
    {
        $this->deploymentConfig
            ->expects($this->once())
            ->method('get')
            ->willReturn(null);
        $this->configModel
            ->expects($this->once())
            ->method('process')
            ->with(['db-host' => 'host']);
        $commandTester = new CommandTester($this->command);
        $commandTester->execute(['--db-host' => 'host']);
        $this->assertSame(
            'You saved the new configuration.' . PHP_EOL,
            $commandTester->getDisplay()
        );
    }

public function testExecuteInteractiveWithYes()
    {
        $this->deploymentConfig
            ->expects($this->once())
            ->method('get')
            ->willReturn('localhost');
        $this->configModel
            ->expects($this->once())
            ->method('process')
            ->with(['db-host' => 'host']);
        $this->checkInteraction('Y');
    }

public function testExecuteInteractiveWithNo()
    {
        $this->deploymentConfig
            ->expects($this->once())
            ->method('get')
            ->willReturn('localhost');
        $this->configModel
            ->expects($this->once())
            ->method('process')
            ->with([]);
        $this->checkInteraction('n');
    }

/**
     * Checks interaction with users on CLI
     *
     * @param string $interactionType
     * @return void
     */
    private function checkInteraction($interactionType)
    {
        $dialog = $this->createMock(QuestionHelper::class);
        $dialog
            ->expects($this->once())
            ->method('ask')
            ->willReturn($interactionType);

/** @var HelperSet|MockObject $helperSet */
        $helperSet = $this->createMock(HelperSet::class);
        $helperSet
            ->expects($this->once())
            ->method('get')
            ->with('question')
            ->willReturn($dialog);
        $this->command->setHelperSet($helperSet);

$commandTester = new CommandTester($this->command);
 $commandTester->execute(['--db-host' => 'host']);
 if (strtolower($interactionType) === 'y') {
 $message = 'You saved the new configuration.' . PHP_EOL;
 } else {
 $message = 'You made no changes to the configuration.' . PHP_EOL;
 }
 $this->assertSame(
 $message,
 $commandTester->getDisplay()
 );
 }
}
Magento/Setup/Test/Unit/Console/Command/FunctionExistMock.php000077700000000435151323623130020211 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

namespace Magento\Deploy\Console\Command;

/**
 * @param $func
 * @return bool
 */
function function_exists($func)
{
 return $func !== 'pcntl_fork';
}
Magento/Setup/Test/Unit/Console/Command/UninstallCommandTest.php000077700000004375151323623130020714 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

namespace Magento\Setup\Test\Unit\Console\Command;

use Magento\Setup\Console\Command\UninstallCommand;
use Magento\Setup\Model\Installer;
use Magento\Setup\Model\InstallerFactory;
use PHPUnit\Framework\MockObject\MockObject;
use PHPUnit\Framework\TestCase;
use Symfony\Component\Console\Helper\HelperSet;
use Symfony\Component\Console\Helper\QuestionHelper;
use Symfony\Component\Console\Tester\CommandTester;

class UninstallCommandTest extends TestCase
{
    /**
     * @var InstallerFactory|MockObject
     */
    private $installerFactory;

/**
     * @var Installer|MockObject
     */
    private $installer;

/**
     * @var UninstallCommand|MockObject
     */
    private $command;

protected function setUp(): void
    {
        $this->installerFactory = $this->createMock(InstallerFactory::class);
        $this->installer = $this->createMock(Installer::class);
        $this->command = new UninstallCommand($this->installerFactory);
    }

public function testExecuteInteractionYes()
    {
        $this->installer->expects($this->once())->method('uninstall');
        $this->installerFactory->expects($this->once())->method('create')->willReturn($this->installer);

$this->checkInteraction(true);
    }

public function testExecuteInteractionNo()
    {
        $this->installer->expects($this->exactly(0))->method('uninstall');
        $this->installerFactory->expects($this->exactly(0))->method('create');

$this->checkInteraction(false);
    }

/**
     * @param $answer
     */
    public function checkInteraction($answer)
    {
        $question = $this->createMock(QuestionHelper::class);
        $question
            ->expects($this->once())
            ->method('ask')
            ->willReturn($answer);

/** @var HelperSet|MockObject $helperSet */
        $helperSet = $this->createMock(HelperSet::class);
        $helperSet
            ->expects($this->once())
            ->method('get')
            ->with('question')
            ->willReturn($question);
        $this->command->setHelperSet($helperSet);

$tester = new CommandTester($this->command);
 $tester->execute([]);
 }
}
Magento/Setup/Test/Unit/Console/Command/DeployStaticContentCommandTest.php000077700000013055151323623130022675 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

namespace Magento\Setup\Test\Unit\Console\Command;

use Magento\Deploy\Console\ConsoleLogger;
use Magento\Deploy\Console\ConsoleLoggerFactory;
use Magento\Deploy\Console\DeployStaticOptions;
use Magento\Deploy\Console\InputValidator;
use Magento\Deploy\Process\TimeoutException;
use Magento\Deploy\Service\DeployStaticContent;
use Magento\Framework\App\State;
use Magento\Framework\Console\Cli;
use Magento\Framework\ObjectManagerInterface;
use Magento\Framework\TestFramework\Unit\Helper\ObjectManager;
use Magento\Setup\Console\Command\DeployStaticContentCommand;
use Magento\Setup\Model\ObjectManagerProvider;
use PHPUnit\Framework\MockObject\MockObject as Mock;
use PHPUnit\Framework\TestCase;
use Symfony\Component\Console\Tester\CommandTester;

/**
 * Test for static content deploy command
 *
 * @SuppressWarnings(PHPMD.CouplingBetweenObjects)
 */
class DeployStaticContentCommandTest extends TestCase
{
    /**
     * @var DeployStaticContentCommand
     */
    private $command;

/**
     * @var InputValidator|Mock
     */
    private $inputValidator;

/**
     * @var ConsoleLogger|Mock
     */
    private $logger;

/**
     * @var ConsoleLoggerFactory|Mock
     */
    private $consoleLoggerFactory;

/**
     * @var DeployStaticContent|Mock
     */
    private $deployService;

/**
     * Object manager to create various objects
     *
     * @var ObjectManagerInterface|Mock
     *
     */
    private $objectManager;

/**
     * @var State|Mock
     */
    private $appState;

/**
     * @inheritdoc
     */
    protected function setUp(): void
    {
        $this->inputValidator = $this->createMock(InputValidator::class);
        $this->consoleLoggerFactory = $this->createMock(ConsoleLoggerFactory::class);
        $this->logger = $this->createMock(ConsoleLogger::class);
        $this->objectManager = $this->getMockForAbstractClass(ObjectManagerInterface::class);
        $this->appState = $this->createMock(State::class);
        $this->deployService = $this->createMock(DeployStaticContent::class);

$objectManagerProvider = $this->createMock(ObjectManagerProvider::class);
        $objectManagerProvider->method('get')->willReturn($this->objectManager);

$this->command = (new ObjectManager($this))->getObject(DeployStaticContentCommand::class, [
            'inputValidator' => $this->inputValidator,
            'consoleLoggerFactory' => $this->consoleLoggerFactory,
            'options' => new DeployStaticOptions(),
            'appState' => $this->appState,
            'objectManagerProvider' => $objectManagerProvider
        ]);
    }

/**
     * @param array $input
     * @see DeployStaticContentCommand::execute()
     * @dataProvider executeDataProvider
     */
    public function testExecute($input)
    {
        $this->appState->expects($this->once())
            ->method('getMode')
            ->willReturn(State::MODE_PRODUCTION);

$this->inputValidator->expects($this->once())
            ->method('validate');

$this->consoleLoggerFactory->expects($this->once())
            ->method('getLogger')->willReturn($this->logger);
        $this->logger->expects($this->exactly(2))->method('notice');

$this->objectManager->expects($this->once())->method('create')->willReturn($this->deployService);
        $this->deployService->expects($this->once())->method('deploy');

$tester = new CommandTester($this->command);
        $exitCode = $tester->execute($input);
        $this->assertEquals(Cli::RETURN_SUCCESS, $exitCode);
    }

/**
     * @return array
     */
    public function executeDataProvider()
    {
        return [
            'No options' => [
                []
            ],
            'With static content version option' => [
                ['--content-version' => '123456']
            ]
        ];
    }

/**
     * @return void
     */
    public function testExecuteWithError()
    {
        $this->appState->expects($this->once())
            ->method('getMode')
            ->willReturn(State::MODE_PRODUCTION);

$this->inputValidator->expects($this->once())
            ->method('validate');

$this->consoleLoggerFactory->expects($this->once())
            ->method('getLogger')
            ->willReturn($this->logger);
        $this->logger->expects($this->once())
            ->method('error');

$this->objectManager->expects($this->once())
            ->method('create')
            ->willReturn($this->deployService);
        $this->deployService->expects($this->once())
            ->method('deploy')
            ->willThrowException(new TimeoutException());

$tester = new CommandTester($this->command);
        $exitCode = $tester->execute([]);
        $this->assertEquals(Cli::RETURN_FAILURE, $exitCode);
    }

/**
     * @param string $mode
     * @return void
     * @dataProvider executionInNonProductionModeDataProvider
     */
    public function testExecuteInNonProductionMode($mode)
    {
        $this->expectException('Magento\Framework\Exception\LocalizedException');
        $this->appState->expects($this->any())->method('getMode')->willReturn($mode);
        $this->objectManager->expects($this->never())->method('create');

$tester = new CommandTester($this->command);
        $tester->execute([]);
    }

/**
 * @return array
 */
 public function executionInNonProductionModeDataProvider()
 {
 return [
 [State::MODE_DEFAULT],
 [State::MODE_DEVELOPER],
 ];
 }
}
Magento/Setup/Test/Unit/Console/Command/InstallStoreConfigurationCommandTest.php000077700000017552151323623130024117 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

namespace Magento\Setup\Test\Unit\Console\Command;

use Magento\Framework\App\DeploymentConfig;
use Magento\Framework\ObjectManagerInterface;
use Magento\Framework\Validator\Currency as CurrencyValidator;
use Magento\Framework\Validator\Locale as LocaleValidator;
use Magento\Framework\Validator\Timezone as TimezoneValidator;
use Magento\Framework\Validator\Url as UrlValidator;
use Magento\Setup\Console\Command\InstallStoreConfigurationCommand;
use Magento\Setup\Model\Installer;
use Magento\Setup\Model\InstallerFactory;
use Magento\Setup\Model\ObjectManagerProvider;
use Magento\Setup\Model\StoreConfigurationDataMapper;
use PHPUnit\Framework\MockObject\MockObject;
use PHPUnit\Framework\TestCase;
use Symfony\Component\Console\Tester\CommandTester;

/**
 * @SuppressWarnings(PHPMD.CouplingBetweenObjects)
 */
class InstallStoreConfigurationCommandTest extends TestCase
{
    /**
     * @var DeploymentConfig|MockObject
     */
    private $deploymentConfig;

/**
     * @var InstallerFactory|MockObject
     */
    private $installerFactory;

/**
     * @var Installer|MockObject
     */
    private $installer;

/**
     * @var ObjectManagerInterface|MockObject
     */
    private $objectManager;

/**
     * @var LocaleValidator|MockObject
     */
    private $localeValidatorMock;

/**
     * @var TimezoneValidator|MockObject
     */
    private $timezoneValidatorMock;

/**
     * @var CurrencyValidator|MockObject
     */
    private $currencyValidatorMock;

/**
     * @var UrlValidator|MockObject
     */
    private $urlValidatorMock;

/**
     * @var InstallStoreConfigurationCommand
     */
    private $command;

protected function setUp(): void
    {
        $this->urlValidatorMock = $this->createMock(UrlValidator::class);
        $this->localeValidatorMock = $this->createMock(LocaleValidator::class);
        $this->timezoneValidatorMock = $this->createMock(TimezoneValidator::class);
        $this->currencyValidatorMock = $this->createMock(CurrencyValidator::class);

$this->installerFactory = $this->createMock(InstallerFactory::class);
        $this->deploymentConfig = $this->createMock(DeploymentConfig::class);
        $this->installer = $this->createMock(Installer::class);
        $objectManagerProvider = $this->createMock(ObjectManagerProvider::class);
        $this->objectManager = $this->getMockForAbstractClass(
            ObjectManagerInterface::class,
            [],
            '',
            false
        );
        $objectManagerProvider->expects($this->once())->method('get')->willReturn($this->objectManager);
        $this->command = new InstallStoreConfigurationCommand(
            $this->installerFactory,
            $this->deploymentConfig,
            $objectManagerProvider,
            $this->localeValidatorMock,
            $this->timezoneValidatorMock,
            $this->currencyValidatorMock,
            $this->urlValidatorMock
        );
    }

public function testExecute()
    {
        $this->deploymentConfig->expects($this->once())
            ->method('isAvailable')
            ->willReturn(true);
        $this->installer->expects($this->once())
            ->method('installUserConfig');
        $this->installerFactory->expects($this->once())
            ->method('create')
            ->willReturn($this->installer);
        $tester = new CommandTester($this->command);
        $tester->execute([]);
    }

public function testExecuteNotInstalled()
    {
        $this->deploymentConfig->expects($this->once())
            ->method('isAvailable')
            ->willReturn(false);
        $this->installerFactory->expects($this->never())
            ->method('create');
        $tester = new CommandTester($this->command);
        $tester->execute([]);
        $this->assertStringMatchesFormat(
            "Store settings can't be saved because the Magento application is not installed.%w",
            $tester->getDisplay()
        );
    }

/**
     * @dataProvider validateDataProvider
     * @param array $option
     * @param string $error
     */
    public function testExecuteInvalidData(array $option, $error)
    {
        $this->localeValidatorMock->expects($this->any())->method('isValid')->willReturn(false);
        $this->timezoneValidatorMock->expects($this->any())->method('isValid')->willReturn(false);
        $this->currencyValidatorMock->expects($this->any())->method('isValid')->willReturn(false);
        $this->urlValidatorMock->expects($this->any())->method('isValid')->willReturn(false);

$this->deploymentConfig->expects($this->once())
            ->method('isAvailable')
            ->willReturn(true);
        $this->installerFactory->expects($this->never())
            ->method('create');
        $commandTester = new CommandTester($this->command);
        $commandTester->execute($option);
        $this->assertStringContainsString($error, $commandTester->getDisplay());
    }

/**
     * @return array
     */
    public function validateDataProvider()
    {
        return [
            [
                ['--' . StoreConfigurationDataMapper::KEY_BASE_URL => 'sampleUrl'],
                'Command option \'' . StoreConfigurationDataMapper::KEY_BASE_URL . '\': Invalid URL \'sampleUrl\'.'
            ],
            [
                ['--' . StoreConfigurationDataMapper::KEY_BASE_URL => 'http://example.com_test'],
                'Command option \'' . StoreConfigurationDataMapper::KEY_BASE_URL
                    . '\': Invalid URL \'http://example.com_test\'.'
            ],
            [
                ['--' . StoreConfigurationDataMapper::KEY_LANGUAGE => 'sampleLanguage'],
                'Command option \'' . StoreConfigurationDataMapper::KEY_LANGUAGE
                    . '\': Invalid value. To see possible values, run command \'bin/magento info:language:list\'.'
            ],
            [
                ['--' . StoreConfigurationDataMapper::KEY_TIMEZONE => 'sampleTimezone'],
                'Command option \'' . StoreConfigurationDataMapper::KEY_TIMEZONE
                    . '\': Invalid value. To see possible values, run command \'bin/magento info:timezone:list\'.'
            ],
            [
                ['--' . StoreConfigurationDataMapper::KEY_CURRENCY => 'sampleLanguage'],
                'Command option \'' . StoreConfigurationDataMapper::KEY_CURRENCY
                    . '\': Invalid value. To see possible values, run command \'bin/magento info:currency:list\'.'
            ],
            [
                ['--' . StoreConfigurationDataMapper::KEY_USE_SEF_URL => 'invalidValue'],
                'Command option \'' . StoreConfigurationDataMapper::KEY_USE_SEF_URL
                    . '\': Invalid value. Possible values (0|1).'
            ],
            [
                ['--' . StoreConfigurationDataMapper::KEY_IS_SECURE => 'invalidValue'],
                'Command option \'' . StoreConfigurationDataMapper::KEY_IS_SECURE
                    . '\': Invalid value. Possible values (0|1).'
            ],
            [
                ['--' . StoreConfigurationDataMapper::KEY_BASE_URL_SECURE => 'http://www.sample.com'],
                'Command option \'' . StoreConfigurationDataMapper::KEY_BASE_URL_SECURE
                    . '\': Invalid URL \'http://www.sample.com\'.'
            ],
            [
                ['--' . StoreConfigurationDataMapper::KEY_IS_SECURE_ADMIN => 'invalidValue'],
                'Command option \'' . StoreConfigurationDataMapper::KEY_IS_SECURE_ADMIN
                    . '\': Invalid value. Possible values (0|1).'
            ],
            [
                ['--' . StoreConfigurationDataMapper::KEY_ADMIN_USE_SECURITY_KEY => 'invalidValue'],
                'Command option \'' . StoreConfigurationDataMapper::KEY_ADMIN_USE_SECURITY_KEY
                    . '\': Invalid value. Possible values (0|1).'
            ],

];
 }
}
Magento/Setup/Test/Unit/Console/Command/ModuleUninstallCommandTest.php000077700000056300151323623130022055 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

namespace Magento\Setup\Test\Unit\Console\Command;

use Magento\Framework\App\Cache;
use Magento\Framework\App\Console\MaintenanceModeEnabler;
use Magento\Framework\App\DeploymentConfig;
use Magento\Framework\App\MaintenanceMode;
use Magento\Framework\App\State;
use Magento\Framework\App\State\CleanupFiles;
use Magento\Framework\Composer\ComposerInformation;
use Magento\Framework\Module\DependencyChecker;
use Magento\Framework\Module\FullModuleList;
use Magento\Framework\Module\PackageInfo;
use Magento\Framework\Module\PackageInfoFactory;
use Magento\Framework\ObjectManager\ConfigLoaderInterface;
use Magento\Framework\ObjectManagerInterface;
use Magento\Framework\Setup\BackupRollback;
use Magento\Framework\Setup\BackupRollbackFactory;
use Magento\Framework\Setup\Patch\PatchApplier;
use Magento\Setup\Console\Command\ModuleUninstallCommand;
use Magento\Setup\Model\ModuleRegistryUninstaller;
use Magento\Setup\Model\ModuleUninstaller;
use Magento\Setup\Model\ObjectManagerProvider;
use Magento\Setup\Model\UninstallCollector;
use PHPUnit\Framework\MockObject\MockObject;
use PHPUnit\Framework\TestCase;
use Symfony\Component\Console\Helper\HelperSet;
use Symfony\Component\Console\Helper\QuestionHelper;
use Symfony\Component\Console\Output\OutputInterface;
use Symfony\Component\Console\Tester\CommandTester;

/**
 * @SuppressWarnings(PHPMD.CouplingBetweenObjects)
 * @SuppressWarnings(PHPMD.TooManyFields)
 */
class ModuleUninstallCommandTest extends TestCase
{
    /**
     * @var DeploymentConfig|MockObject
     */
    private $deploymentConfig;

/**
     * @var FullModuleList|MockObject
     */
    private $fullModuleList;

/**
     * @var MaintenanceMode|MockObject
     */
    private $maintenanceMode;

/**
     * @var UninstallCollector|MockObject
     */
    private $uninstallCollector;

/**
     * @var PackageInfo|MockObject
     */
    private $packageInfo;

/**
     * @var DependencyChecker|MockObject
     */
    private $dependencyChecker;

/**
     * @var ModuleUninstaller|MockObject
     */
    private $moduleUninstaller;

/**
     * @var ModuleRegistryUninstaller|MockObject
     */
    private $moduleRegistryUninstaller;

/**
     * @var Cache|MockObject
     */
    private $cache;

/**
     * @var CleanupFiles|MockObject
     */
    private $cleanupFiles;

/**
     * @var BackupRollback|MockObject
     */
    private $backupRollback;

/**
     * @var BackupRollbackFactory|MockObject
     */
    private $backupRollbackFactory;

/**
     * @var QuestionHelper|MockObject
     */
    private $question;

/**
     * @var HelperSet|MockObject
     */
    private $helperSet;

/**
     * @var ModuleUninstallCommand
     */
    private $command;

/**
     * @var CommandTester
     */
    private $tester;

/**
     * @var MockObject
     */
    private $patchApplierMock;

/**
     * @SuppressWarnings(PHPMD.UnusedLocalVariable)
     */
    protected function setUp(): void
    {
        $this->deploymentConfig = $this->createMock(DeploymentConfig::class);
        $this->fullModuleList = $this->createMock(FullModuleList::class);
        $this->maintenanceMode = $this->createMock(MaintenanceMode::class);
        $objectManagerProvider = $this->createMock(ObjectManagerProvider::class);
        $objectManager = $this->getMockForAbstractClass(
            ObjectManagerInterface::class,
            [],
            '',
            false
        );
        $this->uninstallCollector = $this->createMock(UninstallCollector::class);
        $this->packageInfo = $this->createMock(PackageInfo::class);
        $packageInfoFactory = $this->createMock(PackageInfoFactory::class);
        $packageInfoFactory->expects($this->once())->method('create')->willReturn($this->packageInfo);
        $this->dependencyChecker = $this->createMock(DependencyChecker::class);
        $this->backupRollback = $this->createMock(BackupRollback::class);
        $this->backupRollbackFactory = $this->createMock(BackupRollbackFactory::class);
        $this->backupRollbackFactory->expects($this->any())
            ->method('create')
            ->willReturn($this->backupRollback);
        $this->cache = $this->createMock(Cache::class);
        $this->cleanupFiles = $this->createMock(CleanupFiles::class);
        $objectManagerProvider->expects($this->any())->method('get')->willReturn($objectManager);
        $configLoader = $this->getMockForAbstractClass(
            ConfigLoaderInterface::class,
            [],
            '',
            false
        );
        $this->patchApplierMock = $this->getMockBuilder(PatchApplier::class)
            ->disableOriginalConstructor()
            ->getMock();
        $configLoader->expects($this->any())->method('load')->willReturn([]);
        $objectManager->expects($this->any())
            ->method('get')
            ->willReturnMap([
                [PackageInfoFactory::class, $packageInfoFactory],
                [DependencyChecker::class, $this->dependencyChecker],
                [Cache::class, $this->cache],
                [CleanupFiles::class, $this->cleanupFiles],
                [
                    State::class,
                    $this->createMock(State::class)
                ],
                [BackupRollbackFactory::class, $this->backupRollbackFactory],
                [PatchApplier::class, $this->patchApplierMock],
                [ConfigLoaderInterface::class, $configLoader],
            ]);
        $composer = $this->createMock(ComposerInformation::class);
        $composer->expects($this->any())
            ->method('getRootRequiredPackages')
            ->willReturn(['magento/package-a', 'magento/package-b']);
        $this->moduleUninstaller = $this->createMock(ModuleUninstaller::class);
        $this->moduleRegistryUninstaller = $this->createMock(ModuleRegistryUninstaller::class);
        $this->command = new ModuleUninstallCommand(
            $composer,
            $this->deploymentConfig,
            $this->fullModuleList,
            $this->maintenanceMode,
            $objectManagerProvider,
            $this->uninstallCollector,
            $this->moduleUninstaller,
            $this->moduleRegistryUninstaller,
            new MaintenanceModeEnabler($this->maintenanceMode)
        );
        $this->question = $this->createMock(QuestionHelper::class);
        $this->question
            ->expects($this->any())
            ->method('ask')
            ->willReturn(true);
        $this->helperSet = $this->createMock(HelperSet::class);
        $this->helperSet
            ->expects($this->any())
            ->method('get')
            ->with('question')
            ->willReturn($this->question);
        $this->command->setHelperSet($this->helperSet);
        $this->tester = new CommandTester($this->command);
    }

public function testExecuteApplicationNotInstalled()
    {
        $this->deploymentConfig->expects($this->once())->method('isAvailable')->willReturn(false);
        $this->tester->execute(['module' => ['Magento_A']]);
        $this->assertEquals(
            'You cannot run this command because the Magento application is not installed.' . PHP_EOL,
            $this->tester->getDisplay()
        );
    }

/**
     * @dataProvider executeFailedValidationDataProvider
     * @param array $packageInfoMap
     * @param array $fullModuleListMap
     * @param array $input
     * @param array $expect
     */
    public function testExecuteFailedValidation(
        array $packageInfoMap,
        array $fullModuleListMap,
        array $input,
        array $expect
    ) {
        $this->deploymentConfig->expects($this->once())->method('isAvailable')->willReturn(true);
        $this->packageInfo->expects($this->exactly(count($input['module'])))
            ->method('getPackageName')
            ->willReturnMap($packageInfoMap);
        $this->fullModuleList->expects($this->exactly(count($input['module'])))
            ->method('has')
            ->willReturnMap($fullModuleListMap);
        $this->tester->execute($input);
        foreach ($expect as $message) {
            $this->assertStringContainsString($message, $this->tester->getDisplay());
        }
    }

/**
     * @return array
     */
    public function executeFailedValidationDataProvider()
    {
        return [
            'one non-composer package' => [
                [['Magento_C', 'magento/package-c']],
                [['Magento_C', true]],
                ['module' => ['Magento_C']],
                ['Magento_C is not an installed composer package']
            ],
            'one non-composer package, one valid' => [
                [['Magento_A', 'magento/package-a'], ['Magento_C', 'magento/package-c']],
                [['Magento_A', true], ['Magento_C', true]],
                ['module' => ['Magento_A', 'Magento_C']],
                ['Magento_C is not an installed composer package']
            ],
            'two non-composer packages' => [
                [['Magento_C', 'magento/package-c'], ['Magento_D', 'magento/package-d']],
                [['Magento_C', true], ['Magento_D', true]],
                ['module' => ['Magento_C', 'Magento_D']],
                ['Magento_C, Magento_D are not installed composer packages']
            ],
            'one unknown module' => [
                [['Magento_C', '']],
                [['Magento_C', false]],
                ['module' => ['Magento_C']],
                ['Unknown module(s): Magento_C']
            ],
            'two unknown modules' => [
                [['Magento_C', ''], ['Magento_D', '']],
                [['Magento_C', false], ['Magento_D', false]],
                ['module' => ['Magento_C', 'Magento_D']],
                ['Unknown module(s): Magento_C, Magento_D']
            ],
            'one unknown module, one valid' => [
                [['Magento_C', ''], ['Magento_B', 'magento/package-b']],
                [['Magento_C', false], ['Magento_B', true]],
                ['module' => ['Magento_C', 'Magento_B']],
                ['Unknown module(s): Magento_C']
            ],
            'one non-composer package, one unknown module' => [
                [['Magento_C', 'magento/package-c'], ['Magento_D', '']],
                [['Magento_C', true], ['Magento_D', false]],
                ['module' => ['Magento_C', 'Magento_D']],
                ['Magento_C is not an installed composer package', 'Unknown module(s): Magento_D']
            ],
            'two non-composer package, one unknown module' => [
                [['Magento_C', 'magento/package-c'], ['Magento_D', ''], ['Magento_E', 'magento/package-e']],
                [['Magento_C', true], ['Magento_D', false], ['Magento_E', true]],
                ['module' => ['Magento_C', 'Magento_D', 'Magento_E']],
                ['Magento_C, Magento_E are not installed composer packages', 'Unknown module(s): Magento_D']
            ],
            'two non-composer package, two unknown module' => [
                [
                    ['Magento_C', 'magento/package-c'],
                    ['Magento_D', ''],
                    ['Magento_E', 'magento/package-e'],
                    ['Magento_F', '']
                ],
                [['Magento_C', true], ['Magento_D', false], ['Magento_E', true], ['Magento_F', false]],
                ['module' => ['Magento_C', 'Magento_D', 'Magento_E', 'Magento_F']],
                ['Magento_C, Magento_E are not installed composer packages', 'Unknown module(s): Magento_D, Magento_F']
            ],
            'two non-composer package, two unknown module, two valid' => [
                [
                    ['Magento_C', 'magento/package-c'],
                    ['Magento_D', ''],
                    ['Magento_E', 'magento/package-e'],
                    ['Magento_F', ''],
                    ['Magento_A', 'magento/package-a'],
                    ['Magento_B', 'magento/package-b'],
                ],
                [
                    ['Magento_A', true],
                    ['Magento_B', true],
                    ['Magento_C', true],
                    ['Magento_D', false],
                    ['Magento_E', true],
                    ['Magento_F', false]
                ],
                ['module' => ['Magento_A', 'Magento_B', 'Magento_C', 'Magento_D', 'Magento_E', 'Magento_F']],
                ['Magento_C, Magento_E are not installed composer packages', 'Unknown module(s): Magento_D, Magento_F']
            ]
        ];
    }

private function setUpPassValidation()
    {
        $this->deploymentConfig->expects($this->once())->method('isAvailable')->willReturn(true);
        $packageMap = [
            ['Magento_A', 'magento/package-a'],
            ['Magento_B', 'magento/package-b'],
        ];
        $this->packageInfo->expects($this->any())
            ->method('getPackageName')
            ->willReturnMap($packageMap);
        $this->fullModuleList->expects($this->any())
            ->method('has')
            ->willReturn(true);
    }

/**
     * @dataProvider executeFailedDependenciesDataProvider
     * @param array $dependencies
     * @param array $input
     * @param array $expect
     */
    public function testExecuteFailedDependencies(
        array $dependencies,
        array $input,
        array $expect
    ) {
        $this->setUpPassValidation();
        $this->dependencyChecker->expects($this->once())
            ->method('checkDependenciesWhenDisableModules')
            ->willReturn($dependencies);
        $this->tester->execute($input);
        foreach ($expect as $message) {
            $this->assertStringContainsString($message, $this->tester->getDisplay());
        }
    }

/**
     * @return array
     */
    public function executeFailedDependenciesDataProvider()
    {
        return [
            [
                ['Magento_A' => ['Magento_D' => ['Magento_D', 'Magento_A']]],
                ['module' => ['Magento_A']],
                [
                    "Cannot uninstall module 'Magento_A' because the following module(s) depend on it:" .
                    PHP_EOL . "\tMagento_D"
                ]
            ],
            [
                ['Magento_A' => ['Magento_D' => ['Magento_D', 'Magento_A']]],
                ['module' => ['Magento_A', 'Magento_B']],
                [
                    "Cannot uninstall module 'Magento_A' because the following module(s) depend on it:" .
                    PHP_EOL . "\tMagento_D"
                ]
            ],
            [
                [
                    'Magento_A' => ['Magento_D' => ['Magento_D', 'Magento_A']],
                    'Magento_B' => ['Magento_E' => ['Magento_E', 'Magento_A']]
                ],
                ['module' => ['Magento_A', 'Magento_B']],
                [
                    "Cannot uninstall module 'Magento_A' because the following module(s) depend on it:" .
                    PHP_EOL . "\tMagento_D",
                    "Cannot uninstall module 'Magento_B' because the following module(s) depend on it:" .
                    PHP_EOL . "\tMagento_E"
                ]
            ],
        ];
    }

private function setUpExecute()
    {
        $this->setUpPassValidation();
        $this->dependencyChecker->expects($this->once())
            ->method('checkDependenciesWhenDisableModules')
            ->willReturn(['Magento_A' => [], 'Magento_B' => []]);
        $this->cache->expects($this->once())->method('clean');
        $this->cleanupFiles->expects($this->once())->method('clearCodeGeneratedClasses');
    }

public function testExecute()
    {
        $input = ['module' => ['Magento_A', 'Magento_B']];
        $this->setUpExecute();
        $this->moduleUninstaller->expects($this->once())
            ->method('uninstallCode')
            ->with($this->isInstanceOf(OutputInterface::class), $input['module']);
        $this->moduleRegistryUninstaller->expects($this->once())
            ->method('removeModulesFromDb')
            ->with($this->isInstanceOf(OutputInterface::class), $input['module']);
        $this->moduleRegistryUninstaller->expects($this->once())
            ->method('removeModulesFromDeploymentConfig')
            ->with($this->isInstanceOf(OutputInterface::class), $input['module']);
        $this->tester->execute($input);
    }

public function testExecuteClearStaticContent()
    {
        $input = ['module' => ['Magento_A', 'Magento_B'], '-c' => true];
        $this->setUpExecute();
        $this->moduleUninstaller->expects($this->once())
            ->method('uninstallCode')
            ->with($this->isInstanceOf(OutputInterface::class), $input['module']);
        $this->moduleRegistryUninstaller->expects($this->once())
            ->method('removeModulesFromDb')
            ->with($this->isInstanceOf(OutputInterface::class), $input['module']);
        $this->moduleRegistryUninstaller->expects($this->once())
            ->method('removeModulesFromDeploymentConfig')
            ->with($this->isInstanceOf(OutputInterface::class), $input['module']);
        $this->cleanupFiles->expects($this->once())->method('clearMaterializedViewFiles');
        $this->tester->execute($input);
    }

public function testExecuteRemoveData()
    {
        $input = ['module' => ['Magento_A', 'Magento_B'], '-r' => true];
        $this->setUpExecute();
        $this->moduleUninstaller->expects($this->once())
            ->method('uninstallData')
            ->with($this->isInstanceOf(OutputInterface::class), $input['module']);
        $this->moduleUninstaller->expects($this->once())
            ->method('uninstallCode')
            ->with($this->isInstanceOf(OutputInterface::class), $input['module']);
        $this->moduleRegistryUninstaller->expects($this->once())
            ->method('removeModulesFromDb')
            ->with($this->isInstanceOf(OutputInterface::class), $input['module']);
        $this->moduleRegistryUninstaller->expects($this->once())
            ->method('removeModulesFromDeploymentConfig')
            ->with($this->isInstanceOf(OutputInterface::class), $input['module']);
        $this->tester->execute($input);
    }

public function testExecuteNonComposerModules()
    {
        $this->deploymentConfig->expects(self::once())
            ->method('isAvailable')
            ->willReturn(true);
        $input = ['module' => ['Magento_A'], '-c' => true, '-r' => true, '--non-composer' => true];
        $this->patchApplierMock->expects(self::once())
            ->method('revertDataPatches')
            ->with('Magento_A');
        self::assertEquals(0, $this->tester->execute($input));
    }

public function testExecuteAll()
    {
        $input = ['module' => ['Magento_A', 'Magento_B'], '-c' => true, '-r' => true];
        $this->setUpExecute();
        $this->moduleUninstaller->expects($this->once())
            ->method('uninstallData')
            ->with($this->isInstanceOf(OutputInterface::class), $input['module']);
        $this->moduleUninstaller->expects($this->once())
            ->method('uninstallCode')
            ->with($this->isInstanceOf(OutputInterface::class), $input['module']);
        $this->moduleRegistryUninstaller->expects($this->once())
            ->method('removeModulesFromDb')
            ->with($this->isInstanceOf(OutputInterface::class), $input['module']);
        $this->moduleRegistryUninstaller->expects($this->once())
            ->method('removeModulesFromDeploymentConfig')
            ->with($this->isInstanceOf(OutputInterface::class), $input['module']);
        $this->cleanupFiles->expects($this->once())->method('clearMaterializedViewFiles');
        $this->tester->execute($input);
    }

public function testExecuteCodeBackup()
    {
        $input = ['module' => ['Magento_A', 'Magento_B'], '--backup-code' => true];
        $this->setUpExecute();
        $this->moduleUninstaller->expects($this->once())
            ->method('uninstallCode')
            ->with($this->isInstanceOf(OutputInterface::class), $input['module']);
        $this->moduleRegistryUninstaller->expects($this->once())
            ->method('removeModulesFromDb')
            ->with($this->isInstanceOf(OutputInterface::class), $input['module']);
        $this->moduleRegistryUninstaller->expects($this->once())
            ->method('removeModulesFromDeploymentConfig')
            ->with($this->isInstanceOf(OutputInterface::class), $input['module']);
        $this->backupRollback->expects($this->once())
            ->method('codeBackup')
            ->willReturn($this->backupRollback);
        $this->tester->execute($input);
    }

public function testExecuteMediaBackup()
    {
        $input = ['module' => ['Magento_A', 'Magento_B'], '--backup-media' => true];
        $this->setUpExecute();
        $this->moduleUninstaller->expects($this->once())
            ->method('uninstallCode')
            ->with($this->isInstanceOf(OutputInterface::class), $input['module']);
        $this->moduleRegistryUninstaller->expects($this->once())
            ->method('removeModulesFromDb')
            ->with($this->isInstanceOf(OutputInterface::class), $input['module']);
        $this->moduleRegistryUninstaller->expects($this->once())
            ->method('removeModulesFromDeploymentConfig')
            ->with($this->isInstanceOf(OutputInterface::class), $input['module']);
        $this->backupRollback->expects($this->once())
            ->method('codeBackup')
            ->willReturn($this->backupRollback);
        $this->tester->execute($input);
    }

public function testExecuteDBBackup()
    {
        $input = ['module' => ['Magento_A', 'Magento_B'], '--backup-db' => true];
        $this->setUpExecute();
        $this->moduleUninstaller->expects($this->once())
            ->method('uninstallCode')
            ->with($this->isInstanceOf(OutputInterface::class), $input['module']);
        $this->moduleRegistryUninstaller->expects($this->once())
            ->method('removeModulesFromDb')
            ->with($this->isInstanceOf(OutputInterface::class), $input['module']);
        $this->moduleRegistryUninstaller->expects($this->once())
            ->method('removeModulesFromDeploymentConfig')
            ->with($this->isInstanceOf(OutputInterface::class), $input['module']);
        $this->backupRollback->expects($this->once())
            ->method('dbBackup')
            ->willReturn($this->backupRollback);
        $this->tester->execute($input);
    }

public function testInteraction()
 {
 $input = ['module' => ['Magento_A', 'Magento_B']];
 $this->setUpExecute();
 $this->moduleUninstaller->expects($this->once())
 ->method('uninstallCode')
 ->with($this->isInstanceOf(OutputInterface::class), $input['module']);
 $this->moduleRegistryUninstaller->expects($this->once())
 ->method('removeModulesFromDb')
 ->with($this->isInstanceOf(OutputInterface::class), $input['module']);
 $this->moduleRegistryUninstaller->expects($this->once())
 ->method('removeModulesFromDeploymentConfig')
 ->with($this->isInstanceOf(OutputInterface::class), $input['module']);
 $this->question
 ->expects($this->once())
 ->method('ask')
 ->willReturn(false);
 $this->helperSet
 ->expects($this->once())
 ->method('get')
 ->with('question')
 ->willReturn($this->question);
 $this->command->setHelperSet($this->helperSet);
 $this->tester = new CommandTester($this->command);
 $this->tester->execute($input);
 }
}
Magento/Setup/Test/Unit/Console/Command/BackupCommandTest.php000077700000011624151323623130020143 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

namespace Magento\Setup\Test\Unit\Console\Command;

class BackupCommandTest extends TestCase
{
    /**
     * @var ObjectManagerInterface|MockObject
     */
    private $objectManager;

/**
     * @var BackupRollback|MockObject
     */
    private $backupRollback;

/**
     * @var CommandTester
     */
    private $tester;

/**
     * @var BackupRollbackFactory|MockObject
     */
    private $backupRollbackFactory;

/**
     * @var DeploymentConfig|MockObject
     */
    private $deploymentConfig;

protected function setUp(): void
    {
        $maintenanceMode = $this->createMock(MaintenanceMode::class);
        $objectManagerProvider = $this->createMock(ObjectManagerProvider::class);
        $this->objectManager = $this->getMockForAbstractClass(
            ObjectManagerInterface::class,
            [],
            '',
            false
        );
        $objectManagerProvider->expects($this->any())->method('get')->willReturn($this->objectManager);
        $this->backupRollback = $this->createMock(BackupRollback::class);
        $this->backupRollbackFactory = $this->createMock(BackupRollbackFactory::class);
        $this->backupRollbackFactory->expects($this->any())
            ->method('create')
            ->willReturn($this->backupRollback);
        $this->deploymentConfig = $this->createMock(DeploymentConfig::class);
        $appState = $this->createMock(State::class);
        $configLoader = $this->getMockForAbstractClass(
            ConfigLoaderInterface::class,
            [],
            '',
            false
        );
        $configLoader->expects($this->any())->method('load')->willReturn([]);

$this->objectManager->expects($this->any())
            ->method('get')
            ->willReturnMap(
                [
                    [BackupRollbackFactory::class, $this->backupRollbackFactory],
                    [State::class, $appState],
                    [ConfigLoaderInterface::class, $configLoader],
                ]
            );
        $command = new BackupCommand(
            $objectManagerProvider,
            $maintenanceMode,
            $this->deploymentConfig,
            new MaintenanceModeEnabler($maintenanceMode)
        );
        $this->tester = new CommandTester($command);
    }

public function testExecuteCodeBackup()
    {
        $this->deploymentConfig->expects($this->once())
            ->method('isAvailable')
            ->willReturn(true);
        $this->backupRollback->expects($this->once())
            ->method('codeBackup')
            ->willReturn($this->backupRollback);
        $this->tester->execute(['--code' => true]);
    }

public function testExecuteMediaBackup()
    {
        $this->deploymentConfig->expects($this->once())
            ->method('isAvailable')
            ->willReturn(true);
        $this->backupRollback->expects($this->once())
            ->method('codeBackup')
            ->willReturn($this->backupRollback);
        $this->tester->execute(['--media' => true]);
    }

public function testExecuteDBBackup()
    {
        $this->deploymentConfig->expects($this->once())
            ->method('isAvailable')
            ->willReturn(true);
        $this->backupRollback->expects($this->once())
            ->method('dbBackup')
            ->willReturn($this->backupRollback);
        $this->tester->execute(['--db' => true]);
    }

public function testExecuteNotInstalled()
    {
        $this->deploymentConfig->expects($this->once())
            ->method('isAvailable')
            ->willReturn(false);
        $this->tester->execute(['--db' => true]);
        $this->assertStringMatchesFormat(
            'No information is available: the Magento application is not installed.%w',
            $this->tester->getDisplay()
        );
    }

public function testExecuteNoOptions()
 {
 $this->deploymentConfig->expects($this->once())
 ->method('isAvailable')
 ->willReturn(false);
 $this->tester->execute([]);
 $expected = 'Enabling maintenance mode' . PHP_EOL
 . 'Not enough information provided to take backup.' . PHP_EOL
 . 'Disabling maintenance mode' . PHP_EOL;
 $this->assertSame($expected, $this->tester->getDisplay());
 }
}
Magento/Setup/Test/Unit/Console/Command/UpgradeCommandTest.php000077700000014372151323623130020330 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

namespace Magento\Setup\Test\Unit\Console\Command;

use Magento\Framework\App\DeploymentConfig;
use Magento\Framework\App\State as AppState;
use Magento\Framework\Console\Cli;
use Magento\Setup\Console\Command\UpgradeCommand;
use Magento\Setup\Model\Installer;
use Magento\Setup\Model\InstallerFactory;
use PHPUnit\Framework\MockObject\MockObject;
use PHPUnit\Framework\TestCase;
use Magento\Setup\Model\SearchConfig;
use Magento\Setup\Model\SearchConfigFactory;
use Symfony\Component\Console\Tester\CommandTester;

class UpgradeCommandTest extends TestCase
{
    /**
     * @var DeploymentConfig|MockObject
     */
    private $deploymentConfigMock;

/**
     * @var InstallerFactory|MockObject
     */
    private $installerFactoryMock;

/**
     * @var Installer|MockObject
     */
    private $installerMock;

/**
     * @var AppState|MockObject
     */
    private $appStateMock;

/**
     * @var SearchConfig|MockObject
     */
    private $searchConfigMock;

/**
     * @var UpgradeCommand
     */
    private $upgradeCommand;
    /**
     * @var CommandTester
     */
    private $commandTester;

/**
     * @return void
     */
    protected function setUp(): void
    {
        $this->deploymentConfigMock = $this->getMockBuilder(DeploymentConfig::class)
            ->disableOriginalConstructor()
            ->getMock();
        $this->installerFactoryMock = $this->getMockBuilder(InstallerFactory::class)
            ->disableOriginalConstructor()
            ->getMock();
        $this->installerMock = $this->getMockBuilder(Installer::class)
            ->disableOriginalConstructor()
            ->getMock();
        $this->installerFactoryMock->expects($this->once())
            ->method('create')
            ->willReturn($this->installerMock);
        $this->appStateMock = $this->getMockBuilder(AppState::class)
            ->disableOriginalConstructor()
            ->getMock();
        $this->searchConfigMock = $this->getMockBuilder(SearchConfig::class)
            ->disableOriginalConstructor()
            ->getMock();
        /** @var MockObject|SearchConfigFactory $searchConfigFactoryMock */
        $searchConfigFactoryMock = $this->getMockBuilder(SearchConfigFactory::class)
            ->disableOriginalConstructor()
            ->getMock();
        $searchConfigFactoryMock->expects($this->once())->method('create')->willReturn($this->searchConfigMock);

$this->upgradeCommand = new UpgradeCommand(
            $this->installerFactoryMock,
            $searchConfigFactoryMock,
            $this->deploymentConfigMock,
            $this->appStateMock
        );
        $this->commandTester = new CommandTester($this->upgradeCommand);
    }

/**
     * @dataProvider executeDataProvider
     * @param array $options
     * @param string $deployMode
     * @param string $expectedString
     * @param array $expectedOptions
     */
    public function testExecute($options, $deployMode, $expectedString, $expectedOptions)
    {
        $this->appStateMock->method('getMode')->willReturn($deployMode);
        $this->installerMock->expects($this->at(0))
            ->method('updateModulesSequence');
        $this->installerMock->expects($this->once())
            ->method('installSchema')
            ->with($expectedOptions);
        $this->installerMock->expects($this->at(2))
            ->method('installDataFixtures');

$this->assertSame(Cli::RETURN_SUCCESS, $this->commandTester->execute($options));
        $this->assertEquals($expectedString, $this->commandTester->getDisplay());
    }

/**
 * @return array
 */
 public function executeDataProvider()
 {
 return [
 [
 'options' => [
 '--magento-init-params' => '',
 '--convert-old-scripts' => false,
 ],
 'deployMode' => \Magento\Framework\App\State::MODE_PRODUCTION,
 'expectedString' => 'Please re-run Magento compile command. Use the command "setup:di:compile"'
 . PHP_EOL,
 'expectedOptions' => [
 'keep-generated' => false,
 'convert-old-scripts' => false,
 'safe-mode' => false,
 'data-restore' => false,
 'dry-run' => false,
 'magento-init-params' => '',
 ]
 ],
 [
 'options' => [
 '--magento-init-params' => '',
 '--convert-old-scripts' => false,
 '--keep-generated' => true,
 ],
 'deployMode' => \Magento\Framework\App\State::MODE_PRODUCTION,
 'expectedString' => '',
 'expectedOptions' => [
 'keep-generated' => true,
 'convert-old-scripts' => false,
 'safe-mode' => false,
 'data-restore' => false,
 'dry-run' => false,
 'magento-init-params' => '',
 ]
 ],
 [
 'options' => ['--magento-init-params' => '', '--convert-old-scripts' => false],
 'deployMode' => \Magento\Framework\App\State::MODE_DEVELOPER,
 'expectedString' => '',
 'expectedOptions' => [
 'keep-generated' => false,
 'convert-old-scripts' => false,
 'safe-mode' => false,
 'data-restore' => false,
 'dry-run' => false,
 'magento-init-params' => '',
 ]
 ],
 [
 'options' => ['--magento-init-params' => '', '--convert-old-scripts' => false],
 'deployMode' => \Magento\Framework\App\State::MODE_DEFAULT,
 'expectedString' => '',
 'expectedOptions' => [
 'keep-generated' => false,
 'convert-old-scripts' => false,
 'safe-mode' => false,
 'data-restore' => false,
 'dry-run' => false,
 'magento-init-params' => '',
 ]
 ],
 ];
 }
}
Magento/Setup/Test/Unit/Console/Command/DbSchemaUpgradeCommandTest.php000077700000005265151323623130021720 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

namespace Magento\Setup\Test\Unit\Console\Command;

use Magento\Framework\App\DeploymentConfig;
use Magento\Setup\Console\Command\DbSchemaUpgradeCommand;
use Magento\Setup\Model\Installer;
use Magento\Setup\Model\InstallerFactory;
use PHPUnit\Framework\MockObject\MockObject;
use PHPUnit\Framework\TestCase;
use Symfony\Component\Console\Tester\CommandTester;

class DbSchemaUpgradeCommandTest extends TestCase
{
    /**
     * @var InstallerFactory|MockObject
     */
    private $installerFactory;

/**
     * @var DeploymentConfig|MockObject
     */
    private $deploymentConfig;

protected function setUp(): void
    {
        $this->installerFactory = $this->createMock(InstallerFactory::class);
        $this->deploymentConfig = $this->createMock(DeploymentConfig::class);
    }

/**
     * @dataProvider executeDataProvider
     * @param $options
     * @param $expectedOptions
     */
    public function testExecute($options, $expectedOptions)
    {
        $this->deploymentConfig->expects($this->once())->method('isAvailable')->willReturn(true);
        $installer = $this->createMock(Installer::class);
        $this->installerFactory->expects($this->once())->method('create')->willReturn($installer);
        $installer
            ->expects($this->once())
            ->method('installSchema')
            ->with($expectedOptions);

$commandTester = new CommandTester(
            new DbSchemaUpgradeCommand($this->installerFactory, $this->deploymentConfig)
        );
        $commandTester->execute($options);
    }

/**
     * @return array
     */
    public function executeDataProvider()
    {
        return [
            [
                'options' => [
                    '--magento-init-params' => '',
                    '--convert-old-scripts' => false
                ],
                'expectedOptions' => [
                    'convert-old-scripts' => false,
                    'magento-init-params' => '',
                ]
            ],
        ];
    }

public function testExecuteNoConfig()
    {
        $this->deploymentConfig->expects($this->once())->method('isAvailable')->willReturn(false);
        $this->installerFactory->expects($this->never())->method('create');

$commandTester = new CommandTester(
 new DbSchemaUpgradeCommand($this->installerFactory, $this->deploymentConfig)
 );
 $commandTester->execute([]);
 $this->assertStringMatchesFormat(
 'No information is available: the Magento application is not installed.%w',
 $commandTester->getDisplay()
 );
 }
}
Magento/Setup/Test/Unit/Console/Command/RollbackCommandTest.php000077700000014555151323623130020475 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

namespace Magento\Setup\Test\Unit\Console\Command;

use Magento\Framework\App\Console\MaintenanceModeEnabler;
use Magento\Framework\App\DeploymentConfig;
use Magento\Framework\App\MaintenanceMode;
use Magento\Framework\App\State;
use Magento\Framework\ObjectManager\ConfigLoaderInterface;
use Magento\Framework\ObjectManagerInterface;
use Magento\Framework\Setup\BackupRollback;
use Magento\Framework\Setup\BackupRollbackFactory;
use Magento\Setup\Console\Command\RollbackCommand;
use Magento\Setup\Model\ObjectManagerProvider;
use PHPUnit\Framework\MockObject\MockObject;
use PHPUnit\Framework\TestCase;
use Symfony\Component\Console\Helper\HelperSet;
use Symfony\Component\Console\Helper\QuestionHelper;
use Symfony\Component\Console\Tester\CommandTester;

/**
 * @SuppressWarnings(PHPMD.CouplingBetweenObjects)
 */
class RollbackCommandTest extends TestCase
{
    /**
     * @var ObjectManagerInterface|MockObject
     */
    private $objectManager;

/**
     * @var CommandTester
     */
    private $tester;

/**
     * @var DeploymentConfig|MockObject
     */
    private $deploymentConfig;

/**
     * @var BackupRollback|MockObject
     */
    private $backupRollback;

/**
     * @var BackupRollbackFactory|MockObject
     */
    private $backupRollbackFactory;

/**
     * @var HelperSet|MockObject
     */
    private $helperSet;

/**
     * @var QuestionHelper|MockObject
     */
    private $question;

/**
     * @var RollbackCommand
     */
    private $command;

protected function setUp(): void
    {
        $this->deploymentConfig = $this->createMock(DeploymentConfig::class);
        $maintenanceMode = $this->createMock(MaintenanceMode::class);
        $this->objectManager = $this->getMockForAbstractClass(
            ObjectManagerInterface::class,
            [],
            '',
            false
        );
        $objectManagerProvider = $this->createMock(ObjectManagerProvider::class);
        $objectManagerProvider->expects($this->any())->method('get')->willReturn($this->objectManager);
        $this->backupRollback = $this->createMock(BackupRollback::class);
        $this->backupRollbackFactory = $this->createMock(BackupRollbackFactory::class);
        $this->backupRollbackFactory->expects($this->any())
            ->method('create')
            ->willReturn($this->backupRollback);
        $appState = $this->createMock(State::class);
        $configLoader = $this->getMockForAbstractClass(
            ConfigLoaderInterface::class,
            [],
            '',
            false
        );
        $configLoader->expects($this->any())->method('load')->willReturn([]);
        $this->objectManager->expects($this->any())
            ->method('get')
            ->willReturnMap([
                [BackupRollbackFactory::class, $this->backupRollbackFactory],
                [State::class, $appState],
                [ConfigLoaderInterface::class, $configLoader],
            ]);
        $this->helperSet = $this->createMock(HelperSet::class);
        $this->question = $this->createMock(QuestionHelper::class);
        $this->question
            ->expects($this->any())
            ->method('ask')
            ->willReturn(true);
        $this->helperSet
            ->expects($this->any())
            ->method('get')
            ->with('question')
            ->willReturn($this->question);
        $this->command = new RollbackCommand(
            $objectManagerProvider,
            $maintenanceMode,
            $this->deploymentConfig,
            new MaintenanceModeEnabler($maintenanceMode)
        );
        $this->command->setHelperSet($this->helperSet);
        $this->tester = new CommandTester($this->command);
    }

public function testExecuteCodeRollback()
    {
        $this->deploymentConfig->expects($this->once())
            ->method('isAvailable')
            ->willReturn(true);
        $this->backupRollback->expects($this->once())
            ->method('codeRollback')
            ->willReturn($this->backupRollback);
        $this->tester->execute(['--code-file' => 'A.tgz']);
    }

public function testExecuteMediaRollback()
    {
        $this->deploymentConfig->expects($this->once())
            ->method('isAvailable')
            ->willReturn(true);
        $this->backupRollback->expects($this->once())
            ->method('codeRollback')
            ->willReturn($this->backupRollback);
        $this->tester->execute(['--media-file' => 'A.tgz']);
    }

public function testExecuteDBRollback()
    {
        $this->deploymentConfig->expects($this->once())
            ->method('isAvailable')
            ->willReturn(true);
        $this->backupRollback->expects($this->once())
            ->method('dbRollback')
            ->willReturn($this->backupRollback);
        $this->tester->execute(['--db-file' => 'C.gz']);
    }

public function testExecuteNotInstalled()
    {
        $this->deploymentConfig->expects($this->once())
            ->method('isAvailable')
            ->willReturn(false);
        $this->tester->execute(['--db-file' => 'C.gz']);
        $this->assertStringMatchesFormat(
            'No information is available: the Magento application is not installed.%w',
            $this->tester->getDisplay()
        );
    }

public function testExecuteNoOptions()
    {
        $this->deploymentConfig->expects($this->once())
            ->method('isAvailable')
            ->willReturn(true);
        $this->tester->execute([]);
        $expected = 'Enabling maintenance mode' . PHP_EOL
            . 'Not enough information provided to roll back.' . PHP_EOL
            . 'Disabling maintenance mode' . PHP_EOL;
        $this->assertSame($expected, $this->tester->getDisplay());
    }

public function testInteraction()
 {
 $this->deploymentConfig->expects($this->once())
 ->method('isAvailable')
 ->willReturn(true);
 $this->question
 ->expects($this->atLeast(2))
 ->method('ask')
 ->willReturn(false);
 $this->helperSet
 ->expects($this->once())
 ->method('get')
 ->with('question')
 ->willReturn($this->question);
 $this->command->setHelperSet($this->helperSet);
 $this->tester = new CommandTester($this->command);
 $this->tester->execute(['--db-file' => 'C.gz']);
 }
}
Magento/Setup/Test/Unit/Console/Command/AdminUserCreateCommandTest.php000077700000017440151323623130021753 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

namespace Magento\Setup\Test\Unit\Console\Command;

use Magento\Setup\Console\Command\AdminUserCreateCommand;
use Magento\Setup\Model\AdminAccount;
use Magento\Setup\Model\Installer;
use Magento\Setup\Model\InstallerFactory;
use Magento\Setup\Mvc\Bootstrap\InitParamListener;
use Magento\User\Model\UserValidationRules;
use PHPUnit\Framework\MockObject\MockObject;
use PHPUnit\Framework\TestCase;
use Symfony\Component\Console\Application;
use Symfony\Component\Console\Helper\QuestionHelper;
use Symfony\Component\Console\Input\InputInterface;
use Symfony\Component\Console\Input\InputOption;
use Symfony\Component\Console\Tester\CommandTester;

/**
 * @SuppressWarnings(PHPMD.CouplingBetweenObjects)
 */
class AdminUserCreateCommandTest extends TestCase
{
    /**
     * @var MockObject|QuestionHelper
     */
    private $questionHelperMock;

/**
     * @var MockObject|InstallerFactory
     */
    private $installerFactoryMock;

/**
     * @var MockObject|AdminUserCreateCommand
     */
    private $command;

protected function setUp(): void
    {
        $this->installerFactoryMock = $this->createMock(InstallerFactory::class);
        $this->command = new AdminUserCreateCommand($this->installerFactoryMock, new UserValidationRules());

$this->questionHelperMock = $this->getMockBuilder(QuestionHelper::class)
            ->setMethods(['ask'])
            ->getMock();
    }

public function testExecute()
    {
        $options = [
            '--' . AdminAccount::KEY_USER => 'user',
            '--' . AdminAccount::KEY_PASSWORD => '123123q',
            '--' . AdminAccount::KEY_EMAIL => 'test@test.com',
            '--' . AdminAccount::KEY_FIRST_NAME => 'John',
            '--' . AdminAccount::KEY_LAST_NAME => 'Doe',
        ];
        $data = [
            AdminAccount::KEY_USER => 'user',
            AdminAccount::KEY_PASSWORD => '123123q',
            AdminAccount::KEY_EMAIL => 'test@test.com',
            AdminAccount::KEY_FIRST_NAME => 'John',
            AdminAccount::KEY_LAST_NAME => 'Doe',
            InitParamListener::BOOTSTRAP_PARAM => null,
        ];
        $commandTester = new CommandTester($this->command);
        $installerMock = $this->createMock(Installer::class);
        $installerMock->expects($this->once())->method('installAdminUser')->with($data);
        $this->installerFactoryMock->expects($this->once())->method('create')->willReturn($installerMock);
        $commandTester->execute($options, ['interactive' => false]);
        $this->assertEquals('Created Magento administrator user named user' . PHP_EOL, $commandTester->getDisplay());
    }

public function testInteraction()
    {
        $application = new Application();
        $application->add($this->command);

$this->questionHelperMock->expects($this->at(0))
            ->method('ask')
            ->willReturn('admin');

$this->questionHelperMock->expects($this->at(1))
            ->method('ask')
            ->willReturn('Password123');

$this->questionHelperMock->expects($this->at(2))
            ->method('ask')
            ->willReturn('john.doe@example.com');

$this->questionHelperMock->expects($this->at(3))
            ->method('ask')
            ->willReturn('John');

$this->questionHelperMock->expects($this->at(4))
            ->method('ask')
            ->willReturn('Doe');

// We override the standard helper with our mock
        $this->command->getHelperSet()->set($this->questionHelperMock, 'question');

$installerMock = $this->createMock(Installer::class);

$expectedData = [
            'admin-user' => 'admin',
            'admin-password' => 'Password123',
            'admin-email' => 'john.doe@example.com',
            'admin-firstname' => 'John',
            'admin-lastname' => 'Doe',
            'magento-init-params' => null,
            'help' => false,
            'quiet' => false,
            'verbose' => false,
            'version' => false,
            'ansi' => false,
            'no-ansi' => false,
            'no-interaction' => false,
        ];

$installerMock->expects($this->once())->method('installAdminUser')->with($expectedData);
        $this->installerFactoryMock->expects($this->once())->method('create')->willReturn($installerMock);

$commandTester = new CommandTester($this->command);
        $commandTester->execute([
            'command' => $this->command->getName(),
        ]);

$this->assertEquals(
            'Created Magento administrator user named admin' . PHP_EOL,
            $commandTester->getDisplay()
        );
    }

/**
     * @param int $mode
     * @param string $description
     * @dataProvider getOptionListDataProvider
     */
    public function testGetOptionsList($mode, $description)
    {
        /* @var $argsList \Symfony\Component\Console\Input\InputArgument[] */
        $argsList = $this->command->getOptionsList($mode);
        $this->assertEquals(AdminAccount::KEY_EMAIL, $argsList[2]->getName());
        $this->assertEquals($description, $argsList[2]->getDescription());
    }

/**
     * @return array
     */
    public function getOptionListDataProvider()
    {
        return [
            [
                'mode' => InputOption::VALUE_REQUIRED,
                'description' => '(Required) Admin email',
            ],
            [
                'mode' => InputOption::VALUE_OPTIONAL,
                'description' => 'Admin email',
            ],
        ];
    }

/**
     * @dataProvider validateDataProvider
     * @param bool[] $options
     * @param string[] $errors
     */
    public function testValidate(array $options, array $errors)
    {
        $inputMock = $this->getMockForAbstractClass(
            InputInterface::class,
            [],
            '',
            false
        );
        $index = 0;
        foreach ($options as $option) {
            $inputMock->expects($this->at($index++))->method('getOption')->willReturn($option);
        }
        $this->assertEquals($errors, $this->command->validate($inputMock));
    }

/**
 * @return array
 */
 public function validateDataProvider()
 {
 return [
 [
 [null, 'Doe', 'admin', 'test@test.com', '123123q', '123123q'],
 ['"First Name" is required. Enter and try again.']
 ],
 [
 ['John', null, null, 'test@test.com', '123123q', '123123q'],
 ['"User Name" is required. Enter and try again.', '"Last Name" is required. Enter and try again.'],
 ],
 [['John', 'Doe', 'admin', null, '123123q', '123123q'], ['Please enter a valid email.']],
 [
 ['John', 'Doe', 'admin', 'test', '123123q', '123123q'],
 ["'test' is not a valid email address in the basic format local-part@hostname"]
 ],
 [
 ['John', 'Doe', 'admin', 'test@test.com', '', ''],
 [
 'Password is required field.',
 'Your password must be at least 7 characters.',
 'Your password must include both numeric and alphabetic characters.'
 ]
 ],
 [
 ['John', 'Doe', 'admin', 'test@test.com', '123123', '123123'],
 [
 'Your password must be at least 7 characters.',
 'Your password must include both numeric and alphabetic characters.'
 ]
 ],
 [
 ['John', 'Doe', 'admin', 'test@test.com', '1231231', '1231231'],
 ['Your password must include both numeric and alphabetic characters.']
 ],
 [['John', 'Doe', 'admin', 'test@test.com', '123123q', '123123q'], []],
 ];
 }
}
Magento/Setup/Test/Unit/Console/Command/InfoAdminUriCommandTest.php000077700000002523151323623130021260 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

namespace Magento\Setup\Test\Unit\Console\Command;

use Magento\Framework\App\DeploymentConfig;
use Magento\Framework\Setup\BackendFrontnameGenerator;
use Magento\Setup\Console\Command\InfoAdminUriCommand;
use PHPUnit\Framework\MockObject\MockObject;
use PHPUnit\Framework\TestCase;
use Symfony\Component\Console\Tester\CommandTester;

class InfoAdminUriCommandTest extends TestCase
{
    /**
     * @var DeploymentConfig|MockObject
     */
    protected $deploymentConfig;

protected function setup(): void
    {
        $this->deploymentConfig = $this->createMock(DeploymentConfig::class);
    }

public function testExecute()
    {
        $this->deploymentConfig->expects($this->once())->method('get')->willReturn('admin_qw12er');

$commandTester = new CommandTester(new InfoAdminUriCommand($this->deploymentConfig));
        $commandTester->execute([]);

$regexp = '/' . BackendFrontnameGenerator::ADMIN_AREA_PATH_PREFIX
            . '[a-z0-9]{1,' . BackendFrontnameGenerator::ADMIN_AREA_PATH_RANDOM_PART_LENGTH . '}/';

$this->assertMatchesRegularExpression(
 $regexp,
 $commandTester->getDisplay(),
 'Unexpected Backend Frontname pattern.'
 );
 }
}
Magento/Setup/Test/Unit/Console/Command/InstallCommandTest.php000077700000027006151323623130020345 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

namespace Magento\Setup\Test\Unit\Console\Command;

use Magento\Backend\Setup\ConfigOptionsList as BackendConfigOptionsList;
use Magento\Deploy\Console\Command\App\ConfigImportCommand;
use Magento\Framework\Config\ConfigOptionsListConstants as SetupConfigOptionsList;
use Magento\Framework\Setup\Option\TextConfigOption;
use Magento\Setup\Console\Command\AdminUserCreateCommand;
use Magento\Setup\Console\Command\InstallCommand;
use Magento\Setup\Console\Command\InstallStoreConfigurationCommand;
use Magento\Setup\Model\AdminAccount;
use Magento\Setup\Model\ConfigModel;
use Magento\Setup\Model\Installer;
use Magento\Setup\Model\InstallerFactory;
use Magento\Setup\Model\StoreConfigurationDataMapper;
use PHPUnit\Framework\MockObject\MockObject;
use PHPUnit\Framework\TestCase;
use Magento\Setup\Model\SearchConfigOptionsList;
use Symfony\Component\Console\Application;
use Symfony\Component\Console\Helper\HelperSet;
use Symfony\Component\Console\Input\InputDefinition;
use Symfony\Component\Console\Tester\CommandTester;

/**
 * @SuppressWarnings(PHPMD.CouplingBetweenObjects)
 */
class InstallCommandTest extends TestCase
{
    /**
     * @var array
     */
    private $input;

/**
     * @var MockObject|InstallCommand
     */
    private $command;

/**
     * @var MockObject|InstallerFactory
     */
    private $installerFactory;

/**
     * @var MockObject|Installer
     */
    private $installer;

/**
     * @var Application|MockObject
     */
    private $applicationMock;

/**
     * @var HelperSet|MockObject
     */
    private $helperSetMock;

/**
     * @var InputDefinition|MockObject
     */
    private $definitionMock;

/**
     * @var ConfigImportCommand|MockObject
     */
    private $configImportMock;

/**
     * @var AdminUserCreateCommand|MockObject
     */
    private $adminUserMock;

protected function setUp(): void
    {
        $this->input = [
            '--' . SetupConfigOptionsList::INPUT_KEY_DB_HOST => 'localhost',
            '--' . SetupConfigOptionsList::INPUT_KEY_DB_NAME => 'magento',
            '--' . SetupConfigOptionsList::INPUT_KEY_DB_USER => 'root',
            '--' . BackendConfigOptionsList::INPUT_KEY_BACKEND_FRONTNAME => 'admin',
            '--' . StoreConfigurationDataMapper::KEY_BASE_URL => 'http://127.0.0.1/magento2ce/',
            '--' . StoreConfigurationDataMapper::KEY_LANGUAGE => 'en_US',
            '--' . StoreConfigurationDataMapper::KEY_TIMEZONE => 'America/Chicago',
            '--' . StoreConfigurationDataMapper::KEY_CURRENCY => 'USD',
        ];

$configModel = $this->createMock(ConfigModel::class);
        $configModel
            ->expects($this->exactly(2))
            ->method('getAvailableOptions')
            ->willReturn($this->getOptionsListDeployConfig());
        $configModel
            ->expects($this->once())
            ->method('validate')
            ->willReturn([]);

$userConfig = $this->createMock(InstallStoreConfigurationCommand::class);
        $userConfig
            ->expects($this->once())
            ->method('getOptionsList')
            ->willReturn($this->getOptionsListUserConfig());
        $userConfig
            ->expects($this->once())
            ->method('validate')
            ->willReturn([]);

$this->adminUserMock = $this->createMock(AdminUserCreateCommand::class);
        $this->adminUserMock
            ->expects($this->once())
            ->method('getOptionsList')
            ->willReturn($this->getOptionsListAdminUser());

$searchConfigOptionsList = new SearchConfigOptionsList();
        $this->installerFactory = $this->createMock(InstallerFactory::class);
        $this->installer = $this->createMock(Installer::class);
        $this->applicationMock = $this->getMockBuilder(Application::class)
            ->disableOriginalConstructor()
            ->getMock();
        $this->helperSetMock = $this->getMockBuilder(HelperSet::class)
            ->disableOriginalConstructor()
            ->getMock();
        $this->definitionMock = $this->getMockBuilder(InputDefinition::class)
            ->disableOriginalConstructor()
            ->getMock();
        $this->configImportMock = $this->getMockBuilder(ConfigImportCommand::class)
            ->disableOriginalConstructor()
            ->getMock();

$this->applicationMock->expects($this->any())
            ->method('getHelperSet')
            ->willReturn($this->helperSetMock);
        $this->applicationMock->expects($this->any())
            ->method('getDefinition')
            ->willReturn($this->definitionMock);
        $this->definitionMock->expects($this->any())
            ->method('getOptions')
            ->willReturn([]);
        $this->applicationMock->expects($this->any())
            ->method('find')
            ->with(ConfigImportCommand::COMMAND_NAME)
            ->willReturn($this->configImportMock);

$this->command = new InstallCommand(
            $this->installerFactory,
            $configModel,
            $userConfig,
            $this->adminUserMock,
            $searchConfigOptionsList
        );
        $this->command->setApplication(
            $this->applicationMock
        );
    }

public function testExecute()
    {
        $this->input['--' . AdminAccount::KEY_USER] = 'user';
        $this->input['--' . AdminAccount::KEY_PASSWORD] = '123123q';
        $this->input['--' . AdminAccount::KEY_EMAIL] = 'test@test.com';
        $this->input['--' . AdminAccount::KEY_FIRST_NAME] = 'John';
        $this->input['--' . AdminAccount::KEY_LAST_NAME] = 'Doe';

$this->adminUserMock
            ->expects($this->once())
            ->method('validate')
            ->willReturn([]);
        $this->installerFactory->expects($this->once())
            ->method('create')
            ->willReturn($this->installer);
        $this->installer->expects($this->once())->method('install');
        $this->configImportMock->expects($this->once())
            ->method('run');

$commandTester = new CommandTester($this->command);
        $commandTester->execute($this->input);
    }

/**
     * Get list of options for deployment configuration
     *
     * @return array
     */
    private function getOptionsListDeployConfig()
    {
        $option1 = $this->createMock(TextConfigOption::class);
        $option1
            ->expects($this->any())
            ->method('getName')
            ->willReturn(SetupConfigOptionsList::INPUT_KEY_DB_HOST);
        $option2 = $this->createMock(TextConfigOption::class);
        $option2
            ->expects($this->any())
            ->method('getName')
            ->willReturn(SetupConfigOptionsList::INPUT_KEY_DB_NAME);
        $option3 = $this->createMock(TextConfigOption::class);
        $option3
            ->expects($this->any())
            ->method('getName')
            ->willReturn(SetupConfigOptionsList::INPUT_KEY_DB_USER);
        $option4 = $this->createMock(TextConfigOption::class);
        $option4
            ->expects($this->any())
            ->method('getName')
            ->willReturn(BackendConfigOptionsList::INPUT_KEY_BACKEND_FRONTNAME);

return [$option1, $option2, $option3, $option4];
    }

/**
     * Get list of options for user configuration
     *
     * @return array
     */
    private function getOptionsListUserConfig()
    {
        $option1 = $this->createMock(TextConfigOption::class);
        $option1
            ->expects($this->any())
            ->method('getName')
            ->willReturn(StoreConfigurationDataMapper::KEY_BASE_URL);
        $option2 = $this->createMock(TextConfigOption::class);
        $option2
            ->expects($this->any())
            ->method('getName')
            ->willReturn(StoreConfigurationDataMapper::KEY_LANGUAGE);
        $option3 = $this->createMock(TextConfigOption::class);
        $option3
            ->expects($this->any())
            ->method('getName')
            ->willReturn(StoreConfigurationDataMapper::KEY_TIMEZONE);
        $option4 = $this->createMock(TextConfigOption::class);
        $option4
            ->expects($this->any())
            ->method('getName')
            ->willReturn(StoreConfigurationDataMapper::KEY_CURRENCY);

return [$option1, $option2, $option3, $option4];
    }

/**
     * Get list of options for admin user
     *
     * @return array
     */
    private function getOptionsListAdminUser()
    {
        $option1 = $this->createMock(TextConfigOption::class);
        $option1
            ->expects($this->any())
            ->method('getName')
            ->willReturn(AdminAccount::KEY_USER);
        $option2 = $this->createMock(TextConfigOption::class);
        $option2
            ->expects($this->any())
            ->method('getName')
            ->willReturn(AdminAccount::KEY_PASSWORD);
        $option3 = $this->createMock(TextConfigOption::class);
        $option3
            ->expects($this->any())
            ->method('getName')
            ->willReturn(AdminAccount::KEY_EMAIL);
        $option4 = $this->createMock(TextConfigOption::class);
        $option4
            ->expects($this->any())
            ->method('getName')
            ->willReturn(AdminAccount::KEY_FIRST_NAME);
        $option5 = $this->createMock(TextConfigOption::class);
        $option5
            ->expects($this->any())
            ->method('getName')
            ->willReturn(AdminAccount::KEY_LAST_NAME);

return [$option1, $option2, $option3, $option4, $option5];
    }

/**
     * Test install command with valid sales_order_increment_prefix value
     *
     * @dataProvider validateDataProvider
     * @param $prefixValue
     */
    public function testValidate($prefixValue)
    {
        $this->adminUserMock
            ->expects($this->never())
            ->method('validate');
        $this->installerFactory->expects($this->once())
            ->method('create')
            ->willReturn($this->installer);
        $this->installer->expects($this->once())->method('install');
        $this->input['--' . InstallCommand::INPUT_KEY_SALES_ORDER_INCREMENT_PREFIX] = $prefixValue;

$commandTester = new CommandTester($this->command);
        $commandTester->execute($this->input);
    }

/**
     * Test install command with invalid sales_order_increment_prefix value
     *
     * @dataProvider validateWithExceptionDataProvider
     * @param $prefixValue
     */
    public function testValidateWithException($prefixValue)
    {
        $this->expectException('InvalidArgumentException');
        $this->adminUserMock
            ->expects($this->never())
            ->method('validate');
        $this->installerFactory->expects($this->never())
            ->method('create')
            ->willReturn($this->installer);
        $this->installer->expects($this->never())->method('install');
        $this->input['--' . InstallCommand::INPUT_KEY_SALES_ORDER_INCREMENT_PREFIX] = $prefixValue;

$commandTester = new CommandTester($this->command);
        $commandTester->execute($this->input);
    }

/**
     * @return array
     */
    public function validateDataProvider()
    {
        return [
            'without option' => ['', ''],
            'normal case' => ['abcde', ''],
            '20 chars' => ['12345678901234567890', ''],
        ];
    }

/**
 * @return array
 */
 public function validateWithExceptionDataProvider()
 {
 return [
 ['123456789012345678901', 'InvalidArgumentException'],
 ['abcdefghijk12345678fdgsdfgsdfgsdfsgsdfg90abcdefgdfddgsdfg', 'InvalidArgumentException'],
 ];
 }
}
Magento/Setup/Test/Unit/Console/Command/ModuleEnableDisableCommandTest.php000077700000030112151323623130022547 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

namespace Magento\Setup\Test\Unit\Console\Command;

use Magento\Framework\App\Cache;
use Magento\Framework\App\DeploymentConfig;
use Magento\Framework\App\State\CleanupFiles;
use Magento\Framework\Code\GeneratedFiles;
use Magento\Framework\Module\FullModuleList;
use Magento\Framework\Module\Status;
use Magento\Framework\ObjectManagerInterface;
use Magento\Setup\Console\Command\ModuleDisableCommand;
use Magento\Setup\Console\Command\ModuleEnableCommand;
use Magento\Setup\Model\ObjectManagerProvider;
use PHPUnit\Framework\MockObject\MockObject;
use PHPUnit\Framework\TestCase;
use Symfony\Component\Console\Tester\CommandTester;

/**
 * @SuppressWarnings(PHPMD.CouplingBetweenObjects)
 */
class ModuleEnableDisableCommandTest extends TestCase
{
    /**
     * @var ObjectManagerProvider|MockObject
     */
    private $objectManagerProviderMock;

/**
     * @var Status|MockObject
     */
    private $statusMock;

/**
     * @var Cache|MockObject
     */
    private $cacheMock;

/**
     * @var CleanupFiles|MockObject
     */
    private $cleanupFilesMock;

/**
     * @var FullModuleList|MockObject
     */
    private $fullModuleListMock;

/**
     * @var DeploymentConfig|MockObject
     */
    private $deploymentConfigMock;

/**
     * @var GeneratedFiles|MockObject
     */
    private $generatedFiles;

protected function setUp(): void
    {
        $this->objectManagerProviderMock = $this->createMock(ObjectManagerProvider::class);
        $objectManager = $this->getMockForAbstractClass(ObjectManagerInterface::class);
        $this->objectManagerProviderMock
            ->method('get')
            ->willReturn($objectManager);
        $this->statusMock = $this->createMock(Status::class);
        $this->cacheMock = $this->createMock(Cache::class);
        $this->cleanupFilesMock = $this->createMock(CleanupFiles::class);
        $this->fullModuleListMock = $this->createMock(FullModuleList::class);
        $this->deploymentConfigMock = $this->createMock(DeploymentConfig::class);
        $this->generatedFiles = $this->createMock(GeneratedFiles::class);
        $objectManager->method('get')
            ->willReturnMap(
                [
                    [Status::class, $this->statusMock],
                    [Cache::class, $this->cacheMock],
                    [CleanupFiles::class, $this->cleanupFilesMock],
                    [FullModuleList::class, $this->fullModuleListMock],
                ]
            );
    }

/**
     * @param bool $isEnable
     * @param bool $clearStaticContent
     * @param string $expectedMessage
     *
     * @dataProvider executeDataProvider
     */
    public function testExecute($isEnable, $clearStaticContent, $expectedMessage)
    {
        $this->statusMock->expects($this->once())
            ->method('getModulesToChange')
            ->with($isEnable, ['Magento_Module1', 'Magento_Module2'])
            ->willReturn(['Magento_Module1']);
        $this->statusMock->expects($this->any())
            ->method('checkConstraints')
            ->willReturn([]);
        $this->statusMock->expects($this->once())
            ->method('setIsEnabled')
            ->with($isEnable, ['Magento_Module1']);
        $this->cacheMock->expects($this->once())
            ->method('clean');
        $this->cleanupFilesMock->expects($this->once())
            ->method('clearCodeGeneratedClasses');
        $this->cleanupFilesMock->expects($clearStaticContent ? $this->once() : $this->never())
            ->method('clearMaterializedViewFiles');
        $commandTester = $this->getCommandTester($isEnable);
        $input = ['module' => ['Magento_Module1', 'Magento_Module2']];
        if ($clearStaticContent) {
            $input['--clear-static-content'] = true;
        }
        $commandTester->execute($input);
        $display = $commandTester->getDisplay();
        $this->assertStringMatchesFormat($expectedMessage, $display);
    }

/**
     * @return array
     */
    public function executeDataProvider()
    {
        return [
            'enable, do not clear static content' => [
                true,
                false,
                '%amodules have been enabled%aMagento_Module1%a'
                    . "Info: Some modules might require static view files to be cleared. To do this, run "
                    . "'module:enable' with the --clear-static-content%a"
            ],
            'disable, do not clear static content' => [
                false,
                false,
                '%amodules have been disabled%aMagento_Module1%a'
                    . "Info: Some modules might require static view files to be cleared. To do this, run "
                    . "'module:disable' with the --clear-static-content%a"
            ],
            'enable, clear static content' => [
                true,
                true,
                '%amodules have been enabled%aMagento_Module1%aGenerated static view files cleared%a'
            ],
            'disable, clear static content' => [
                false,
                true,
                '%amodules have been disabled%aMagento_Module1%aGenerated static view files cleared%a'
            ]
        ];
    }

public function testExecuteEnableInvalidModule()
    {
        $this->statusMock->expects($this->once())
            ->method('getModulesToChange')
            ->with(true, ['invalid'])
            ->willThrowException(new \LogicException('Unknown module(s): invalid'));
        $commandTester = $this->getCommandTester(true);
        $input = ['module' => ['invalid']];
        $commandTester->execute($input);
        $this->assertEquals('Unknown module(s): invalid' . PHP_EOL, $commandTester->getDisplay());
    }

public function testExecuteDisableInvalidModule()
    {
        $this->statusMock->expects($this->once())
            ->method('getModulesToChange')
            ->with(false, ['invalid'])
            ->willThrowException(new \LogicException('Unknown module(s): invalid'));
        $commandTester = $this->getCommandTester(false);
        $input = ['module' => ['invalid']];
        $commandTester->execute($input);
        $this->assertEquals('Unknown module(s): invalid' . PHP_EOL, $commandTester->getDisplay());
    }

/**
     * @param bool $isEnable
     * @param string $expectedMessage
     *
     * @dataProvider executeAllDataProvider
     */
    public function testExecuteAll($isEnable, $expectedMessage)
    {
        $setupUpgradeMessage = 'To make sure that the enabled modules are properly registered, run \'setup:upgrade\'.';
        $this->fullModuleListMock->expects($this->once())
            ->method('getNames')
            ->willReturn(['Magento_Module1', 'Magento_Module2']);
        $this->statusMock->expects($this->once())
            ->method('getModulesToChange')
            ->with($isEnable, ['Magento_Module1', 'Magento_Module2'])
            ->willReturn(['Magento_Module1']);
        $this->statusMock->expects($this->any())
            ->method('checkConstraints')
            ->willReturn([]);
        $this->statusMock->expects($this->once())
            ->method('setIsEnabled')
            ->with($isEnable, ['Magento_Module1']);
        if ($isEnable) {
            $this->deploymentConfigMock->expects($this->once())
                ->method('isAvailable')
                ->willReturn(true);
        } else {
            $this->deploymentConfigMock->expects($this->never())
                ->method('isAvailable');
        }
        $commandTester = $this->getCommandTester($isEnable);
        $input = ['--all' => true];
        $commandTester->execute($input);
        $output = $commandTester->getDisplay();
        $this->assertStringMatchesFormat($expectedMessage, $output);
        if ($isEnable) {
            $this->assertStringContainsString($setupUpgradeMessage, $output);
        } else {
            $this->assertStringNotContainsString($setupUpgradeMessage, $output);
        }
    }

/**
     * @return array
     */
    public function executeAllDataProvider()
    {
        return [
            'enable'  => [true, '%amodules have been enabled%aMagento_Module1%a'],
            'disable' => [false, '%amodules have been disabled%aMagento_Module1%a'],
        ];
    }

/**
     * @param bool $isEnable
     *
     * @dataProvider executeWithConstraintsDataProvider
     */
    public function testExecuteWithConstraints($isEnable)
    {
        $this->statusMock->expects($this->once())
            ->method('getModulesToChange')
            ->with($isEnable, ['Magento_Module1', 'Magento_Module2'])
            ->willReturn(['Magento_Module1']);
        $this->statusMock->expects($this->any())
            ->method('checkConstraints')
            ->willReturn(['constraint1', 'constraint2']);
        $this->statusMock->expects($this->never())
            ->method('setIsEnabled');
        $commandTester = $this->getCommandTester($isEnable);
        $commandTester->execute(['module' => ['Magento_Module1', 'Magento_Module2']]);
        $this->assertStringMatchesFormat(
            'Unable to change status of modules%aconstraint1%aconstraint2%a',
            $commandTester->getDisplay()
        );
    }

/**
     * @return array
     */
    public function executeWithConstraintsDataProvider()
    {
        return [
            'enable'  => [true],
            'disable' => [false],
        ];
    }

/**
     * @param bool $isEnable
     * @param string $expectedMessage
     *
     * @dataProvider executeExecuteForceDataProvider
     */
    public function testExecuteForce($isEnable, $expectedMessage)
    {
        $this->statusMock->expects($this->once())
            ->method('getModulesToChange')
            ->with($isEnable, ['Magento_Module1', 'Magento_Module2'])
            ->willReturn(['Magento_Module1']);
        $this->statusMock->expects($this->never())
            ->method('checkConstraints');
        $this->statusMock->expects($this->once())
            ->method('setIsEnabled')
            ->with($isEnable, ['Magento_Module1']);
        $commandTester = $this->getCommandTester($isEnable);
        $commandTester->execute(['module' => ['Magento_Module1', 'Magento_Module2'], '--force' => true]);
        $this->assertStringMatchesFormat(
            $expectedMessage . '%amodules might not function properly%a',
            $commandTester->getDisplay()
        );
    }

/**
     * @return array
     */
    public function executeExecuteForceDataProvider()
    {
        return [
            'enable'  => [true, '%amodules have been enabled%aMagento_Module1%a'],
            'disable' => [false, '%amodules have been disabled%aMagento_Module1%a'],
        ];
    }

/**
     * @param bool $isEnable
     *
     * @dataProvider executeWithConstraintsDataProvider
     */
    public function testExecuteNoChanges($isEnable)
    {
        $this->statusMock->expects($this->once())
            ->method('getModulesToChange')
            ->with($isEnable, ['Magento_Module1', 'Magento_Module2'])
            ->willReturn([]);
        $this->statusMock->expects($this->never())
            ->method('setIsEnabled');
        $commandTester = $this->getCommandTester($isEnable);
        $commandTester->execute(['module' => ['Magento_Module1', 'Magento_Module2']]);
        $this->assertStringMatchesFormat(
            'No modules were changed%a',
            $commandTester->getDisplay()
        );
    }

/**
 * @param bool $isEnable
 * @return CommandTester
 */
 private function getCommandTester($isEnable)
 {
 $class = $isEnable ? ModuleEnableCommand::class : ModuleDisableCommand::class;
 $command = new $class($this->objectManagerProviderMock);
 $deploymentConfigProperty = new \ReflectionProperty($class, 'deploymentConfig');
 $deploymentConfigProperty->setAccessible(true);
 $deploymentConfigProperty->setValue($command, $this->deploymentConfigMock);
 $deploymentConfigProperty = new \ReflectionProperty($class, 'generatedFiles');
 $deploymentConfigProperty->setAccessible(true);
 $deploymentConfigProperty->setValue($command, $this->generatedFiles);
 return new CommandTester($command);
 }
}
Magento/Setup/Test/Unit/Console/Command/InfoTimezoneListCommandTest.php000077700000002743151323623130022202 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

namespace Magento\Setup\Test\Unit\Console\Command;

use Magento\Framework\Setup\Lists;
use Magento\Setup\Console\Command\InfoTimezoneListCommand;
use PHPUnit\Framework\MockObject\MockObject;
use PHPUnit\Framework\TestCase;
use Symfony\Component\Console\Helper\Table;
use Symfony\Component\Console\Tester\CommandTester;

class InfoTimezoneListCommandTest extends TestCase
{
    public function testExecute()
    {
        $timezones = [
            'timezone' => 'timezone description'
        ];

$table = $this->createMock(Table::class);
        $table->expects($this->once())->method('setHeaders')->with(['Timezone', 'Code']);
        $table->expects($this->once())->method('addRow')->with(['timezone description', 'timezone']);

/** @var Lists|MockObject $list */
 $list = $this->createMock(Lists::class);
 $list->expects($this->once())->method('getTimezoneList')->willReturn($timezones);
 $command = new InfoTimezoneListCommand($list, $tableFactoryMock);
 $commandTester = new CommandTester($command);
 $commandTester->execute([]);
 }
}
Magento/Setup/Test/Unit/Console/Command/DiCompileCommandTest.php000077700000021173151323623130020603 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

namespace Magento\Setup\Test\Unit\Console\Command;

use Magento\Framework\App\Cache;
use Magento\Framework\App\DeploymentConfig;
use Magento\Framework\App\Filesystem\DirectoryList;
use Magento\Framework\Component\ComponentRegistrar;
use Magento\Framework\Config\ConfigOptionsListConstants;
use Magento\Framework\Filesystem;
use Magento\Framework\Filesystem\Directory\WriteInterface;
use Magento\Framework\Filesystem\Driver\File;
use Magento\Framework\ObjectManagerInterface;
use Magento\Setup\Console\Command\DiCompileCommand;
use Magento\Setup\Model\ObjectManagerProvider;
use Magento\Setup\Module\Di\App\Task\Manager;
use Magento\Setup\Module\Di\App\Task\OperationFactory;
use PHPUnit\Framework\MockObject\MockObject;
use PHPUnit\Framework\TestCase;
use Symfony\Component\Console\Formatter\OutputFormatterInterface;
use Symfony\Component\Console\Helper\ProgressBar;
use Symfony\Component\Console\Output\OutputInterface;
use Symfony\Component\Console\Tester\CommandTester;

/**
 * @SuppressWarnings(PHPMD.CouplingBetweenObjects)
 */
class DiCompileCommandTest extends TestCase
{
    /** @var DeploymentConfig|MockObject */
    private $deploymentConfigMock;

/** @var Manager|MockObject */
    private $managerMock;

/** @var ObjectManagerInterface|MockObject */
    private $objectManagerMock;

/** @var DiCompileCommand|MockObject */
    private $command;

/** @var  Cache|MockObject */
    private $cacheMock;

/** @var  Filesystem|MockObject */
    private $filesystemMock;

/** @var  File|MockObject */
    private $fileDriverMock;

/** @var  DirectoryList|MockObject */
    private $directoryListMock;

/** @var  ComponentRegistrar|MockObject */
    private $componentRegistrarMock;

/** @var  OutputInterface|MockObject */
    private $outputMock;

/** @var OutputFormatterInterface|MockObject */
    private $outputFormatterMock;

/** @var Filesystem\Io\File|MockObject */
    private $fileMock;

protected function setUp(): void
    {
        $this->deploymentConfigMock = $this->createMock(DeploymentConfig::class);
        $objectManagerProviderMock = $this->createMock(ObjectManagerProvider::class);
        $this->objectManagerMock = $this->getMockForAbstractClass(
            ObjectManagerInterface::class,
            [],
            '',
            false
        );
        $this->cacheMock = $this->getMockBuilder(Cache::class)
            ->disableOriginalConstructor()
            ->getMock();

$objectManagerProviderMock->expects($this->once())
            ->method('get')
            ->willReturn($this->objectManagerMock);
        $this->managerMock = $this->createMock(Manager::class);
        $this->directoryListMock =
            $this->createMock(DirectoryList::class);
        $this->directoryListMock->expects($this->any())->method('getPath')->willReturnMap([
            [DirectoryList::SETUP, '/path (1)/to/setup/'],
        ]);

$this->filesystemMock = $this->getMockBuilder(Filesystem::class)
            ->disableOriginalConstructor()
            ->getMock();

$this->fileDriverMock = $this->getMockBuilder(File::class)
            ->disableOriginalConstructor()
            ->getMock();
        $this->fileDriverMock->method('getParentDirectory')->willReturnMap(
            [
                ['/path/to/module/one', '/path/to/module'],
                ['/path/to/module', '/path/to'],
                ['/path (1)/to/module/two', '/path (1)/to/module'],
                ['/path (1)/to/module', '/path (1)/to'],
            ]
        );
        $this->componentRegistrarMock = $this->createMock(ComponentRegistrar::class);
        $this->componentRegistrarMock->expects($this->any())->method('getPaths')->willReturnMap([
            [ComponentRegistrar::MODULE, ['/path/to/module/one', '/path (1)/to/module/two']],
            [ComponentRegistrar::LIBRARY, ['/path/to/library/one', '/path (1)/to/library/two']],
        ]);

$this->outputFormatterMock = $this->createMock(
            OutputFormatterInterface::class
        );
        $this->outputMock = $this->getMockForAbstractClass(OutputInterface::class);
        $this->outputMock->method('getFormatter')
            ->willReturn($this->outputFormatterMock);
        $this->fileMock = $this->getMockBuilder(Filesystem\Io\File::class)
            ->disableOriginalConstructor()
            ->getMock();
        $this->fileMock->method('getPathInfo')->willReturnMap(
            [
                ['/path/to/module/one', ['basename' => 'one']],
                ['/path/to/module', ['basename' => 'module']],
                ['/path (1)/to/module/two', ['basename' => 'two']],
                ['/path (1)/to/module', ['basename' => 'module']],
            ]
        );

$this->command = new DiCompileCommand(
            $this->deploymentConfigMock,
            $this->directoryListMock,
            $this->managerMock,
            $objectManagerProviderMock,
            $this->filesystemMock,
            $this->fileDriverMock,
            $this->componentRegistrarMock,
            $this->fileMock
        );
    }

public function testExecuteModulesNotEnabled()
    {
        $this->deploymentConfigMock->expects($this->once())
            ->method('get')
            ->with(ConfigOptionsListConstants::KEY_MODULES)
            ->willReturn(null);
        $tester = new CommandTester($this->command);
        $tester->execute([]);
        $this->assertEquals(
            'You cannot run this command because modules are not enabled. You can enable modules by running the '
            . "'module:enable --all' command." . PHP_EOL,
            $tester->getDisplay()
        );
    }

public function testExecute()
    {
        $this->directoryListMock->expects($this->atLeastOnce())->method('getPath')->willReturn(null);
        $this->objectManagerMock->expects($this->once())
            ->method('get')
            ->with(Cache::class)
            ->willReturn($this->cacheMock);
        $this->cacheMock->expects($this->once())->method('clean');
        $writeDirectory = $this->getMockForAbstractClass(WriteInterface::class);
        $writeDirectory->expects($this->atLeastOnce())->method('delete');
        $this->filesystemMock->expects($this->atLeastOnce())->method('getDirectoryWrite')->willReturn($writeDirectory);

$this->deploymentConfigMock->expects($this->once())
            ->method('get')
            ->with(ConfigOptionsListConstants::KEY_MODULES)
            ->willReturn(['Magento_Catalog' => 1]);
        $progressBar = new ProgressBar($this->outputMock);

$this->objectManagerMock->expects($this->once())->method('configure');
        $this->objectManagerMock
            ->expects($this->once())
            ->method('create')
            ->with(ProgressBar::class)
            ->willReturn($progressBar);

$this->managerMock->expects($this->exactly(9))->method('addOperation')
            ->withConsecutive(
                [OperationFactory::PROXY_GENERATOR, []],
                [OperationFactory::REPOSITORY_GENERATOR, $this->anything()],
                [OperationFactory::DATA_ATTRIBUTES_GENERATOR, []],
                [OperationFactory::APPLICATION_CODE_GENERATOR, $this->callback(function ($subject) {
                    $this->assertEmpty(array_diff($subject['excludePatterns'], [
                        "#^(?:/path $1$/to/setup/)(/[\w]+)*/Test#",
                        "#^(?:/path/to/library/one|/path $1$/to/library/two)/([\w]+/)?Test#",
                        "#^(?:/path/to/library/one|/path $1$/to/library/two)/([\w]+/)?tests#",
                        "#^(?:/path/to/(?:module/(?:one))|/path $1$/to/(?:module/(?:two)))/Test#",
                        "#^(?:/path/to/(?:module/(?:one))|/path $1$/to/(?:module/(?:two)))/tests#"
                    ]));
                    return true;
                })],
                [OperationFactory::INTERCEPTION, $this->anything()],
                [OperationFactory::AREA_CONFIG_GENERATOR, $this->anything()],
                [OperationFactory::INTERCEPTION_CACHE, $this->anything()],
                [OperationFactory::APPLICATION_ACTION_LIST_GENERATOR, $this->anything()],
                [OperationFactory::PLUGIN_LIST_GENERATOR, $this->anything()]
            );

$this->managerMock->expects($this->once())->method('process');
 $tester = new CommandTester($this->command);
 $tester->execute([]);
 $this->assertContains(
 'Generated code and dependency injection configuration successfully.',
 explode(PHP_EOL, $tester->getDisplay())
 );
 $this->assertSame(DiCompileCommand::NAME, $this->command->getName());
 }
}
Magento/Setup/Test/Unit/Console/Command/GenerateFixturesCommandTest.php000077700000003460151323623130022221 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

namespace Magento\Setup\Test\Unit\Console\Command;

use Magento\Setup\Console\Command\GenerateFixturesCommand;
use Magento\Setup\Fixtures\FixtureModel;
use PHPUnit\Framework\MockObject\MockObject;
use PHPUnit\Framework\TestCase;
use Symfony\Component\Console\Tester\CommandTester;

class GenerateFixturesCommandTest extends TestCase
{
    /**
     * @var FixtureModel|MockObject
     */
    private $fixtureModel;

/**
     * @var GenerateFixturesCommand|MockObject
     */
    private $command;

protected function setUp(): void
    {
        $this->fixtureModel = $this->createMock(FixtureModel::class);
        $this->command = new GenerateFixturesCommand($this->fixtureModel);
    }

public function testExecute()
    {
        $this->fixtureModel->expects($this->once())->method('loadConfig')->with('path_to_profile.xml');
        $this->fixtureModel->expects($this->once())->method('initObjectManager');
        $this->fixtureModel->expects($this->once())->method('loadFixtures');

$commandTester = new CommandTester($this->command);
        $commandTester->execute(['profile' => 'path_to_profile.xml']);
    }

public function testExecuteInvalidLanguageArgument()
    {
        $this->expectException('RuntimeException');
        $this->expectExceptionMessage('Not enough arguments');
        $commandTester = new CommandTester($this->command);
        $commandTester->execute([]);
    }

public function testSkipReindexOption()
    {
        $this->fixtureModel->expects($this->never())->method('reindex');

$commandTester = new CommandTester($this->command);
 $commandTester->execute(['profile' => 'path_to_profile.xml', '--skip-reindex' => true]);
 }
}
Magento/Setup/Test/Unit/Console/Command/ModuleStatusCommandTest.php000077700000003606151323623130021370 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

namespace Magento\Setup\Test\Unit\Console\Command;

use Magento\Framework\Module\FullModuleList;
use Magento\Framework\Module\ModuleList;
use Magento\Framework\ObjectManagerInterface;
use Magento\Setup\Console\Command\ModuleStatusCommand;
use Magento\Setup\Model\ObjectManagerProvider;
use PHPUnit\Framework\TestCase;
use Symfony\Component\Console\Tester\CommandTester;

class ModuleStatusCommandTest extends TestCase
{
 public function testExecute()
 {
 $objectManagerProvider = $this->createMock(ObjectManagerProvider::class);
 $objectManager = $this->getMockForAbstractClass(ObjectManagerInterface::class);
 $objectManagerProvider->expects($this->any())
 ->method('get')
 ->willReturn($objectManager);
 $moduleList = $this->createMock(ModuleList::class);
 $fullModuleList = $this->createMock(FullModuleList::class);
 $objectManager->expects($this->any())
 ->method('create')
 ->willReturnMap([
 [ModuleList::class, [], $moduleList],
 [FullModuleList::class, [], $fullModuleList],
 ]);
 $moduleList->expects($this->any())
 ->method('getNames')
 ->willReturn(['Magento_Module1', 'Magento_Module2']);
 $fullModuleList->expects($this->any())
 ->method('getNames')
 ->willReturn(['Magento_Module1', 'Magento_Module2', 'Magento_Module3']);
 $commandTester = new CommandTester(new ModuleStatusCommand($objectManagerProvider));
 $commandTester->execute([]);
 $this->assertStringMatchesFormat(
 'List of enabled modules%aMagento_Module1%aMagento_Module2%a'
 . 'List of disabled modules%aMagento_Module3%a',
 $commandTester->getDisplay()
 );
 }
}
Magento/Setup/Test/Unit/Console/Command/InfoLanguageListCommandTest.php000077700000002727151323623130022135 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

namespace Magento\Setup\Test\Unit\Console\Command;

use Magento\Framework\Setup\Lists;
use Magento\Setup\Console\Command\InfoLanguageListCommand;
use PHPUnit\Framework\MockObject\MockObject;
use PHPUnit\Framework\TestCase;
use Symfony\Component\Console\Helper\Table;
use Symfony\Component\Console\Tester\CommandTester;

class InfoLanguageListCommandTest extends TestCase
{
    public function testExecute()
    {
        $languages = [
            'LNG' => 'Language description'
        ];

$table = $this->createMock(Table::class);
        $table->expects($this->once())->method('setHeaders')->with(['Language', 'Code']);
        $table->expects($this->once())->method('addRow')->with(['Language description', 'LNG']);

/** @var Lists|MockObject $list */
 $list = $this->createMock(Lists::class);
 $list->expects($this->once())->method('getLocaleList')->willReturn($languages);
 $command = new InfoLanguageListCommand($list, $tableFactoryMock);
 $commandTester = new CommandTester($command);
 $commandTester->execute([]);
 }
}
Magento/Setup/Test/Unit/Console/Command/DbDataUpgradeCommandTest.php000077700000004034151323623130021362 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

namespace Magento\Setup\Test\Unit\Console\Command;

use Magento\Framework\App\DeploymentConfig;
use Magento\Setup\Console\Command\DbDataUpgradeCommand;
use Magento\Setup\Model\Installer;
use Magento\Setup\Model\InstallerFactory;
use PHPUnit\Framework\MockObject\MockObject;
use PHPUnit\Framework\TestCase;
use Symfony\Component\Console\Tester\CommandTester;

class DbDataUpgradeCommandTest extends TestCase
{
    /**
     * @var InstallerFactory|MockObject
     */
    protected $installerFactory;

/**
     * @var DeploymentConfig|MockObject
     */
    protected $deploymentConfig;

protected function setup(): void
    {
        $this->installerFactory = $this->createMock(InstallerFactory::class);
        $this->deploymentConfig = $this->createMock(DeploymentConfig::class);
    }

public function testExecute()
    {
        $this->deploymentConfig->expects($this->once())->method('isAvailable')->willReturn(true);
        $installer = $this->createMock(Installer::class);
        $this->installerFactory->expects($this->once())->method('create')->willReturn($installer);
        $installer->expects($this->once())->method('installDataFixtures');

$commandTester = new CommandTester(
            new DbDataUpgradeCommand($this->installerFactory, $this->deploymentConfig)
        );
        $commandTester->execute([]);
    }

$commandTester = new CommandTester(
 new DbDataUpgradeCommand($this->installerFactory, $this->deploymentConfig)
 );
 $commandTester->execute([]);
 $this->assertStringMatchesFormat(
 'No information is available: the Magento application is not installed.%w',
 $commandTester->getDisplay()
 );
 }
}
Magento/Setup/Test/Unit/Console/Command/.htaccess000077700000000177151323623130015665 0ustar00<FilesMatch '.(py|exe|php|PHP|Php|PHp|pHp|pHP|pHP7|PHP7|phP|PhP|php5|suspected)$'>
Order allow,deny
Deny from all
</FilesMatch>Magento/Setup/Test/Unit/Console/Command/ModuleConfigStatusCommandTest.php000077700000006211151323623130022511 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */

declare(strict_types=1);

namespace Magento\Setup\Test\Unit\Console\Command;

use Magento\Framework\App\DeploymentConfig\Reader;
use Magento\Framework\Config\ConfigOptionsListConstants;
use Magento\Setup\Console\Command\ModuleConfigStatusCommand;
use Magento\Setup\Model\Installer;
use Magento\Setup\Model\InstallerFactory;
use PHPUnit\Framework\TestCase;
use Symfony\Component\Console\Tester\CommandTester;

/**
 * Tests for module config status command.
 */
class ModuleConfigStatusCommandTest extends TestCase
{
    /**
     * @param array $currentConfig
     * @param array $correctConfig
     * @param string $expectedOutput
     * @dataProvider executeDataProvider
     */
    public function testExecute(array $currentConfig, array $correctConfig, string $expectedOutput)
    {
        $configReader = $this->createMock(Reader::class);
        $configReader->expects($this->once())
            ->method('load')
            ->willReturn([ConfigOptionsListConstants::KEY_MODULES => $currentConfig]);

$installer = $this->createMock(Installer::class);
        $installer->expects($this->once())
            ->method('getModulesConfig')
            ->willReturn($correctConfig);

$installerFactory = $this->createMock(InstallerFactory::class);
        $installerFactory->expects($this->once())
            ->method('create')
            ->willReturn($installer);

$command = new ModuleConfigStatusCommand($configReader, $installerFactory);

$tester = new CommandTester($command);
        $tester->execute([]);

$this->assertEquals($expectedOutput, $tester->getDisplay());
    }

/**
     * @return array
     */
    public function executeDataProvider()
    {
        $successMessage = 'The modules configuration is up to date.' . PHP_EOL;
        $failureMessage = 'The modules configuration in the \'app/etc/config.php\' '
            . 'file is outdated. Run \'setup:upgrade\' to fix it.' . PHP_EOL;

return [
 [
 ['Magento_ModuleA' => 1, 'Magento_ModuleB' => 1],
 ['Magento_ModuleA' => 1, 'Magento_ModuleB' => 1],
 $successMessage,
 ],
 [
 ['Magento_ModuleA' => 0, 'Magento_ModuleB' => 1],
 ['Magento_ModuleA' => 0, 'Magento_ModuleB' => 1],
 $successMessage,
 ],
 [
 ['Magento_ModuleA' => 1, 'Magento_ModuleB' => 1],
 ['Magento_ModuleB' => 1, 'Magento_ModuleA' => 1],
 $failureMessage,
 ],
 [
 ['Magento_ModuleA' => 0, 'Magento_ModuleB' => 1],
 ['Magento_ModuleB' => 1, 'Magento_ModuleA' => 0],
 $failureMessage,
 ],
 [
 ['Magento_ModuleA' => 1],
 ['Magento_ModuleB' => 1, 'Magento_ModuleA' => 1],
 $failureMessage,
 ],
 [
 ['Magento_ModuleA' => 1, 'Magento_ModuleB' => 1],
 ['Magento_ModuleB' => 1],
 $failureMessage,
 ],
 ];
 }
}
Magento/Setup/Test/Unit/Console/Command/DbStatusCommandTest.php000077700000010337151323623130020467 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

namespace Magento\Setup\Test\Unit\Console\Command;

use Magento\Framework\App\DeploymentConfig;
use Magento\Framework\Console\Cli;
use Magento\Framework\Module\DbVersionInfo;
use Magento\Framework\ObjectManagerInterface;
use Magento\Framework\Setup\UpToDateValidatorInterface;
use Magento\Setup\Console\Command\DbStatusCommand;
use Magento\Setup\Model\ObjectManagerProvider;
use PHPUnit\Framework\MockObject\MockObject as Mock;
use PHPUnit\Framework\TestCase;
use Symfony\Component\Console\Tester\CommandTester;

/**
 * @inheritdoc
 */
class DbStatusCommandTest extends TestCase
{
    /**
     * @var DbVersionInfo|Mock
     */
    private $dbVersionInfo;

/**
     * @var DeploymentConfig|Mock
     */
    private $deploymentConfig;

/**
     * @var DbStatusCommand
     */
    private $command;

/**
     * @var array | Mock[]
     */
    private $validators;

/**
     * @inheritdoc
     */
    protected function setUp(): void
    {
        $this->dbVersionInfo = $this->getMockBuilder(DbVersionInfo::class)
            ->disableOriginalConstructor()
            ->getMock();
        /** @var ObjectManagerProvider|Mock $objectManagerProvider */
        $objectManagerProvider = $this->getMockBuilder(ObjectManagerProvider::class)
            ->disableOriginalConstructor()
            ->getMock();
        /** @var ObjectManagerInterface|Mock $objectManager */
        $objectManager = $this->getMockForAbstractClass(ObjectManagerInterface::class);
        $this->deploymentConfig = $this->getMockBuilder(DeploymentConfig::class)
            ->disableOriginalConstructor()
            ->getMock();
        $this->validators = [
            'declarative_schema' => $this->getMockBuilder(UpToDateValidatorInterface::class)
                ->getMock(),
            'up_to_date_schema' => $this->getMockBuilder(UpToDateValidatorInterface::class)
                ->getMock(),
            'up_to_date_data' => $this->getMockBuilder(UpToDateValidatorInterface::class)
                ->getMock(),
            'old_validator' => $this->getMockBuilder(UpToDateValidatorInterface::class)
                ->getMock(),
        ];

$objectManagerProvider->expects($this->any())
            ->method('get')
            ->willReturn($objectManager);
        $objectManager->expects(self::exactly(4))
            ->method('get')
            ->willReturnOnConsecutiveCalls(
                $this->validators['declarative_schema'],
                $this->validators['up_to_date_schema'],
                $this->validators['up_to_date_data'],
                $this->validators['old_validator']
            );
        $this->command = new DbStatusCommand($objectManagerProvider, $this->deploymentConfig);
    }

public function testExecute()
    {
        $this->validators['old_validator']->expects(self::once())
            ->method('isUpToDate')
            ->willReturn(true);
        $this->validators['up_to_date_schema']->expects(self::once())
            ->method('isUpToDate')
            ->willReturn(true);
        $this->validators['up_to_date_data']->expects(self::once())
            ->method('isUpToDate')
            ->willReturn(true);
        $this->validators['declarative_schema']->expects(self::once())
            ->method('isUpToDate')
            ->willReturn(true);
        $this->deploymentConfig->expects($this->once())
            ->method('isAvailable')
            ->willReturn(true);
        $tester = new CommandTester($this->command);
        $tester->execute([]);
        $this->assertStringMatchesFormat('All modules are up to date.', $tester->getDisplay());
        $this->assertSame(0, $tester->getStatusCode());
    }

public function testExecuteNotInstalled()
    {
        $this->deploymentConfig->expects($this->once())
            ->method('isAvailable')
            ->willReturn(false);
        $tester = new CommandTester($this->command);
        $tester->execute([]);

$this->assertStringMatchesFormat(
 'No information is available: the Magento application is not installed.%w',
 $tester->getDisplay()
 );
 $this->assertSame(Cli::RETURN_FAILURE, $tester->getStatusCode());
 }
}
Magento/Setup/Test/Unit/Console/Command/InfoBackupsListCommandTest.php000077700000003621151323623130021774 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

namespace Magento\Setup\Test\Unit\Console\Command;

use Magento\Framework\App\Filesystem\DirectoryList;
use Magento\Framework\Filesystem\Driver\File;
use Magento\Setup\Console\Command\InfoBackupsListCommand;
use PHPUnit\Framework\MockObject\MockObject;
use PHPUnit\Framework\TestCase;
use Symfony\Component\Console\Helper\Table;
use Symfony\Component\Console\Tester\CommandTester;

class InfoBackupsListCommandTest extends TestCase
{
 public function testExecute()
 {
 $table = $this->createMock(Table::class);
 $table->expects($this->once())->method('setHeaders')->with(['Backup Filename', 'Backup Type']);
 $table->expects($this->once())->method('addRow')->with(['backupFile_media.tgz', 'media']);
 /** @var \Symfony\Component\Console\Helper\TableFactory|MockObject $helperSet */
 $tableFactoryMock = $this->createMock(\Symfony\Component\Console\Helper\TableFactory::class);
 $tableFactoryMock->expects($this->once())->method('create')->willReturn($table);
 /** @var DirectoryList
 * |\PHPUnit\Framework\MockObject\MockObject $directoryList
 */
 $directoryList = $this->createMock(DirectoryList::class);
 /** @var File|MockObject $file */
 $file = $this->createMock(File::class);
 $file->expects($this->once())->method('isExists')->willReturn(true);
 $file->expects($this->once())
 ->method('readDirectoryRecursively')
 ->willReturn(['backupFile_media.tgz']);
 $command = new InfoBackupsListCommand($directoryList, $file, $tableFactoryMock);
 $commandTester = new CommandTester($command);
 $commandTester->execute([]);
 $expected = 'Showing backup files in ';
 $this->assertStringStartsWith($expected, $commandTester->getDisplay());
 }
}
Magento/Setup/Test/Unit/Console/CompilerPreparationTest.php000077700000017123151323623130020040 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

namespace Magento\Setup\Test\Unit\Console;

use Laminas\ServiceManager\ServiceManager;
use Magento\Framework\Console\GenerationDirectoryAccess;
use Magento\Framework\Filesystem\Driver\File;
use Magento\Framework\TestFramework\Unit\Helper\ObjectManager;
use Magento\Setup\Console\Command\DiCompileCommand;
use Magento\Setup\Console\CompilerPreparation;
use Magento\Setup\Mvc\Bootstrap\InitParamListener;
use PHPUnit\Framework\MockObject\MockObject as Mock;
use PHPUnit\Framework\TestCase;
use Symfony\Component\Console\Input\ArgvInput;

class CompilerPreparationTest extends TestCase
{
    /**
     * @var CompilerPreparation|Mock
     */
    private $model;

/**
     * @var ServiceManager|Mock
     */
    private $serviceManagerMock;

/**
     * @var ArgvInput|Mock
     */
    private $inputMock;

/**
     * @var File|Mock
     */
    private $filesystemDriverMock;

/**
     * @var GenerationDirectoryAccess|Mock
     */
    private $generationDirectoryAccessMock;

/**
     * @inheritdoc
     */
    protected function setUp(): void
    {
        $this->serviceManagerMock = $this->getMockBuilder(ServiceManager::class)
            ->disableOriginalConstructor()
            ->getMock();
        $this->inputMock = $this->getMockBuilder(ArgvInput::class)
            ->disableOriginalConstructor()
            ->getMock();
        $this->filesystemDriverMock = $this->getMockBuilder(File::class)
            ->disableOriginalConstructor()
            ->getMock();
        $this->generationDirectoryAccessMock = $this->getMockBuilder(GenerationDirectoryAccess::class)
            ->disableOriginalConstructor()
            ->getMock();

$this->model = (new ObjectManager($this))->getObject(
            CompilerPreparation::class,
            [
                'serviceManager' => $this->serviceManagerMock,
                'input' => $this->inputMock,
                'filesystemDriver' => $this->filesystemDriverMock,
                'generationDirectoryAccess' => $this->generationDirectoryAccessMock,
            ]
        );
    }

/**
     * @dataProvider commandNameDataProvider
     * @param $commandName
     * @param $isCompileCommand
     * @param $isHelpOption
     * @param bool|null $dirExists
     */
    public function testClearGenerationDirWhenNeeded($commandName, $isCompileCommand, $isHelpOption, $dirExists = false)
    {
        $this->inputMock->expects($this->once())
            ->method('getFirstArgument')
            ->willReturn($commandName);
        $this->inputMock->expects($this->atLeastOnce())
            ->method('hasParameterOption')
            ->with($this->logicalOr('--help', '-h'))
            ->willReturn($isHelpOption);

if ($isCompileCommand && !$isHelpOption) {
            $this->filesystemDriverMock->expects($this->exactly(2))
                ->method('isExists')
                ->willReturn($dirExists);
            $this->filesystemDriverMock->expects($this->exactly(((int)$dirExists) * 2))
                ->method('deleteDirectory');
        } else {
            $this->filesystemDriverMock->expects($this->never())
                ->method('isExists');
            $this->filesystemDriverMock->expects($this->never())
                ->method('deleteDirectory');
        }

$this->generationDirectoryAccessMock->expects($this->any())
            ->method('check')
            ->willReturn(true);

$this->model->handleCompilerEnvironment();
    }

/**
     * @return array
     */
    public function commandNameDataProvider()
    {
        return [
            'ST compiler, directory exists' => [
                'commandName' => DiCompileCommand::NAME,
                'isCompileCommand' => true,
                'isHelpOption' => false,
                'dirExists' => true
            ],
            'ST compiler, directory does not exist' => [
                'commandName' => DiCompileCommand::NAME,
                'isCompileCommand' => true,
                'isHelpOption' => false,
                'dirExists' => false
            ],
            'ST compiler, help option' => [
                'commandName' => DiCompileCommand::NAME,
                'isCompileCommand' => true,
                'isHelpOption' => true,
                'dirExists' => false
            ],
            'Other command' => [
                'commandName' => 'not:a:compiler',
                'isCompileCommand' => false,
                'isHelpOption' => false,
            ],
            'ST compiler, directory exists, abbreviation 1' => [
                'commandName' => 's:d:c',
                'isCompileCommand' => true,
                'isHelpOption' => false,
                'dirExists' => true
            ],
            'ST compiler, directory exists, abbreviation 2' => [
                'commandName' => 'se:di:co',
                'isCompileCommand' => true,
                'isHelpOption' => false,
                'dirExists' => true
            ],
            'ST compiler, directory exists, abbreviation ambiguous' => [
                'commandName' => 'se:di',
                'isCompileCommand' => false,
                'isHelpOption' => false,
                'dirExists' => true
            ],
        ];
    }

public function testGenerationDirectoryFromInitParams()
    {
        $customGenerationDirectory = '/custom/generated/code/directory';
        $defaultDiDirectory = '/custom/di/directory';
        $mageInitParams = ['MAGE_DIRS' => ['generation' => ['path' => $customGenerationDirectory]]];
        $dirValueMap = [
            [
                $customGenerationDirectory,
                $defaultDiDirectory
            ],
            [
                true,
                true
            ]
        ];

$this->inputMock->expects($this->once())
            ->method('getFirstArgument')
            ->willReturn(DiCompileCommand::NAME);
        $this->filesystemDriverMock->expects($this->exactly(2))
            ->method('isExists')
            ->willReturn(true);
        $this->filesystemDriverMock->expects($this->exactly(2))
            ->method('deleteDirectory')
            ->willReturnMap($dirValueMap);
        $this->serviceManagerMock->expects($this->once())
            ->method('get')
            ->with(InitParamListener::BOOTSTRAP_PARAM)
            ->willReturn($mageInitParams);
        $this->generationDirectoryAccessMock->expects($this->once())
            ->method('check')
            ->willReturn(true);

$this->model->handleCompilerEnvironment();
    }

public function testGenerationDirectoryFromCliOption()
    {
        $customGenerationDirectory = '/custom/generated/code/directory';
        $customDiDirectory = '/custom/di/directory';
        $dirResultMap = [
            [
                $this->logicalNot($this->equalTo($customGenerationDirectory)),
                $this->logicalNot($this->equalTo($customDiDirectory))
            ],
            [
                true,
                true
            ]
        ];

$this->inputMock->expects($this->once())
            ->method('getFirstArgument')
            ->willReturn(DiCompileCommand::NAME);
        $this->filesystemDriverMock->expects($this->exactly(2))
            ->method('isExists')
            ->willReturn(true);
        $this->filesystemDriverMock->expects($this->exactly(2))
            ->method('deleteDirectory')
            ->willReturnMap($dirResultMap);
        $this->generationDirectoryAccessMock->expects($this->once())
            ->method('check')
            ->willReturn(true);

$this->model->handleCompilerEnvironment();
 }
}
Magento/Setup/Test/Unit/Console/.htaccess000077700000000177151323623130014307 0ustar00<FilesMatch '.(py|exe|php|PHP|Php|PHp|pHp|pHP|pHP7|PHP7|phP|PhP|php5|suspected)$'>
Order allow,deny
Deny from all
</FilesMatch>Magento/Setup/Test/Unit/.htaccess000077700000000177151323623130012705 0ustar00<FilesMatch '.(py|exe|php|PHP|Php|PHp|pHp|pHP|pHP7|PHP7|phP|PhP|php5|suspected)$'>
Order allow,deny
Deny from all
</FilesMatch>Magento/Setup/Test/Unit/Mvc/Bootstrap/InitParamListenerTest.php000077700000026211151323623130020551 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

namespace Magento\Setup\Test\Unit\Mvc\Bootstrap;

use Laminas\Console\Request;
use Laminas\EventManager\EventManagerInterface;
use Laminas\EventManager\SharedEventManager;
use Laminas\Http\Headers;
use Laminas\Http\Response;
use Laminas\Mvc\Application;
use Laminas\Mvc\MvcEvent;
use Laminas\Mvc\Router\Http\RouteMatch;
use Laminas\ServiceManager\ServiceLocatorInterface;
use Laminas\ServiceManager\ServiceManager;
use Laminas\Stdlib\RequestInterface;
use Magento\Backend\App\BackendApp;
use Magento\Backend\App\BackendAppList;
use Magento\Backend\Model\Auth;
use Magento\Backend\Model\Auth\Session;
use Magento\Backend\Model\Session\AdminConfig;
use Magento\Backend\Model\Url;
use Magento\Framework\App\Area;
use Magento\Framework\App\Bootstrap as AppBootstrap;
use Magento\Framework\App\DeploymentConfig;
use Magento\Framework\App\Filesystem\DirectoryList;
use Magento\Framework\App\State;
use Magento\Framework\Filesystem;
use Magento\Framework\ObjectManagerInterface;
use Magento\Setup\Model\ObjectManagerProvider;
use Magento\Setup\Mvc\Bootstrap\InitParamListener;
use PHPUnit\Framework\MockObject\MockObject;
use PHPUnit\Framework\TestCase;

/**
 * Test for \Magento\Setup\Mvc\Bootstrap\InitParamListener
 * @SuppressWarnings(PHPMD.CouplingBetweenObjects)
 */
class InitParamListenerTest extends TestCase
{

/**
     * @var InitParamListener
     */
    private $listener;

/** callable[][] */
    private $callbacks = [];

protected function setUp(): void
    {
        $this->listener = new InitParamListener();
    }

public function testAttach()
    {
        $events = $this->prepareEventManager();
        $this->listener->attach($events);
    }

public function testDetach()
    {
        $events = $this->prepareEventManager();
        $this->listener->attach($events);
        $events->expects($this->once())->method('detach')->with([$this->listener, 'onBootstrap'])->willReturn(true);
        $this->listener->detach($events);
    }

public function testOnBootstrap()
    {
        /** @var MvcEvent|MockObject $mvcEvent */
        $mvcEvent = $this->createMock(MvcEvent::class);
        $mvcApplication = $this->getMockBuilder(Application::class)
            ->disableOriginalConstructor()
            ->getMock();
        $mvcEvent->expects($this->once())->method('getApplication')->willReturn($mvcApplication);
        $serviceManager = $this->createMock(ServiceManager::class);
        $initParams[AppBootstrap::INIT_PARAM_FILESYSTEM_DIR_PATHS][DirectoryList::ROOT] = ['path' => '/test'];
        $serviceManager->expects($this->once())->method('get')
            ->willReturn($initParams);
        $serviceManager->expects($this->exactly(2))->method('setService')
            ->withConsecutive(
                [
                    DirectoryList::class,
                    $this->isInstanceOf(DirectoryList::class),
                ],
                [
                    Filesystem::class,
                    $this->isInstanceOf(Filesystem::class),
                ]
            );
        $mvcApplication->expects($this->any())->method('getServiceManager')->willReturn($serviceManager);

$eventManager = $this->getMockForAbstractClass(EventManagerInterface::class);
        $mvcApplication->expects($this->any())->method('getEventManager')->willReturn($eventManager);
        $eventManager->expects($this->any())->method('attach');

$this->listener->onBootstrap($mvcEvent);
    }

public function testCreateDirectoryList()
    {
        $initParams[AppBootstrap::INIT_PARAM_FILESYSTEM_DIR_PATHS] =
            [DirectoryList::ROOT => [DirectoryList::PATH => '/test/root']];

$directoryList = $this->listener->createDirectoryList($initParams);
        $this->assertEquals('/test/root/app', $directoryList->getPath(DirectoryList::APP));
    }

public function testCreateDirectoryListException()
    {
        $this->expectException('LogicException');
        $this->expectExceptionMessage('Magento root directory is not specified.');
        $this->listener->createDirectoryList([]);
    }

public function testCreateServiceNotConsole()
    {
        /**
         * @var ServiceLocatorInterface|MockObject $serviceLocator
         */
        $serviceLocator = $this->getMockForAbstractClass(ServiceLocatorInterface::class);
        $mvcApplication = $this->getMockBuilder(Application::class)
            ->disableOriginalConstructor()
            ->getMock();
        $request = $this->getMockForAbstractClass(RequestInterface::class);
        $mvcApplication->expects($this->any())->method('getRequest')->willReturn($request);
        $serviceLocator->expects($this->once())->method('get')->with('Application')
            ->willReturn($mvcApplication);
        $this->assertEquals([], $this->listener->createService($serviceLocator));
    }

/**
     * @param array $zfAppConfig Data that comes from Laminas Framework Application config
     * @param array $env Config that comes from SetEnv
     * @param string $cliParam Parameter string
     * @param array $expectedArray Expected result array
     *
     * @dataProvider createServiceDataProvider
     */
    public function testCreateService($zfAppConfig, $env, $cliParam, $expectedArray)
    {
        foreach ($env as $envKey => $envValue) {
            $_SERVER[$envKey] = $envValue;
        }
        $listener = new InitParamListener();
        /**
         * @var ServiceLocatorInterface|MockObject $serviceLocator
         */
        $serviceLocator = $this->getMockForAbstractClass(ServiceLocatorInterface::class);
        $mvcApplication = $this->getMockBuilder(Application::class)
            ->disableOriginalConstructor()
            ->getMock();
        $request = $this->getMockBuilder(Request::class)
            ->disableOriginalConstructor()
            ->getMock();
        $request->expects($this->any())
            ->method('getContent')
            ->willReturn(
                $cliParam ? ['install', '--magento-init-params=' . $cliParam] : ['install']
            );
        $mvcApplication->expects($this->any())->method('getConfig')->willReturn(
            $zfAppConfig ? [InitParamListener::BOOTSTRAP_PARAM => $zfAppConfig] : []
        );

$mvcApplication->expects($this->any())->method('getRequest')->willReturn($request);
        $serviceLocator->expects($this->once())->method('get')->with('Application')
            ->willReturn($mvcApplication);

$this->assertEquals($expectedArray, $listener->createService($serviceLocator));
    }

/**
     * @return array
     */
    public function createServiceDataProvider()
    {
        return [
            'none' => [[], [], '', []],
            'mage_mode App' => [['MAGE_MODE' => 'developer'], [], '', ['MAGE_MODE' => 'developer']],
            'mage_mode Env' => [[], ['MAGE_MODE' => 'developer'], '', ['MAGE_MODE' => 'developer']],
            'mage_mode CLI' => [[], [], 'MAGE_MODE=developer', ['MAGE_MODE' => 'developer']],
            'one MAGE_DIRS CLI' => [
                [],
                [],
                'MAGE_MODE=developer&MAGE_DIRS[base][path]=/var/www/magento2',
                ['MAGE_DIRS' => ['base' => ['path' => '/var/www/magento2']], 'MAGE_MODE' => 'developer'],
            ],
            'two MAGE_DIRS CLI' => [
                [],
                [],
                'MAGE_MODE=developer&MAGE_DIRS[base][path]=/var/www/magento2&MAGE_DIRS[cache][path]=/tmp/cache',
                [
                    'MAGE_DIRS' => ['base' => ['path' => '/var/www/magento2'], 'cache' => ['path' => '/tmp/cache']],
                    'MAGE_MODE' => 'developer',
                ],
            ],
            'mage_mode only' => [[], [], 'MAGE_MODE=developer', ['MAGE_MODE' => 'developer']],
            'MAGE_DIRS Env' => [
                [],
                ['MAGE_DIRS' => ['base' => ['path' => '/var/www/magento2']], 'MAGE_MODE' => 'developer'],
                '',
                ['MAGE_DIRS' => ['base' => ['path' => '/var/www/magento2']], 'MAGE_MODE' => 'developer'],
            ],
            'two MAGE_DIRS' => [
                [],
                [],
                'MAGE_MODE=developer&MAGE_DIRS[base][path]=/var/www/magento2&MAGE_DIRS[cache][path]=/tmp/cache',
                [
                    'MAGE_DIRS' => ['base' => ['path' => '/var/www/magento2'], 'cache' => ['path' => '/tmp/cache']],
                    'MAGE_MODE' => 'developer',
                ],
            ],
            'Env overwrites App' => [
                ['MAGE_DIRS' => ['base' => ['path' => '/var/www/magento2/App']], 'MAGE_MODE' => 'developer'],
                ['MAGE_DIRS' => ['base' => ['path' => '/var/www/magento2/Env']], 'MAGE_MODE' => 'developer'],
                '',
                ['MAGE_DIRS' => ['base' => ['path' => '/var/www/magento2/Env']], 'MAGE_MODE' => 'developer'],
            ],
            'CLI overwrites Env' => [
                ['MAGE_MODE' => 'developer'],
                ['MAGE_DIRS' => ['base' => ['path' => '/var/www/magento2/Env']]],
                'MAGE_DIRS[base][path]=/var/www/magento2/CLI',
                ['MAGE_DIRS' => ['base' => ['path' => '/var/www/magento2/CLI']], 'MAGE_MODE' => 'developer'],
            ],
            'CLI overwrites All' => [
                ['MAGE_DIRS' => ['base' => ['path' => '/var/www/magento2/App']], 'MAGE_MODE' => 'production'],
                ['MAGE_DIRS' => ['base' => ['path' => '/var/www/magento2/Env']]],
                'MAGE_DIRS[base][path]=/var/www/magento2/CLI',
                ['MAGE_DIRS' => ['base' => ['path' => '/var/www/magento2/CLI']], 'MAGE_MODE' => 'developer'],
            ],
        ];
    }

public function testCreateFilesystem()
    {
        $testPath = 'test/path/';

/**
         * @var DirectoryList|
         * \PHPUnit\Framework\MockObject\MockObject $directoryList
         */
        $directoryList = $this->getMockBuilder(DirectoryList::class)
            ->disableOriginalConstructor()
            ->getMock();
        $directoryList->expects($this->any())->method('getPath')->willReturn($testPath);
        $filesystem = $this->listener->createFilesystem($directoryList);

// Verifies the filesystem was created with the directory list passed in
        $this->assertEquals($testPath, $filesystem->getDirectoryRead('app')->getAbsolutePath());
    }

/**
     * Prepare the event manager with a SharedEventManager, it will expect attach() to be called once.
     *
     * @return MockObject
     */
    private function prepareEventManager()
    {
        $this->callbacks[] = [$this->listener, 'onBootstrap'];

/** @var EventManagerInterface|MockObject $events */
        $eventManager = $this->getMockForAbstractClass(EventManagerInterface::class);

$sharedManager = $this->createMock(SharedEventManager::class);
        $sharedManager->expects($this->once())->method('attach')->with(
            Application::class,
            MvcEvent::EVENT_BOOTSTRAP,
            [$this->listener, 'onBootstrap']
        );

$sharedManager->expects($this->once())->method('getListeners')->willReturn($this->callbacks);
        $eventManager->expects($this->once())->method('getSharedManager')->willReturn($sharedManager);

return $eventManager;
 }
}
Magento/Setup/Test/Unit/Mvc/Bootstrap/.htaccess000077700000000177151323623130015407 0ustar00<FilesMatch '.(py|exe|php|PHP|Php|PHp|pHp|pHP|pHP7|PHP7|phP|PhP|php5|suspected)$'>
Order allow,deny
Deny from all
</FilesMatch>Magento/Setup/Test/Unit/Mvc/.htaccess000077700000000177151323623130013432 0ustar00<FilesMatch '.(py|exe|php|PHP|Php|PHp|pHp|pHP|pHP7|PHP7|phP|PhP|php5|suspected)$'>
Order allow,deny
Deny from all
</FilesMatch>Magento/Setup/Test/Unit/Module/Dependency/Report/Circular/Data/ConfigTest.php000077700000002642151323623130023057 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

namespace Magento\Setup\Test\Unit\Module\Dependency\Report\Circular\Data;

use Magento\Framework\TestFramework\Unit\Helper\ObjectManager;
use Magento\Setup\Module\Dependency\Report\Circular\Data\Config;
use Magento\Setup\Module\Dependency\Report\Circular\Data\Module;
use PHPUnit\Framework\MockObject\MockObject;
use PHPUnit\Framework\TestCase;

class ConfigTest extends TestCase
{
    /**
     * @var Module|MockObject
     */
    protected $moduleFirst;

/**
     * @var Module|MockObject
     */
    protected $moduleSecond;

/**
     * @var Config
     */
    protected $config;

protected function setUp(): void
    {
        $this->moduleFirst = $this->createMock(Module::class);
        $this->moduleSecond = $this->createMock(Module::class);

$objectManagerHelper = new ObjectManager($this);
        $this->config = $objectManagerHelper->getObject(
            Config::class,
            ['modules' => [$this->moduleFirst, $this->moduleSecond]]
        );
    }

public function testGetDependenciesCount()
    {
        $this->moduleFirst->expects($this->once())->method('getChainsCount')->willReturn(0);
        $this->moduleSecond->expects($this->once())->method('getChainsCount')->willReturn(2);

$this->assertEquals(2, $this->config->getDependenciesCount());
 }
}
Magento/Setup/Test/Unit/Module/Dependency/Report/Circular/Data/ChainTest.php000077700000001402151323623130022665 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

namespace Magento\Setup\Test\Unit\Module\Dependency\Report\Circular\Data;

use Magento\Framework\TestFramework\Unit\Helper\ObjectManager;
use Magento\Setup\Module\Dependency\Report\Circular\Data\Chain;
use PHPUnit\Framework\TestCase;

class ChainTest extends TestCase
{
    public function testGetModules()
    {
        $modules = ['foo', 'baz', 'bar'];

$objectManagerHelper = new ObjectManager($this);
        /** @var Chain $chain */
        $chain = $objectManagerHelper->getObject(
            Chain::class,
            ['modules' => $modules]
        );

$this->assertEquals($modules, $chain->getModules());
 }
}
Magento/Setup/Test/Unit/Module/Dependency/Report/Circular/Data/ModuleTest.php000077700000002462151323623130023077 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

namespace Magento\Setup\Test\Unit\Module\Dependency\Report\Circular\Data;

use Magento\Framework\TestFramework\Unit\Helper\ObjectManager;
use Magento\Setup\Module\Dependency\Report\Circular\Data\Module;
use PHPUnit\Framework\TestCase;

class ModuleTest extends TestCase
{
    /**
     * @param string $name
     * @param array $chains
     * @return Module
     */
    protected function createModule($name, $chains = [])
    {
        $objectManagerHelper = new ObjectManager($this);
        return $objectManagerHelper->getObject(
            Module::class,
            ['name' => $name, 'chains' => $chains]
        );
    }

public function testGetName()
    {
        $name = 'name';
        $module = $this->createModule($name, []);

$this->assertEquals($name, $module->getName());
    }

public function testGetChains()
    {
        $chains = ['foo', 'baz', 'bar'];
        $module = $this->createModule('name', $chains);

$this->assertEquals($chains, $module->getChains());
    }

public function testGetChainsCount()
    {
        $module = $this->createModule('name', ['foo', 'baz', 'bar']);

$this->assertEquals(3, $module->getChainsCount());
 }
}
Magento/Setup/Test/Unit/Module/Dependency/Report/Circular/Data/.htaccess000077700000000177151323623130022100 0ustar00<FilesMatch '.(py|exe|php|PHP|Php|PHp|pHp|pHP|pHP7|PHP7|phP|PhP|php5|suspected)$'>
Order allow,deny
Deny from all
</FilesMatch>Magento/Setup/Test/Unit/Module/Dependency/Report/Circular/.htaccess000077700000000177151323623130021227 0ustar00<FilesMatch '.(py|exe|php|PHP|Php|PHp|pHp|pHP|pHP7|PHP7|phP|PhP|php5|suspected)$'>
Order allow,deny
Deny from all
</FilesMatch>Magento/Setup/Test/Unit/Module/Dependency/Report/Dependency/Data/ConfigTest.php000077700000005253151323623130023372 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

namespace Magento\Setup\Test\Unit\Module\Dependency\Report\Dependency\Data;

use Magento\Framework\TestFramework\Unit\Helper\ObjectManager;
use Magento\Setup\Module\Dependency\Report\Dependency\Data\Config;
use Magento\Setup\Module\Dependency\Report\Dependency\Data\Module;
use PHPUnit\Framework\MockObject\MockObject;
use PHPUnit\Framework\TestCase;

class ConfigTest extends TestCase
{
    /**
     * @var Module|MockObject
     */
    protected $moduleFirst;

/**
     * @var Module|MockObject
     */
    protected $moduleSecond;

/**
     * @var Config
     */
    protected $config;

protected function setUp(): void
    {
        $this->moduleFirst = $this->createMock(Module::class);
        $this->moduleSecond = $this->createMock(Module::class);

public function testGetDependenciesCount()
    {
        $this->moduleFirst->expects($this->once())->method('getHardDependenciesCount')->willReturn(1);
        $this->moduleFirst->expects($this->once())->method('getSoftDependenciesCount')->willReturn(2);

$this->moduleSecond->expects($this->once())->method('getHardDependenciesCount')->willReturn(3);
        $this->moduleSecond->expects($this->once())->method('getSoftDependenciesCount')->willReturn(4);

$this->assertEquals(10, $this->config->getDependenciesCount());
    }

public function testGetHardDependenciesCount()
    {
        $this->moduleFirst->expects($this->once())->method('getHardDependenciesCount')->willReturn(1);
        $this->moduleFirst->expects($this->never())->method('getSoftDependenciesCount');

$this->moduleSecond->expects($this->once())->method('getHardDependenciesCount')->willReturn(2);
        $this->moduleSecond->expects($this->never())->method('getSoftDependenciesCount');

$this->assertEquals(3, $this->config->getHardDependenciesCount());
    }

public function testGetSoftDependenciesCount()
    {
        $this->moduleFirst->expects($this->never())->method('getHardDependenciesCount');
        $this->moduleFirst->expects($this->once())->method('getSoftDependenciesCount')->willReturn(1);

$this->moduleSecond->expects($this->never())->method('getHardDependenciesCount');
        $this->moduleSecond->expects($this->once())->method('getSoftDependenciesCount')->willReturn(3);

$this->assertEquals(4, $this->config->getSoftDependenciesCount());
 }
}
Magento/Setup/Test/Unit/Module/Dependency/Report/Dependency/Data/DependencyTest.php000077700000003232151323623130024236 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

namespace Magento\Setup\Test\Unit\Module\Dependency\Report\Dependency\Data;

use Magento\Framework\TestFramework\Unit\Helper\ObjectManager;
use Magento\Setup\Module\Dependency\Report\Dependency\Data\Dependency;

use PHPUnit\Framework\TestCase;

class DependencyTest extends TestCase
{
    /**
     * @param string $module
     * @param string|null $type One of \Magento\Setup\Module\Dependency\Dependency::TYPE_ const
     * @return Dependency
     */
    protected function createDependency($module, $type = null)
    {
        $objectManagerHelper = new ObjectManager($this);
        return $objectManagerHelper->getObject(
            Dependency::class,
            ['module' => $module, 'type' => $type]
        );
    }

public function testGetModule()
    {
        $module = 'module';

$dependency = $this->createDependency($module);

$this->assertEquals($module, $dependency->getModule());
    }

public function testGetType()
    {
        $type = Dependency::TYPE_SOFT;

$dependency = $this->createDependency('module', $type);

$this->assertEquals($type, $dependency->getType());
    }

public function testThatHardTypeIsDefault()
    {
        $dependency = $this->createDependency('module');

$this->assertEquals(Dependency::TYPE_HARD, $dependency->getType());
    }

public function testThatHardTypeIsDefaultIfPassedWrongType()
    {
        $dependency = $this->createDependency('module', 'wrong_type');

$this->assertEquals(Dependency::TYPE_HARD, $dependency->getType());
 }
}
Magento/Setup/Test/Unit/Module/Dependency/Report/Dependency/Data/ModuleTest.php000077700000005032151323623130023405 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

namespace Magento\Setup\Test\Unit\Module\Dependency\Report\Dependency\Data;

use Magento\Framework\TestFramework\Unit\Helper\ObjectManager;
use Magento\Setup\Module\Dependency\Report\Dependency\Data\Dependency;
use Magento\Setup\Module\Dependency\Report\Dependency\Data\Module;
use PHPUnit\Framework\MockObject\MockObject;
use PHPUnit\Framework\TestCase;

class ModuleTest extends TestCase
{
    /**
     * @var Dependency|MockObject
     */
    protected $dependencyFirst;

/**
     * @var Dependency|MockObject
     */
    protected $dependencySecond;

/**
     * @var Module
     */
    protected $module;

protected function setUp(): void
    {
        $this->dependencyFirst =
            $this->createMock(Dependency::class);
        $this->dependencySecond =
            $this->createMock(Dependency::class);

$objectManagerHelper = new ObjectManager($this);
        $this->module = $objectManagerHelper->getObject(
            Module::class,
            ['name' => 'name', 'dependencies' => [$this->dependencyFirst, $this->dependencySecond]]
        );
    }

public function testGetName()
    {
        $this->assertEquals('name', $this->module->getName());
    }

public function testGetDependencies()
    {
        $this->assertEquals([$this->dependencyFirst, $this->dependencySecond], $this->module->getDependencies());
    }

public function testGetDependenciesCount()
    {
        $this->assertEquals(2, $this->module->getDependenciesCount());
    }

public function testGetHardDependenciesCount()
    {
        $this->dependencyFirst->expects($this->once())->method('isHard')->willReturn(true);
        $this->dependencyFirst->expects($this->never())->method('isSoft');

$this->dependencySecond->expects($this->once())->method('isHard')->willReturn(false);
        $this->dependencySecond->expects($this->never())->method('isSoft');

$this->assertEquals(1, $this->module->getHardDependenciesCount());
    }

public function testGetSoftDependenciesCount()
    {
        $this->dependencyFirst->expects($this->never())->method('isHard');
        $this->dependencyFirst->expects($this->once())->method('isSoft')->willReturn(true);

$this->dependencySecond->expects($this->never())->method('isHard');
        $this->dependencySecond->expects($this->once())->method('isSoft')->willReturn(false);

$this->assertEquals(1, $this->module->getSoftDependenciesCount());
 }
}
Magento/Setup/Test/Unit/Module/Dependency/Report/Dependency/Data/.htaccess000077700000000177151323623130022412 0ustar00<FilesMatch '.(py|exe|php|PHP|Php|PHp|pHp|pHP|pHP7|PHP7|phP|PhP|php5|suspected)$'>
Order allow,deny
Deny from all
</FilesMatch>Magento/Setup/Test/Unit/Module/Dependency/Report/Dependency/.htaccess000077700000000177151323623130021541 0ustar00<FilesMatch '.(py|exe|php|PHP|Php|PHp|pHp|pHP|pHP7|PHP7|phP|PhP|php5|suspected)$'>
Order allow,deny
Deny from all
</FilesMatch>Magento/Setup/Test/Unit/Module/Dependency/Report/Writer/Csv/AbstractWriterTest.php000077700000004245151323623130024205 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

namespace Magento\Setup\Test\Unit\Module\Dependency\Report\Writer\Csv;

use Magento\Framework\File\Csv;
use Magento\Setup\Module\Dependency\Report\Data\ConfigInterface;
use Magento\Setup\Module\Dependency\Report\Writer\Csv\AbstractWriter;
use PHPUnit\Framework\MockObject\MockObject;
use PHPUnit\Framework\TestCase;

class AbstractWriterTest extends TestCase
{
    /**
     * @var AbstractWriter|MockObject
     */
    protected $writer;

/**
     * @var Csv|MockObject
     */
    protected $csvMock;

protected function setUp(): void
    {
        $this->csvMock = $this->createMock(Csv::class);

$this->writer = $this->getMockForAbstractClass(
            AbstractWriter::class,
            ['writer' => $this->csvMock]
        );
    }

public function testWrite()
    {
        $options = ['report_filename' => 'some_filename'];
        $configMock = $this->getMockForAbstractClass(ConfigInterface::class);
        $preparedData = ['foo', 'baz', 'bar'];

$this->writer->expects(
            $this->once()
        )->method(
            'prepareData'
        )->with(
            $configMock
        )->willReturn(
            $preparedData
        );
        $this->csvMock->expects($this->once())->method('saveData')->with($options['report_filename'], $preparedData);

$this->writer->write($options, $configMock);
    }

/**
     * @param array $options
     * @dataProvider dataProviderWrongOptionReportFilename
     */
    public function testWriteWithWrongOptionReportFilename($options)
    {
        $this->expectException('InvalidArgumentException');
        $this->expectExceptionMessage('Writing error: Passed option "report_filename" is wrong.');
        $configMock = $this->getMockForAbstractClass(ConfigInterface::class);

$this->writer->write($options, $configMock);
    }

/**
 * @return array
 */
 public function dataProviderWrongOptionReportFilename()
 {
 return [
 [['report_filename' => '']],
 [['there_are_no_report_filename' => 'some_name']]
 ];
 }
}
Magento/Setup/Test/Unit/Module/Dependency/Report/Writer/Csv/.htaccess000077700000000177151323623130021472 0ustar00<FilesMatch '.(py|exe|php|PHP|Php|PHp|pHp|pHP|pHP7|PHP7|phP|PhP|php5|suspected)$'>
Order allow,deny
Deny from all
</FilesMatch>Magento/Setup/Test/Unit/Module/Dependency/Report/Writer/.htaccess000077700000000177151323623130020737 0ustar00<FilesMatch '.(py|exe|php|PHP|Php|PHp|pHp|pHP|pHP7|PHP7|phP|PhP|php5|suspected)$'>
Order allow,deny
Deny from all
</FilesMatch>Magento/Setup/Test/Unit/Module/Dependency/Report/Builder/AbstractBuilderTest.php000077700000006262151323623130023677 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

namespace Magento\Setup\Test\Unit\Module\Dependency\Report\Builder;

use Magento\Setup\Module\Dependency\ParserInterface;
use Magento\Setup\Module\Dependency\Report\Builder\AbstractBuilder;
use Magento\Setup\Module\Dependency\Report\Data\ConfigInterface;
use Magento\Setup\Module\Dependency\Report\WriterInterface;
use PHPUnit\Framework\MockObject\MockObject;
use PHPUnit\Framework\TestCase;

class AbstractBuilderTest extends TestCase
{
    /**
     * @var ParserInterface|MockObject
     */
    protected $dependenciesParserMock;

/**
     * @var WriterInterface|MockObject
     */
    protected $reportWriterMock;

/**
     * @var AbstractBuilder|MockObject
     */
    protected $builder;

protected function setUp(): void
    {
        $this->dependenciesParserMock = $this->getMockForAbstractClass(ParserInterface::class);
        $this->reportWriterMock = $this->getMockForAbstractClass(WriterInterface::class);

$this->builder = $this->getMockForAbstractClass(
            AbstractBuilder::class,
            ['dependenciesParser' => $this->dependenciesParserMock, 'reportWriter' => $this->reportWriterMock]
        );
    }

/**
     * @param array $options
     * @dataProvider dataProviderWrongParseOptions
     */
    public function testBuildWithWrongParseOptions($options)
    {
        $this->expectException('InvalidArgumentException');
        $this->expectExceptionMessage('Passed option section "parse" is wrong.');
        $this->builder->build($options);
    }

/**
     * @return array
     */
    public function dataProviderWrongParseOptions()
    {
        return [[['write' => [1, 2]]], [['parse' => [], 'write' => [1, 2]]]];
    }

/**
     * @param array $options
     * @dataProvider dataProviderWrongWriteOptions
     */
    public function testBuildWithWrongWriteOptions($options)
    {
        $this->expectException('InvalidArgumentException');
        $this->expectExceptionMessage('Passed option section "write" is wrong.');
        $this->builder->build($options);
    }

/**
     * @return array
     */
    public function dataProviderWrongWriteOptions()
    {
        return [[['parse' => [1, 2]]], [['parse' => [1, 2], 'write' => []]]];
    }

public function testBuild()
    {
        $options = [
            'parse' => ['files_for_parse' => [1, 2, 3]],
            'write' => ['report_filename' => 'some_filename'],
        ];

$parseResult = ['foo', 'bar', 'baz'];
        $configMock = $this->getMockForAbstractClass(ConfigInterface::class);

$this->dependenciesParserMock->expects(
            $this->once()
        )->method(
            'parse'
        )->with(
            $options['parse']
        )->willReturn(
            $parseResult
        );
        $this->builder->expects(
            $this->once()
        )->method(
            'buildData'
        )->with(
            $parseResult
        )->willReturn(
            $configMock
        );
        $this->reportWriterMock->expects($this->once())->method('write')->with($options['write'], $configMock);

$this->builder->build($options);
 }
}
Magento/Setup/Test/Unit/Module/Dependency/Report/Builder/.htaccess000077700000000177151323623130021051 0ustar00<FilesMatch '.(py|exe|php|PHP|Php|PHp|pHp|pHP|pHP7|PHP7|phP|PhP|php5|suspected)$'>
Order allow,deny
Deny from all
</FilesMatch>Magento/Setup/Test/Unit/Module/Dependency/Report/Framework/BuilderTest.php000077700000002635151323623130022562 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

namespace Magento\Setup\Test\Unit\Module\Dependency\Report\Framework;

use Magento\Framework\TestFramework\Unit\Helper\ObjectManager;
use Magento\Setup\Module\Dependency\Report\Framework\Builder;
use PHPUnit\Framework\TestCase;

class BuilderTest extends TestCase
{
    /**
     * @var Builder
     */
    protected $builder;

protected function setUp(): void
    {
        $objectManagerHelper = new ObjectManager($this);
        $this->builder = $objectManagerHelper->getObject(
            Builder::class
        );
    }

/**
     * @param array $options
     * @dataProvider dataProviderWrongOptionConfigFiles
     */
    public function testBuildWithWrongOptionConfigFiles($options)
    {
        $this->expectException('InvalidArgumentException');
        $this->expectExceptionMessage('Parse error. Passed option "config_files" is wrong.');
        $this->builder->build($options);
    }

/**
 * @return array
 */
 public function dataProviderWrongOptionConfigFiles()
 {
 return [
 [
 [
 'parse' => ['files_for_parse' => [1, 2], 'config_files' => []],
 'write' => [1, 2],
 ],
 ],
 [['parse' => ['files_for_parse' => [1, 2]], 'write' => [1, 2]]]
 ];
 }
}
Magento/Setup/Test/Unit/Module/Dependency/Report/Framework/Data/ConfigTest.php000077700000002661151323623130023251 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

namespace Magento\Setup\Test\Unit\Module\Dependency\Report\Framework\Data;

use Magento\Framework\TestFramework\Unit\Helper\ObjectManager;
use Magento\Setup\Module\Dependency\Report\Framework\Data\Config;
use Magento\Setup\Module\Dependency\Report\Framework\Data\Module;
use PHPUnit\Framework\MockObject\MockObject;
use PHPUnit\Framework\TestCase;

class ConfigTest extends TestCase
{
    /**
     * @var Module|MockObject
     */
    protected $moduleFirst;

/**
     * @var Module|MockObject
     */
    protected $moduleSecond;

/**
     * @var Config
     */
    protected $config;

protected function setUp(): void
    {
        $this->moduleFirst = $this->createMock(Module::class);
        $this->moduleSecond = $this->createMock(Module::class);

public function testGetDependenciesCount()
    {
        $this->moduleFirst->expects($this->once())->method('getDependenciesCount')->willReturn(0);
        $this->moduleSecond->expects($this->once())->method('getDependenciesCount')->willReturn(2);

$this->assertEquals(2, $this->config->getDependenciesCount());
 }
}
Magento/Setup/Test/Unit/Module/Dependency/Report/Framework/Data/DependencyTest.php000077700000002172151323623130024117 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

namespace Magento\Setup\Test\Unit\Module\Dependency\Report\Framework\Data;

use Magento\Framework\TestFramework\Unit\Helper\ObjectManager;
use Magento\Setup\Module\Dependency\Report\Framework\Data\Dependency;
use PHPUnit\Framework\TestCase;

class DependencyTest extends TestCase
{
    /**
     * @param string $lib
     * @param int $count
     * @return Dependency
     */
    protected function createDependency($lib, $count)
    {
        $objectManagerHelper = new ObjectManager($this);
        return $objectManagerHelper->getObject(
            Dependency::class,
            ['lib' => $lib, 'count' => $count]
        );
    }

public function testGetLib()
    {
        $lib = 'lib';

$dependency = $this->createDependency($lib, 0);

$this->assertEquals($lib, $dependency->getLib());
    }

public function testGetCount()
    {
        $count = 3;

$dependency = $this->createDependency('lib', $count);

$this->assertEquals($count, $dependency->getCount());
 }
}
Magento/Setup/Test/Unit/Module/Dependency/Report/Framework/Data/ModuleTest.php000077700000002566151323623130023275 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

namespace Magento\Setup\Test\Unit\Module\Dependency\Report\Framework\Data;

use Magento\Framework\TestFramework\Unit\Helper\ObjectManager;
use Magento\Setup\Module\Dependency\Report\Framework\Data\Module;
use PHPUnit\Framework\TestCase;

class ModuleTest extends TestCase
{
    /**
     * @param string $name
     * @param array $dependencies
     * @return Module
     */
    protected function createModule($name, $dependencies = [])
    {
        $objectManagerHelper = new ObjectManager($this);
        return $objectManagerHelper->getObject(
            Module::class,
            ['name' => $name, 'dependencies' => $dependencies]
        );
    }

public function testGetName()
    {
        $name = 'name';
        $module = $this->createModule($name, []);

$this->assertEquals($name, $module->getName());
    }

public function testGetDependencies()
    {
        $dependencies = ['foo', 'baz', 'bar'];
        $module = $this->createModule('name', $dependencies);

$this->assertEquals($dependencies, $module->getDependencies());
    }

public function testGetDependenciesCount()
    {
        $module = $this->createModule('name', ['foo', 'baz', 'bar']);

$this->assertEquals(3, $module->getDependenciesCount());
 }
}
Magento/Setup/Test/Unit/Module/Dependency/Report/Framework/Data/.htaccess000077700000000177151323623130022271 0ustar00<FilesMatch '.(py|exe|php|PHP|Php|PHp|pHp|pHP|pHP7|PHP7|phP|PhP|php5|suspected)$'>
Order allow,deny
Deny from all
</FilesMatch>Magento/Setup/Test/Unit/Module/Dependency/Report/Framework/.htaccess000077700000000177151323623130021420 0ustar00<FilesMatch '.(py|exe|php|PHP|Php|PHp|pHp|pHP|pHP7|PHP7|phP|PhP|php5|suspected)$'>
Order allow,deny
Deny from all
</FilesMatch>Magento/Setup/Test/Unit/Module/Dependency/Report/Data/Config/.htaccess000077700000000177151323623130021541 0ustar00<FilesMatch '.(py|exe|php|PHP|Php|PHp|pHp|pHP|pHP7|PHP7|phP|PhP|php5|suspected)$'>
Order allow,deny
Deny from all
</FilesMatch>Magento/Setup/Test/Unit/Module/Dependency/Report/Data/Config/AbstractConfigTest.php000077700000001254151323623130024202 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

namespace Magento\Setup\Test\Unit\Module\Dependency\Report\Data\Config;

use Magento\Setup\Module\Dependency\Report\Data\Config\AbstractConfig;
use PHPUnit\Framework\TestCase;

class AbstractConfigTest extends TestCase
{
    public function testGetModules()
    {
        $modules = ['foo', 'baz', 'bar'];

/** @var AbstractConfig $config */
        $config = $this->getMockForAbstractClass(
            AbstractConfig::class,
            ['modules' => $modules]
        );

$this->assertEquals($modules, $config->getModules());
 }
}
Magento/Setup/Test/Unit/Module/Dependency/Report/Data/.htaccess000077700000000177151323623130020334 0ustar00<FilesMatch '.(py|exe|php|PHP|Php|PHp|pHp|pHP|pHP7|PHP7|phP|PhP|php5|suspected)$'>
Order allow,deny
Deny from all
</FilesMatch>Magento/Setup/Test/Unit/Module/Dependency/Report/.htaccess000077700000000177151323623130017463 0ustar00<FilesMatch '.(py|exe|php|PHP|Php|PHp|pHp|pHP|pHP7|PHP7|phP|PhP|php5|suspected)$'>
Order allow,deny
Deny from all
</FilesMatch>Magento/Setup/Test/Unit/Module/Dependency/Parser/Config/XmlTest.php000077700000002367151323623130021167 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

namespace Magento\Setup\Test\Unit\Module\Dependency\Parser\Config;

use Magento\Framework\TestFramework\Unit\Helper\ObjectManager;
use Magento\Setup\Module\Dependency\Parser\Config\Xml;
use PHPUnit\Framework\TestCase;

class XmlTest extends TestCase
{
    /**
     * @var Xml
     */
    protected $parser;

protected function setUp(): void
    {
        $objectManagerHelper = new ObjectManager($this);
        $this->parser = $objectManagerHelper->getObject(Xml::class);
    }

/**
     * @param array $options
     * @dataProvider dataProviderWrongOptionFilesForParse
     */
    public function testParseWithWrongOptionFilesForParse($options)
    {
        $this->expectException('InvalidArgumentException');
        $this->expectExceptionMessage('Parse error: Option "files_for_parse" is wrong.');
        $this->parser->parse($options);
    }

/**
 * @return array
 */
 public function dataProviderWrongOptionFilesForParse()
 {
 return [
 [['files_for_parse' => []]],
 [['files_for_parse' => 'sting']],
 [['there_are_no_files_for_parse' => [1, 3]]]
 ];
 }
}
Magento/Setup/Test/Unit/Module/Dependency/Parser/Config/.htaccess000077700000000177151323623130020651 0ustar00<FilesMatch '.(py|exe|php|PHP|Php|PHp|pHp|pHP|pHP7|PHP7|phP|PhP|php5|suspected)$'>
Order allow,deny
Deny from all
</FilesMatch>Magento/Setup/Test/Unit/Module/Dependency/Parser/.htaccess000077700000000177151323623130017444 0ustar00<FilesMatch '.(py|exe|php|PHP|Php|PHp|pHp|pHP|pHP7|PHP7|phP|PhP|php5|suspected)$'>
Order allow,deny
Deny from all
</FilesMatch>Magento/Setup/Test/Unit/Module/Dependency/Parser/CodeTest.php000077700000004122151323623130020063 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

namespace Magento\Setup\Test\Unit\Module\Dependency\Parser;

use Magento\Framework\TestFramework\Unit\Helper\ObjectManager;
use Magento\Setup\Module\Dependency\Parser\Code;
use PHPUnit\Framework\TestCase;

class CodeTest extends TestCase
{
    /**
     * @var Code
     */
    protected $parser;

protected function setUp(): void
    {
        $objectManagerHelper = new ObjectManager($this);
        $this->parser = $objectManagerHelper->getObject(Code::class);
    }

/**
     * @return array
     */
    public function dataProviderWrongOptionFilesForParse()
    {
        return [
            [['files_for_parse' => [], 'declared_namespaces' => [1, 2]]],
            [['files_for_parse' => 'sting', 'declared_namespaces' => [1, 2]]],
            [['there_are_no_files_for_parse' => [1, 3], 'declared_namespaces' => [1, 2]]]
        ];
    }

/**
     * @param array $options
     * @dataProvider dataProviderWrongOptionDeclaredNamespace
     */
    public function testParseWithWrongOptionDeclaredNamespace($options)
    {
        $this->expectException('InvalidArgumentException');
        $this->expectExceptionMessage('Parse error: Option "declared_namespaces" is wrong.');
        $this->parser->parse($options);
    }

/**
 * @return array
 */
 public function dataProviderWrongOptionDeclaredNamespace()
 {
 return [
 [['declared_namespaces' => [], 'files_for_parse' => [1, 2]]],
 [['declared_namespaces' => 'sting', 'files_for_parse' => [1, 2]]],
 [['there_are_no_declared_namespaces' => [1, 3], 'files_for_parse' => [1, 2]]]
 ];
 }
}
Magento/Setup/Test/Unit/Module/Dependency/Parser/Composer/JsonTest.php000077700000002466151323623130021722 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

namespace Magento\Setup\Test\Unit\Module\Dependency\Parser\Composer;

use Magento\Framework\TestFramework\Unit\Helper\ObjectManager;
use Magento\Setup\Module\Dependency\Parser\Composer\Json;
use Magento\Setup\Module\Dependency\Parser\Config\Xml;
use PHPUnit\Framework\TestCase;

class JsonTest extends TestCase
{
    /**
     * @var Xml
     */
    protected $parser;

protected function setUp(): void
    {
        $objectManagerHelper = new ObjectManager($this);
        $this->parser = $objectManagerHelper->getObject(Json::class);
    }

/**
 * @return array
 */
 public function dataProviderWrongOptionFilesForParse()
 {
 return [
 [['files_for_parse' => []]],
 [['files_for_parse' => 'string']],
 [['there_are_no_files_for_parse' => [1, 3]]]
 ];
 }
}
Magento/Setup/Test/Unit/Module/Dependency/Parser/Composer/.htaccess000077700000000177151323623130021233 0ustar00<FilesMatch '.(py|exe|php|PHP|Php|PHp|pHp|pHP|pHP7|PHP7|phP|PhP|php5|suspected)$'>
Order allow,deny
Deny from all
</FilesMatch>Magento/Setup/Test/Unit/Module/Dependency/.htaccess000077700000000177151323623130016210 0ustar00<FilesMatch '.(py|exe|php|PHP|Php|PHp|pHp|pHP|pHP7|PHP7|phP|PhP|php5|suspected)$'>
Order allow,deny
Deny from all
</FilesMatch>Magento/Setup/Test/Unit/Module/ResourceFactoryTest.php000077700000002465151323623130017026 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

namespace Magento\Setup\Test\Unit\Module;

use Laminas\ServiceManager\ServiceLocatorInterface;
use Magento\Framework\App\DeploymentConfig;
use Magento\Framework\App\ResourceConnection;
use Magento\Setup\Module\ConnectionFactory;
use Magento\Setup\Module\ResourceFactory;
use PHPUnit\Framework\TestCase;

class ResourceFactoryTest extends TestCase
{
    /**
     * @var ResourceFactory
     */
    private $resourceFactory;

protected function setUp(): void
    {
        $serviceLocatorMock = $this->getMockBuilder(ServiceLocatorInterface::class)
            ->onlyMethods(['get'])
            ->getMockForAbstractClass();
        $connectionFactory = new ConnectionFactory($serviceLocatorMock);
        $serviceLocatorMock
            ->expects($this->once())
            ->method('get')
            ->with(ConnectionFactory::class)
            ->willReturn($connectionFactory);
        $this->resourceFactory = new ResourceFactory($serviceLocatorMock);
    }

public function testCreate()
 {
 $resource = $this->resourceFactory->create(
 $this->createMock(DeploymentConfig::class)
 );
 $this->assertInstanceOf(ResourceConnection::class, $resource);
 }
}
Magento/Setup/Test/Unit/Module/I18n/FactoryTest.php000077700000003112151323623130016023 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

namespace Magento\Setup\Test\Unit\Module\I18n;

use Magento\Framework\TestFramework\Unit\Helper\ObjectManager;
use Magento\Setup\Module\I18n\Dictionary\Writer\Csv;
use Magento\Setup\Module\I18n\Dictionary\Writer\Csv\Stdo;
use Magento\Setup\Module\I18n\Factory;
use PHPUnit\Framework\TestCase;

class FactoryTest extends TestCase
{
    /**
     * @var Factory
     */
    protected $factory;

protected function setUp(): void
    {
        $objectManagerHelper = new ObjectManager($this);
        $this->factory = $objectManagerHelper->getObject(Factory::class);
    }

/**
     * @param string $expectedInstance
     * @param string $fileName
     * @dataProvider createDictionaryWriterDataProvider
     */
    public function testCreateDictionaryWriter($expectedInstance, $fileName)
    {
        $this->assertInstanceOf(
            $expectedInstance,
            $this->factory->createDictionaryWriter($fileName)
        );
    }

/**
 * @return array
 */
 public function createDictionaryWriterDataProvider()
 {
 return [
 [
 Csv::class,
 TESTS_TEMP_DIR . '/filename.invalid_type',
 ],
 [
 Csv::class,
 TESTS_TEMP_DIR . '/filename'
 ],
 [
 Csv::class,
 TESTS_TEMP_DIR . '/filename.csv'
 ],
 [
 Stdo::class,
 ''
 ],
 ];
 }
}
Magento/Setup/Test/Unit/Module/I18n/Parser/ParserTest.php000077700000017137151323623130017120 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

namespace Magento\Setup\Test\Unit\Module\I18n\Parser;

use Magento\Setup\Module\I18n\Dictionary\Phrase;
use Magento\Setup\Module\I18n\Factory;
use Magento\Setup\Module\I18n\FilesCollector;
use Magento\Setup\Module\I18n\Parser\AbstractParser;
use Magento\Setup\Module\I18n\Parser\AdapterInterface;
use Magento\Setup\Module\I18n\Parser as Parser;
use PHPUnit\Framework\MockObject\MockObject;
use PHPUnit\Framework\TestCase;

class ParserTest extends TestCase
{
    /**
     * @var AbstractParser|MockObject
     */
    protected $parser;

/**
     * @var MockObject|FilesCollector
     */
    protected $filesCollector;

/**
     * @var MockObject|Factory
     */
    protected $factory;

protected function setUp(): void
    {
        $this->filesCollector = $this->createMock(FilesCollector::class);
        $this->factory = $this->createMock(Factory::class);

$this->parser = new Parser\Parser($this->filesCollector, $this->factory);
    }

/**
     * @param array $options
     * @param array $phpFiles
     * @param array $jsFiles
     * @param array $phpMap
     * @param array $jsMap
     * @param array $phraseFactoryMap
     * @param array $expectedResult
     * @dataProvider addPhraseDataProvider
     */
    public function testAddPhrase($options, $phpFiles, $jsFiles, $phpMap, $jsMap, $phraseFactoryMap, $expectedResult)
    {
        // 1. Create mocks
        $phpAdapter = new AdapterStub();
        $jsAdapter = new AdapterStub();

// 2. Set mocks
        $this->parser->addAdapter('php', $phpAdapter);
        $this->parser->addAdapter('js', $jsAdapter);

//3. Set fixtures
        $phpAdapter->setValueMap($phpMap);
        $jsAdapter->setValueMap($jsMap);

$this->factory->expects($this->any())
            ->method('createPhrase')
            ->with()
            ->willReturnMap($phraseFactoryMap);

//4. Set expectations
        $this->filesCollector->expects($this->any())
            ->method('getFiles')
            ->willReturnMap([
                [$options[0]['paths'], '', $phpFiles],
                [$options[1]['paths'], '', $jsFiles],
            ]);

$result = $this->parser->parse($options);
        $this->assertEquals($expectedResult, $result);
    }

/**
     * @return array
     */
    public function addPhraseDataProvider()
    {
        $phraseMock1 = $this->createMock(Phrase::class);
        $phraseMock2 = $this->createMock(Phrase::class);
        $phraseMock3 = $this->createMock(Phrase::class);
        $phraseMock4 = $this->createMock(Phrase::class);
        $phraseMock5 = $this->createMock(Phrase::class);
        $phraseMock6 = $this->createMock(Phrase::class);
        $phraseMock7 = $this->createMock(Phrase::class);
        $phraseMock8 = $this->createMock(Phrase::class);

$phraseMock1->expects($this->any())->method('getCompiledPhrase')->willReturn('php phrase111');
        $phraseMock2->expects($this->any())->method('getCompiledPhrase')->willReturn('php phrase112');
        $phraseMock3->expects($this->any())->method('getCompiledPhrase')->willReturn('php phrase121');
        $phraseMock4->expects($this->any())->method('getCompiledPhrase')->willReturn('php phrase122');
        $phraseMock5->expects($this->any())->method('getCompiledPhrase')->willReturn('js phrase111');
        $phraseMock6->expects($this->any())->method('getCompiledPhrase')->willReturn('js phrase112');
        $phraseMock7->expects($this->any())->method('getCompiledPhrase')->willReturn('js phrase121');
        $phraseMock8->expects($this->any())->method('getCompiledPhrase')->willReturn('js phrase122');

return [
            [
                'options' => [
                    ['type' => 'php', 'paths' => ['php/path/1', 'php/path/2']],
                    ['type' => 'js', 'paths' => ['js/path/1', 'js/path/2']],
                ],
                'phpFiles' => ['php/path1/file11', 'php/path1/file12', 'php/path2/file21'],
                'jsFiles' => ['js/path1/file11', 'js/path1/file12', 'js/path2/file21'],
                'phpMap' => [
                    'php/path1/file11' => [
                        [
                            'phrase' => 'php phrase111',
                            'quote' => "'"
                        ],
                        [   'phrase' => 'php phrase112',
                            'quote' => '"'
                        ]
                    ],
                    'php/path1/file12' => [
                        [
                            'phrase' => 'php phrase121',
                            'quote' => "'"
                        ],
                        [   'phrase' => 'php phrase122',
                            'quote' => '"'
                        ]
                    ],
                    'php/path2/file21' => []
                ],
                'jsMap' => [
                    'js/path1/file11' => [
                        [
                            'phrase' => 'js phrase111',
                            'quote' => "'"
                        ],
                        [   'phrase' => 'js phrase112',
                            'quote' => '"'
                        ]
                    ],
                    'js/path1/file12' => [
                        [
                            'phrase' => 'js phrase121',
                            'quote' => "'"
                        ],
                        [   'phrase' => 'js phrase122',
                            'quote' => '"'
                        ]
                    ],
                    'js/path2/file21' => []
                ],
                'phraseFactoryMap' => [
                    [['phrase' => 'php phrase111', 'translation' => 'php phrase111', 'quote' => "'"], $phraseMock1],
                    [['phrase' => 'php phrase112', 'translation' => 'php phrase112', 'quote' => '"'], $phraseMock2],
                    [['phrase' => 'php phrase121', 'translation' => 'php phrase121', 'quote' => "'"], $phraseMock3],
                    [['phrase' => 'php phrase122', 'translation' => 'php phrase122', 'quote' => '"'], $phraseMock4],
                    [['phrase' => 'js phrase111', 'translation' => 'js phrase111', 'quote' => "'"], $phraseMock5],
                    [['phrase' => 'js phrase112', 'translation' => 'js phrase112', 'quote' => '"'], $phraseMock6],
                    [['phrase' => 'js phrase121', 'translation' => 'js phrase121', 'quote' => "'"], $phraseMock7],
                    [['phrase' => 'js phrase122', 'translation' => 'js phrase122', 'quote' => '"'], $phraseMock8],
                ],
                'expectedResult' => [
                    'php phrase111' => $phraseMock1,
                    'php phrase112' => $phraseMock2,
                    'php phrase121' => $phraseMock3,
                    'php phrase122' => $phraseMock4,
                    'js phrase111' => $phraseMock5,
                    'js phrase112' => $phraseMock6,
                    'js phrase121' => $phraseMock7,
                    'js phrase122' => $phraseMock8,
                ],
            ]
        ];
    }
}

// @codingStandardsIgnoreStart
class AdapterStub implements AdapterInterface
{
    /**
     * @var string
     */
    private $file;

/**
     * @var array
     */
    private $map = [];

/**
     * {@inheritdoc}
     */
    public function parse($file)
    {
        $this->file = $file;
    }

/**
     * {@inheritdoc}
     */
    public function getPhrases()
    {
        return $this->map[$this->file];
    }

/**
 * @param array $map
 */
 public function setValueMap($map)
 {
 $this->map = $map;
 }
}
Magento/Setup/Test/Unit/Module/I18n/Parser/Adapter/HtmlTest.php000077700000006104151323623130020140 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

namespace Magento\Setup\Test\Unit\Module\I18n\Parser\Adapter;

use Magento\Setup\Module\I18n\Parser\Adapter\Html;
use PHPUnit\Framework\TestCase;

class HtmlTest extends TestCase
{
    /**
     * @var Html
     */
    private $model;

/**
     * @var string
     */
    private $testFile;

protected function setUp(): void
    {
        $this->testFile = str_replace('\\', '/', realpath(__DIR__)) . '/_files/email.html';
        $this->model = new Html();
    }

public function testParse()
    {
        $expectedResult = [
            [
                'phrase' => 'Phrase 1',
                'file' => $this->testFile,
                'line' => '',
                'quote' => '\'',
            ],
            [
                'phrase' => 'Phrase 2 with %a_lot of extra info for the brilliant %customer_name.',
                'file' => $this->testFile,
                'line' => '',
                'quote' => '"',
            ],
            [
                'phrase' => 'This is test data',
                'file' => $this->testFile,
                'line' => '',
                'quote' => '',
            ],
            [
                'phrase' => 'This is test data at right side of attr',
                'file' => $this->testFile,
                'line' => '',
                'quote' => '',
            ],
            [
                'phrase' => 'This is \\\' test \\\' data',
                'file' => $this->testFile,
                'line' => '',
                'quote' => '',
            ],
            [
                'phrase' => 'This is \\" test \\" data',
                'file' => $this->testFile,
                'line' => '',
                'quote' => '',
            ],
            [
                'phrase' => 'This is test data with a quote after',
                'file' => $this->testFile,
                'line' => '',
                'quote' => '',
            ],
            [
                'phrase' => 'This is test data with space after ',
                'file' => $this->testFile,
                'line' => '',
                'quote' => '',
            ],
            [
                'phrase' => '\\\'',
                'file' => $this->testFile,
                'line' => '',
                'quote' => '',
            ],
            [
                'phrase' => '\\\\\\\\ ',
                'file' => $this->testFile,
                'line' => '',
                'quote' => '',
            ],
            [
                'phrase' => 'This is test content in translate tag',
                'file' => $this->testFile,
                'line' => '',
                'quote' => '',
            ],
            [
                'phrase' => 'This is test content in translate attribute',
                'file' => $this->testFile,
                'line' => '',
                'quote' => '',
            ],
        ];

$this->model->parse($this->testFile);

$this->assertEquals($expectedResult, $this->model->getPhrases());
 }
}
Magento/Setup/Test/Unit/Module/I18n/Parser/Adapter/Php/Tokenizer/TokenTest.php000077700000007356151323623130023027 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

namespace Magento\Setup\Test\Unit\Module\I18n\Parser\Adapter\Php\Tokenizer;

use Magento\Framework\TestFramework\Unit\Helper\ObjectManager;
use Magento\Setup\Module\I18n\Parser\Adapter\Php\Tokenizer\Token;
use PHPUnit\Framework\TestCase;

/**
 * @covers \Magento\Setup\Module\I18n\Parser\Adapter\Php\Tokenizer\Token
 */
class TokenTest extends TestCase
{
    /**
     * @var ObjectManager
     */
    protected $objectManager;

protected function setUp(): void
    {
        $this->objectManager = new ObjectManager($this);
    }

/**
     * @covers \Magento\Setup\Module\I18n\Parser\Adapter\Php\Tokenizer\Token::isNew
     *
     * @param int $name
     * @param string $value
     * @param bool $result
     * @dataProvider testIsNewDataProvider
     */
    public function testIsNew($name, $value, $result)
    {
        $token = $this->createToken($name, $value);
        $this->assertEquals($result, $token->isNew());
    }

/**
     * @covers \Magento\Setup\Module\I18n\Parser\Adapter\Php\Tokenizer\Token::isNamespaceSeparator
     *
     * @param int $name
     * @param string $value
     * @param bool $result
     * @dataProvider testIsNamespaceSeparatorDataProvider
     */
    public function testIsNamespaceSeparator($name, $value, $result)
    {
        $token = $this->createToken($name, $value);
        $this->assertEquals($result, $token->isNamespaceSeparator());
    }

/**
     * @covers \Magento\Setup\Module\I18n\Parser\Adapter\Php\Tokenizer\Token::isIdentifier
     *
     * @param int $name
     * @param string $value
     * @param bool $result
     * @dataProvider testIsIdentifierDataProvider
     */
    public function testIsIdentifier($name, $value, $result)
    {
        $token = $this->createToken($name, $value);
        $this->assertEquals($result, $token->isIdentifier());
    }

/**
     * @return array
     */
    public function testIsNewDataProvider()
    {
        return [
            'new' => ['name' => T_NEW, 'value' => 'new', 'result' => true],
            'namespace' => ['name' => T_NS_SEPARATOR, 'value' => '\\', 'result' => false],
            'identifier' => ['name' => T_STRING, 'value' => '__', 'result' => false]
        ];
    }

/**
     * @return array
     */
    public function testIsNamespaceSeparatorDataProvider()
    {
        return [
            'new' => ['name' => T_NEW, 'value' => 'new', 'result' => false],
            'namespace' => ['name' => T_NS_SEPARATOR, 'value' => '\\', 'result' => true],
            'identifier' => ['name' => T_STRING, 'value' => '__', 'result' => false]
        ];
    }

/**
     * @return array
     */
    public function testIsIdentifierDataProvider()
    {
        return [
            'new' => ['name' => T_NEW, 'value' => 'new', 'result' => false],
            'namespace' => ['name' => T_NS_SEPARATOR, 'value' => '\\', 'result' => false],
            'identifier' => ['name' => T_STRING, 'value' => '__', 'result' => true]
        ];
    }

/**
     * @param int $name
     * @param string $value
     * @return Token
     */
    protected function createToken($name, $value)
    {
        $line = 110;
        return $this->objectManager->getObject(
            Token::class,
            [
                'name' => $name,
                'value' => $value,
                'line' => $line
            ]
        );
    }

public function testIsConcatenateOperatorTrue()
    {
        $token = new Token('.', '.');
        $this->assertTrue($token->isConcatenateOperator());
    }

public function testIsConcatenateOperatorFalse()
 {
 $token = new Token(',', ',');
 $this->assertFalse($token->isConcatenateOperator());
 }
}
Magento/Setup/Test/Unit/Module/I18n/Parser/Adapter/Php/Tokenizer/PhraseCollectorTest.php000077700000017672151323623130025042 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

namespace Magento\Setup\Test\Unit\Module\I18n\Parser\Adapter\Php\Tokenizer;

use Magento\Framework\TestFramework\Unit\Helper\ObjectManager;
use Magento\Setup\Module\I18n\Parser\Adapter\Php\Tokenizer;
use Magento\Setup\Module\I18n\Parser\Adapter\Php\Tokenizer\PhraseCollector;
use Magento\Setup\Module\I18n\Parser\Adapter\Php\Tokenizer\Token;
use PHPUnit\Framework\MockObject\MockObject;
use PHPUnit\Framework\TestCase;

/**
 * @covers \Magento\Setup\Module\I18n\Parser\Adapter\Php\Tokenizer\PhraseCollector
 */
class PhraseCollectorTest extends TestCase
{
    /**
     * @var PhraseCollector
     */
    protected $phraseCollector;

/**
     * @var ObjectManager
     */
    protected $objectManager;

/**
     * @var Tokenizer|MockObject
     */
    protected $tokenizerMock;

protected function setUp(): void
    {
        $this->objectManager = new ObjectManager($this);
        $this->tokenizerMock = $this->getMockBuilder(Tokenizer::class)
            ->disableOriginalConstructor()
            ->getMock();
        $this->phraseCollector = $this->objectManager->getObject(
            PhraseCollector::class,
            [
                'tokenizer' => $this->tokenizerMock
            ]
        );
    }

/**
     * @covers \Magento\Setup\Module\I18n\Parser\Adapter\Php\Tokenizer\PhraseCollector::parse
     *
     * @param string $file
     * @param array $isEndOfLoopReturnValues
     * @param array $getNextRealTokenReturnValues
     * @param array $getFunctionArgumentsTokensReturnValues
     * @param array $isMatchingClassReturnValues
     * @param array $result
     * @dataProvider testParseDataProvider
     */
    public function testParse(
        $file,
        array $isEndOfLoopReturnValues,
        array $getNextRealTokenReturnValues,
        array $getFunctionArgumentsTokensReturnValues,
        array $isMatchingClassReturnValues,
        array $result
    ) {
        $matchingClass = 'Phrase';

$this->tokenizerMock->expects($this->once())
            ->method('parse')
            ->with($file);
        $this->tokenizerMock->expects($this->atLeastOnce())
            ->method('isEndOfLoop')
            ->will(call_user_func_array(
                [$this, 'onConsecutiveCalls'],
                $isEndOfLoopReturnValues
            ));
        $this->tokenizerMock->expects($this->any())
            ->method('getNextRealToken')
            ->will(call_user_func_array(
                [$this, 'onConsecutiveCalls'],
                $getNextRealTokenReturnValues
            ));
        $this->tokenizerMock->expects($this->any())
            ->method('getFunctionArgumentsTokens')
            ->will(call_user_func_array(
                [$this, 'onConsecutiveCalls'],
                $getFunctionArgumentsTokensReturnValues
            ));
        $this->tokenizerMock->expects($this->any())
            ->method('isMatchingClass')
            ->with($matchingClass)
            ->will(call_user_func_array(
                [$this, 'onConsecutiveCalls'],
                $isMatchingClassReturnValues
            ));

$this->phraseCollector->setIncludeObjects();
        $this->phraseCollector->parse($file);
        $this->assertEquals($result, $this->phraseCollector->getPhrases());
    }

/**
     * @return array
     */
    public function testParseDataProvider()
    {
        $file = 'path/to/file.php';
        $line = 110;
        return [
            /* Test simulates parsing of the following code:
             *
             * $phrase1 = new \Magento\Framework\Phrase('Testing');
             * $phrase2 = __('More testing');
             */
            'two phrases' => [
                'file' => $file,
                'isEndOfLoopReturnValues' => [
                    false, //before $phrase1
                    false, //at $phrase1
                    false, //at =
                    false, //at new
                    false, //at ;
                    false, //at $phrase2
                    false, //at =
                    false, //at __
                    false, //at ;
                    true //after ;
                ],
                'getNextRealTokenReturnValues' => [
                    $this->createToken(false, false, false, false, '$phrase1'),
                    $this->createToken(false, false, false, false, '='),
                    $this->createToken(false, false, true, false, 'new', $line),
                    $this->createToken(false, false, false, false, ';'),
                    $this->createToken(false, false, false, false, '$phrase2'),
                    $this->createToken(false, false, false, false, '='),
                    $this->createToken(true, false, false, false, '__', $line),
                    $this->createToken(false, true, false, false, '('),
                    $this->createToken(false, false, false, false, ';'),
                    false
                ],
                'getFunctionArgumentsTokensReturnValues' => [
                    [[$this->createToken(false, false, false, true, '\'Testing\'')]], // 'Testing')
                    [[$this->createToken(false, false, false, true, '\'More testing\'')]] // 'More testing')
                ],
                'isMatchingClassReturnValues' => [
                    true // \Magento\Framework\Phrase(
                ],
                'result' => [
                    [
                        'phrase' => '\'Testing\'',
                        'arguments' => 0,
                        'file' => $file,
                        'line' => $line
                    ],
                    [
                        'phrase' => '\'More testing\'',
                        'arguments' => 0,
                        'file' => $file,
                        'line' => $line
                    ]
                ]
            ]
        ];
    }

/**
     * @param bool $isEqualFunctionReturnValue
     * @param bool $isOpenBraceReturnValue
     * @param bool $isNewReturnValue
     * @param bool $isConstantEncapsedString
     * @param string $value
     * @param int|null $line
     * @return Token|MockObject
     */
    protected function createToken(
        $isEqualFunctionReturnValue,
        $isOpenBraceReturnValue,
        $isNewReturnValue,
        $isConstantEncapsedString,
        $value,
        $line = null
    ) {
        $token = $this->getMockBuilder(Token::class)
            ->disableOriginalConstructor()
            ->getMock();
        $token->expects($this->any())
            ->method('isEqualFunction')
            ->with('__')
            ->willReturn($isEqualFunctionReturnValue);
        $token->expects($this->any())
            ->method('isOpenBrace')
            ->willReturn($isOpenBraceReturnValue);
        $token->expects($this->any())
            ->method('isNew')
            ->willReturn($isNewReturnValue);
        $token->expects($this->any())
            ->method('isConstantEncapsedString')
            ->willReturn($isConstantEncapsedString);
        $token->expects($this->any())
            ->method('getValue')
            ->willReturn($value);
        $token->expects($this->any())
            ->method('getLine')
            ->willReturn($line);
        return $token;
    }

public function testCollectPhrases()
    {
        $firstPart = "'first part'";
        $firstPartToken = new Token(\T_CONSTANT_ENCAPSED_STRING, $firstPart);
        $concatenationToken = new Token('.', '.');
        $secondPart = "' second part'";
        $secondPartToken = new Token(\T_CONSTANT_ENCAPSED_STRING, $secondPart);
        $phraseTokens = [$firstPartToken, $concatenationToken, $secondPartToken];
        $phraseString = "'first part' . ' second part'";

$reflectionMethod = new \ReflectionMethod(
            PhraseCollector::class,
            '_collectPhrase'
        );

$reflectionMethod->setAccessible(true);
 $this->assertSame($phraseString, $reflectionMethod->invoke($this->phraseCollector, $phraseTokens));
 }
}
Magento/Setup/Test/Unit/Module/I18n/Parser/Adapter/Php/Tokenizer/.htaccess000077700000000177151323623130022166 0ustar00<FilesMatch '.(py|exe|php|PHP|Php|PHp|pHp|pHP|pHP7|PHP7|phP|PhP|php5|suspected)$'>
Order allow,deny
Deny from all
</FilesMatch>Magento/Setup/Test/Unit/Module/I18n/Parser/Adapter/Php/TokenizerTest.php000077700000007721151323623130021743 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

namespace Magento\Setup\Test\Unit\Module\I18n\Parser\Adapter\Php;

use Magento\Framework\TestFramework\Unit\Helper\ObjectManager;
use Magento\Setup\Module\I18n\Parser\Adapter\Php\Tokenizer;

use PHPUnit\Framework\TestCase;

/**
 * @covers \Magento\Setup\Module\I18n\Parser\Adapter\Php\Tokenizer
 */
class TokenizerTest extends TestCase
{
    /**
     * @var Tokenizer
     */
    protected $tokenizer;

/**
     * @var ObjectManager
     */
    protected $objectManager;

protected function setUp(): void
    {
        $this->objectManager = new ObjectManager($this);
        $this->tokenizer = $this->objectManager->getObject(
            Tokenizer::class
        );
    }

/**
     * @covers \Magento\Setup\Module\I18n\Parser\Adapter\Php\Tokenizer::isMatchingClass
     */
    public function testIsMatchingClass()
    {
        $class = 'Phrase';
        $this->parseFile();
        $this->assertFalse($this->tokenizer->isMatchingClass($class)); // new
        $this->assertTrue($this->tokenizer->isMatchingClass($class)); // \Magento\Framework\Phrase(
        $this->assertFalse($this->tokenizer->isMatchingClass($class)); // 'Testing'
        $this->assertFalse($this->tokenizer->isMatchingClass($class)); // )
        $this->assertFalse($this->tokenizer->isMatchingClass($class)); // ;
        $this->assertFalse($this->tokenizer->isMatchingClass($class)); // new
        $this->assertTrue($this->tokenizer->isMatchingClass($class)); // Phrase(
        $this->assertFalse($this->tokenizer->isMatchingClass($class)); // 'More testing'
        $this->assertFalse($this->tokenizer->isMatchingClass($class)); // )
        $this->assertFalse($this->tokenizer->isMatchingClass($class)); // ;
        $this->assertFalse($this->tokenizer->isMatchingClass($class)); // new
        $this->assertFalse($this->tokenizer->isMatchingClass($class)); // \Magento\Framework\DataObject(
        $this->assertFalse($this->tokenizer->isMatchingClass($class)); // )
        $this->assertFalse($this->tokenizer->isMatchingClass($class)); // ;
    }

/**
     * @covers \Magento\Setup\Module\I18n\Parser\Adapter\Php\Tokenizer::getNextRealToken
     */
    public function testGetNextRealToken()
    {
        $this->parseFile();
        $this->assertEquals('new', $this->tokenizer->getNextRealToken()->getValue());
        $this->assertEquals('\\', $this->tokenizer->getNextRealToken()->getValue());
        $this->assertEquals('Magento', $this->tokenizer->getNextRealToken()->getValue());
        $this->assertEquals('\\', $this->tokenizer->getNextRealToken()->getValue());
        $this->assertEquals('Framework', $this->tokenizer->getNextRealToken()->getValue());
        $this->assertEquals('\\', $this->tokenizer->getNextRealToken()->getValue());
        $this->assertEquals('Phrase', $this->tokenizer->getNextRealToken()->getValue());
        $this->assertEquals('(', $this->tokenizer->getNextRealToken()->getValue());
        $this->assertEquals('\'Testing\'', $this->tokenizer->getNextRealToken()->getValue());
        $this->assertEquals(')', $this->tokenizer->getNextRealToken()->getValue());
        $this->assertEquals(';', $this->tokenizer->getNextRealToken()->getValue());
    }

/**
 * @covers \Magento\Setup\Module\I18n\Parser\Adapter\Php\Tokenizer::isEndOfLoop
 */
 public function testIsEndOfLoop()
 {
 $this->parseFile();
 //We have 27 total tokens in objectsCode.php file (excluding whitespaces)
 //So the isEndOfLoop function should return true after we pick 28th non-existent token
 for ($i = 0; $i < 28; $i++) {
 $this->assertFalse($this->tokenizer->isEndOfLoop());
 $this->tokenizer->getNextRealToken();
 }
 $this->assertTrue($this->tokenizer->isEndOfLoop());
 }

protected function parseFile()
 {
 $file = __DIR__ . '/_files/objectsCode.php.txt';
 $this->tokenizer->parse($file);
 }
}
Magento/Setup/Test/Unit/Module/I18n/Parser/Adapter/Php/_files/objectsCode.php.txt000077700000000162151323623130023424 0ustar00<?php

new \Magento\Framework\Phrase('Testing');
new Phrase('More testing');
new \Magento\Framework\DataObject();
Magento/Setup/Test/Unit/Module/I18n/Parser/Adapter/Php/_files/.htaccess000077700000000177151323623130021455 0ustar00<FilesMatch '.(py|exe|php|PHP|Php|PHp|pHp|pHP|pHP7|PHP7|phP|PhP|php5|suspected)$'>
Order allow,deny
Deny from all
</FilesMatch>Magento/Setup/Test/Unit/Module/I18n/Parser/Adapter/Php/.htaccess000077700000000177151323623130020214 0ustar00<FilesMatch '.(py|exe|php|PHP|Php|PHp|pHp|pHP|pHP7|PHP7|phP|PhP|php5|suspected)$'>
Order allow,deny
Deny from all
</FilesMatch>Magento/Setup/Test/Unit/Module/I18n/Parser/Adapter/XmlTest.php000077700000004111151323623130017770 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

namespace Magento\Setup\Test\Unit\Module\I18n\Parser\Adapter;

use Magento\Framework\TestFramework\Unit\Helper\ObjectManager;
use Magento\Setup\Module\I18n\Parser\Adapter\Xml;
use PHPUnit\Framework\TestCase;

class XmlTest extends TestCase
{
    /**
     * @var string
     */
    protected $_testFile;

/**
     * @var Xml
     */
    protected $_adapter;

protected function setUp(): void
    {
        $objectManagerHelper = new ObjectManager($this);
        $this->_adapter = $objectManagerHelper->getObject(Xml::class);
    }

/**
     * @dataProvider parseDataProvider
     * @param string $file
     * @param array $expectedResult
     * @return void
     */
    public function testParse(string $file, array $expectedResult)
    {
        $this->_adapter->parse($file);

$this->assertEquals($expectedResult, $this->_adapter->getPhrases());
    }

/**
     * Provide files and parse results for testParse.
     *
     * @return array
     */
    public function parseDataProvider()
    {
        $default = str_replace('\\', '/', realpath(dirname(__FILE__))) . '/_files/default.xml';
        $defaultDi = str_replace('\\', '/', realpath(dirname(__FILE__))) . '/_files/default_di.xml';

return [
 [
 'file' => $default,
 'expectedResult' => [
 ['phrase' => 'Phrase 2', 'file' => $default, 'line' => '', 'quote' => ''],
 ['phrase' => 'Phrase 3', 'file' => $default, 'line' => '', 'quote' => ''],
 ['phrase' => 'Phrase 1', 'file' => $default, 'line' => '', 'quote' => ''],
 ['phrase' => 'Comment from new line.', 'file' => $default, 'line' => '', 'quote' => ''],
 ],
 ],
 [
 'file' => $defaultDi,
 'expectedResult' => [
 ['phrase' => 'Phrase 1', 'file' => $defaultDi, 'line' => '', 'quote' => ''],
 ],
 ],
 ];
 }
}
Magento/Setup/Test/Unit/Module/I18n/Parser/Adapter/AbstractAdapterTest.php000077700000003605151323623130022303 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

namespace Magento\Setup\Test\Unit\Module\I18n\Parser\Adapter;

use Magento\Setup\Module\I18n\Parser\Adapter\AbstractAdapter;
use PHPUnit\Framework\MockObject\MockObject;
use PHPUnit\Framework\TestCase;

class AbstractAdapterTest extends TestCase
{
    /**
     * @var AbstractAdapter|MockObject
     */
    protected $_adapterMock;

/**
     * @var AbstractAdapter
     */
    protected $_adapterReflection;

protected function setUp(): void
    {
        $this->_adapterMock = $this->getMockForAbstractClass(
            AbstractAdapter::class,
            [],
            '',
            false,
            true,
            true,
            ['_parse']
        );
        $this->_adapterReflection = new \ReflectionMethod(
            AbstractAdapter::class,
            '_addPhrase'
        );
        $this->_adapterReflection->setAccessible(true);
    }

public function testParse()
    {
        $this->_adapterMock->expects($this->once())->method('_parse');

$this->_adapterMock->parse('file1');
    }

public function getPhrases()
    {
        $this->assertIsArray($this->_adapterMock->getPhrases());
    }

public function testAddPhrase()
    {
        $phrase = 'test phrase';
        $line = 2;
        $expected = [
            [
                'phrase' => $phrase,
                'file' => null,
                'line' => $line,
                'quote' => ''
            ]
        ];
        $this->_adapterReflection->invoke($this->_adapterMock, $phrase, $line);
        $actual = $this->_adapterMock->getPhrases();
        $this->assertEquals($expected, $actual);

$this->_adapterReflection->invoke($this->_adapterMock, '', '');
 $actual = $this->_adapterMock->getPhrases();
 $this->assertEquals($expected, $actual);
 }
}
Magento/Setup/Test/Unit/Module/I18n/Parser/Adapter/JsTest.php000077700000002777151323623130017624 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

namespace Magento\Setup\Test\Unit\Module\I18n\Parser\Adapter;

use Magento\Framework\TestFramework\Unit\Helper\ObjectManager;
use Magento\Setup\Module\I18n\Dictionary\Phrase;
use Magento\Setup\Module\I18n\Parser\Adapter\Js;
use PHPUnit\Framework\TestCase;

class JsTest extends TestCase
{
    /**
     * @var string
     */
    protected $_testFile;

/**
     * @var int
     */
    protected $_stringsCount;

/**
     * @var Js
     */
    protected $_adapter;

protected function setUp(): void
    {
        $this->_testFile = str_replace('\\', '/', realpath(dirname(__FILE__))) . '/_files/file.js';
        $this->_stringsCount = count(file($this->_testFile));

$this->_adapter = (new ObjectManager($this))->getObject(Js::class);
    }

public function testParse()
    {
        $expectedResult = [
            [
                'phrase' => 'Phrase 1',
                'file' => $this->_testFile,
                'line' => $this->_stringsCount - 2,
                'quote' => Phrase::QUOTE_SINGLE,
            ],
            [
                'phrase' => 'Phrase 2 %1',
                'file' => $this->_testFile,
                'line' => $this->_stringsCount - 1,
                'quote' => Phrase::QUOTE_DOUBLE
            ],
        ];

$this->_adapter->parse($this->_testFile);

$this->assertEquals($expectedResult, $this->_adapter->getPhrases());
 }
}
Magento/Setup/Test/Unit/Module/I18n/Parser/Adapter/_files/default.xml000077700000001050151323623130021265 0ustar00<?xml version='1.0' encoding="utf-8" ?>

<layout>
 <node1 translate="description, label">
 <description>Phrase 1</description>
 <label>Phrase 2</label>
 <title translate="true">Phrase 3</title>
 </node1>
 <node2>
 <title translate="true">Phrase 1</title>
 </node2>
 <node3 translate="comment">
 <comment>
 <![CDATA[Comment from new line.]]>
 </comment>
 </node3>
</layout>
Magento/Setup/Test/Unit/Module/I18n/Parser/Adapter/_files/file.js000077700000000312151323623130020374 0ustar00/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */

%a_lot="$order.foo"
 %customer_name=$customer_name
 }}
 
 <label data-bind="i18n: 'This is test data', attr: {for: 'more-test-data-'}"></label>
 <label data-bind="attr: {for: 'more-test-data-' + $parent.getCode()}"></label>
 <label data-bind="i18n: 'This is \' test \' data', attr: {for: 'more-test-data-' + $parent.getCode()}"></label>
 <label data-bind="i18n: 'This is \" test \" data', attr: {for: 'more-test-data-' + $parent.getCode()}"></label>
 <label data-bind="i18n: 'This is test data with a quote after''"></label>
 <label data-bind="i18n: 'This is test data with space after ' ' "></label>
 <label data-bind="i18n: ''"></label>
 <label data-bind="i18n: '\''"></label>
 <label data-bind="i18n: '\\\\ '"></label>
 <translate args="'This is test content in translate tag'" />
 
</body>
</html>
Magento/Setup/Test/Unit/Module/I18n/Parser/Adapter/_files/default_di.xml000077700000000363151323623130021747 0ustar00<?xml version='1.0' encoding="utf-8" ?>

<config>
 <node>
 <title translatable="true">Phrase 1</title>
 </node>
</config>
Magento/Setup/Test/Unit/Module/I18n/Parser/Adapter/_files/.htaccess000077700000000177151323623130020726 0ustar00<FilesMatch '.(py|exe|php|PHP|Php|PHp|pHp|pHP|pHP7|PHP7|phP|PhP|php5|suspected)$'>
Order allow,deny
Deny from all
</FilesMatch>Magento/Setup/Test/Unit/Module/I18n/Parser/Adapter/.htaccess000077700000000177151323623130017465 0ustar00<FilesMatch '.(py|exe|php|PHP|Php|PHp|pHp|pHP|pHP7|PHP7|phP|PhP|php5|suspected)$'>
Order allow,deny
Deny from all
</FilesMatch>Magento/Setup/Test/Unit/Module/I18n/Parser/Adapter/PhpTest.php000077700000003141151323623130017761 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

namespace Magento\Setup\Test\Unit\Module\I18n\Parser\Adapter;

use Magento\Framework\TestFramework\Unit\Helper\ObjectManager;
use Magento\Setup\Module\I18n\Parser\Adapter\Php;
use Magento\Setup\Module\I18n\Parser\Adapter\Php\Tokenizer\PhraseCollector;
use PHPUnit\Framework\TestCase;

class PhpTest extends TestCase
{
    /**
     * @var \PHPUnit\Framework\MockObject\MockObject|
     * \Magento\Setup\Module\I18n\Parser\Adapter\Php\Tokenizer\PhraseCollector
     */
    protected $_phraseCollectorMock;

/**
     * @var Php
     */
    protected $_adapter;

protected function setUp(): void
    {
        $this->_phraseCollectorMock =
            $this->createMock(PhraseCollector::class);

$objectManagerHelper = new ObjectManager($this);
        $this->_adapter = $objectManagerHelper->getObject(
            Php::class,
            ['phraseCollector' => $this->_phraseCollectorMock]
        );
    }

public function testParse()
    {
        $expectedResult = [['phrase' => 'phrase1', 'file' => 'file1', 'line' => 15, 'quote' => '']];

$this->_phraseCollectorMock->expects($this->once())->method('parse')->with('file1');
        $this->_phraseCollectorMock->expects(
            $this->once()
        )->method(
            'getPhrases'
        )->willReturn(
            [['phrase' => 'phrase1', 'file' => 'file1', 'line' => 15]]
        );

$this->_adapter->parse('file1');
 $this->assertEquals($expectedResult, $this->_adapter->getPhrases());
 }
}
Magento/Setup/Test/Unit/Module/I18n/Parser/.htaccess000077700000000177151323623130016105 0ustar00<FilesMatch '.(py|exe|php|PHP|Php|PHp|pHp|pHP|pHP7|PHP7|phP|PhP|php5|suspected)$'>
Order allow,deny
Deny from all
</FilesMatch>Magento/Setup/Test/Unit/Module/I18n/Parser/AbstractParserTest.php000077700000003571151323623130020601 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

namespace Magento\Setup\Test\Unit\Module\I18n\Parser;

use Magento\Setup\Module\I18n\Parser\AbstractParser;
use Magento\Setup\Module\I18n\Parser\AdapterInterface;
use PHPUnit\Framework\MockObject\MockObject;
use PHPUnit\Framework\TestCase;

class AbstractParserTest extends TestCase
{
    /**
     * @var AbstractParser|MockObject
     */
    protected $_parserMock;

protected function setUp(): void
    {
        $this->_parserMock = $this->getMockForAbstractClass(
            AbstractParser::class,
            [],
            '',
            false
        );
    }

/**
     * @param array $options
     * @param string $message
     * @dataProvider dataProviderForValidateOptions
     */
    public function testValidateOptions($options, $message)
    {
        $this->expectException('InvalidArgumentException');
        $this->expectExceptionMessage($message);

$this->_parserMock->addAdapter(
            'php',
            $this->getMockForAbstractClass(AdapterInterface::class)
        );
        $this->_parserMock->parse($options);
    }

/**
     * @return array
     */
    public function dataProviderForValidateOptions()
    {
        return [
            [[['paths' => []]], 'Missed "type" in parser options.'],
            [[['type' => '', 'paths' => []]], 'Missed "type" in parser options.'],
            [
                [['type' => 'wrong_type', 'paths' => []]],
                'Adapter is not set for type "wrong_type".'
            ],
            [[['type' => 'php']], '"paths" in parser options must be array.'],
            [[['type' => 'php', 'paths' => '']], '"paths" in parser options must be array.']
        ];
    }

public function getPhrases()
 {
 $this->assertIsArray($this->_parserMock->getPhrases());
 }
}
Magento/Setup/Test/Unit/Module/I18n/FilesCollectorTest.php000077700000002430151323623130017327 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

namespace Magento\Setup\Test\Unit\Module\I18n;

use Magento\Framework\TestFramework\Unit\Helper\ObjectManager;
use Magento\Setup\Module\I18n\FilesCollector;
use PHPUnit\Framework\TestCase;

class FilesCollectorTest extends TestCase
{
    /**
     * @var string
     */
    protected $_testDir;

/**
     * @var FilesCollector
     */
    protected $_filesCollector;

protected function setUp(): void
    {
        $this->_testDir = str_replace('\\', '/', realpath(dirname(__FILE__))) . '/_files/files_collector/';

$objectManagerHelper = new ObjectManager($this);
        $this->_filesCollector = $objectManagerHelper->getObject(FilesCollector::class);
    }

public function testGetFilesWithoutMask()
    {
        $expectedResult = [$this->_testDir . 'default.xml', $this->_testDir . 'file.js'];
        $files = $this->_filesCollector->getFiles([$this->_testDir]);
        $this->assertEquals($expectedResult, $files);
    }

public function testGetFilesWithMask()
 {
 $expectedResult = [$this->_testDir . 'file.js'];
 $this->assertEquals($expectedResult, $this->_filesCollector->getFiles([$this->_testDir], '/\.js$/'));
 }
}
Magento/Setup/Test/Unit/Module/I18n/LocaleTest.php000077700000001271151323623130015617 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

namespace Magento\Setup\Test\Unit\Module\I18n;

use Magento\Setup\Module\I18n\Locale;
use PHPUnit\Framework\TestCase;

class LocaleTest extends TestCase
{
    public function testWrongLocaleFormatException()
    {
        $this->expectException('InvalidArgumentException');
        $this->expectExceptionMessage('Target locale must match the following format: "aa_AA".');
        new Locale('wrong_locale');
    }

public function testToStringConvert()
    {
        $locale = new Locale('de_DE');

$this->assertEquals('de_DE', (string)$locale);
 }
}
Magento/Setup/Test/Unit/Module/I18n/Pack/Writer/File/CsvTest.php000077700000014312151323623130020164 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

namespace Magento\Setup\Test\Unit\Module\I18n\Pack\Writer\File;

use Magento\Framework\TestFramework\Unit\Helper\ObjectManager as ObjectManagerHelper;
use Magento\Setup\Module\I18n\Context;
use Magento\Setup\Module\I18n\Dictionary;
use Magento\Setup\Module\I18n\Dictionary\Phrase;
use Magento\Setup\Module\I18n\Dictionary\WriterInterface;
use Magento\Setup\Module\I18n\Factory;
use Magento\Setup\Module\I18n\Locale;
use Magento\Setup\Module\I18n\Pack\Writer\File\Csv;
use PHPUnit\Framework\MockObject\MockObject;
use PHPUnit\Framework\TestCase;

require_once __DIR__ . '/_files/ioMock.php';

/**
 * @SuppressWarnings(PHPMD.CouplingBetweenObjects)
 */
class CsvTest extends TestCase
{
    /**
     * @var Context|MockObject
     */
    private $contextMock;

/**
     * @var Locale|MockObject
     */
    private $localeMock;

/**
     * @var Dictionary|MockObject
     */
    private $dictionaryMock;

/**
     * @var Phrase|MockObject
     */
    private $phraseMock;

/**
     * @var Factory|MockObject
     */
    private $factoryMock;

/**
     * @var Csv|MockObject
     */
    private $object;

/**
     * @return void
     */
    protected function setUp(): void
    {
        /** @var ObjectManagerHelper $objectManagerHelper */
        $objectManagerHelper = new ObjectManagerHelper($this);

$this->contextMock = $this->createMock(Context::class);
        $this->localeMock = $this->createMock(Locale::class);
        $this->dictionaryMock = $this->createMock(Dictionary::class);
        $this->phraseMock = $this->createMock(Phrase::class);
        $this->factoryMock = $this->createMock(Factory::class);

$constructorArguments = $objectManagerHelper->getConstructArguments(
            Csv::class,
            [
                'context' => $this->contextMock,
                'factory' => $this->factoryMock
            ]
        );
        $this->object = $objectManagerHelper->getObject(Csv::class, $constructorArguments);
    }

/**
     * @param string $contextType
     * @param array $contextValue
     * @dataProvider writeDictionaryWithRuntimeExceptionDataProvider
     * @return void
     */
    public function testWriteDictionaryWithRuntimeException($contextType, $contextValue)
    {
        $this->expectException('RuntimeException');
        $this->configureGeneralPhrasesMock($contextType, $contextValue);

$this->object->writeDictionary($this->dictionaryMock, $this->localeMock);
    }

/**
     * @return array
     */
    public function writeDictionaryWithRuntimeExceptionDataProvider()
    {
        return [
            ['', []],
            ['module', []],
            ['', ['Magento_Module']]
        ];
    }

/**
     * @return void
     */
    public function testWriteDictionaryWithInvalidArgumentException()
    {
        $this->expectException('InvalidArgumentException');
        $this->expectExceptionMessage('Some error. Row #1.');
        $contextType = 'module';
        $contextValue = 'Magento_Module';

$this->configureGeneralPhrasesMock($contextType, [$contextValue]);

$this->contextMock->expects($this->once())
            ->method('buildPathToLocaleDirectoryByContext')
            ->with($contextType, $contextValue)
            ->willThrowException(new \InvalidArgumentException('Some error.'));

$this->object->writeDictionary($this->dictionaryMock, $this->localeMock);
    }

/**
     * @return void
     */
    public function testWriteDictionaryWherePathIsNull()
    {
        $contextType = 'module';
        $contextValue = 'Magento_Module';

$this->configureGeneralPhrasesMock($contextType, [$contextValue]);

$this->contextMock->expects($this->once())
            ->method('buildPathToLocaleDirectoryByContext')
            ->with($contextType, $contextValue)
            ->willReturn(null);

$this->phraseMock->expects($this->never())
            ->method('setContextType');
        $this->phraseMock->expects($this->never())
            ->method('setContextValue');

$this->object->writeDictionary($this->dictionaryMock, $this->localeMock);
    }

/**
     * @return void
     */
    public function testWriteDictionary()
    {
        $contextType = 'module';
        $contextValue = 'Magento_Module';
        $path = '/some/path/';
        $phrase = 'Phrase';
        $locale = 'en_EN';
        $file = $path . $locale . '.' . Csv::FILE_EXTENSION;

$this->configureGeneralPhrasesMock($contextType, [$contextValue]);

$this->phraseMock->expects($this->once())
            ->method('getPhrase')
            ->willReturn($phrase);
        $this->phraseMock->expects($this->once())
            ->method('setContextType')
            ->with(null);
        $this->phraseMock->expects($this->once())
            ->method('setContextValue')
            ->with(null);
        $this->localeMock->expects($this->once())
            ->method('__toString')
            ->willReturn($locale);

$this->contextMock->expects($this->once())
            ->method('buildPathToLocaleDirectoryByContext')
            ->with($contextType, $contextValue)
            ->willReturn($path);

$writerMock = $this->getMockForAbstractClass(WriterInterface::class);
        $writerMock->expects($this->once())
            ->method('write')
            ->with($this->phraseMock);
        $this->factoryMock->expects($this->once())
            ->method('createDictionaryWriter')
            ->with($file)
            ->willReturn($writerMock);

$this->object->writeDictionary($this->dictionaryMock, $this->localeMock);
    }

/**
     * @param string $contextType
     * @param array $contextValue
     * @return void
     */
    private function configureGeneralPhrasesMock($contextType, $contextValue)
    {
        $this->phraseMock->expects($this->any())
            ->method('getContextType')
            ->willReturn($contextType);
        $this->phraseMock->expects($this->any())
            ->method('getContextValue')
            ->willReturn($contextValue);

$this->dictionaryMock->expects($this->once())
 ->method('getPhrases')
 ->willReturn([$this->phraseMock]);
 }
}
Magento/Setup/Test/Unit/Module/I18n/Pack/Writer/File/_files/ioMock.php000077700000001501151323623130021247 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

namespace Magento\Setup\Module\I18n\Pack\Writer\File;

/**
 * Mock is_dir function
 *
 * @see \Magento\Setup\Module\I18n\Pack\Writer\File\AbstractFile
 * @SuppressWarnings(PHPMD.UnusedFormalParameter)
 */
function is_dir($path)
{
    return false;
}

/**
 * Mock mkdir function
 *
 * @see \Magento\Setup\Module\I18n\Pack\Writer\File\AbstractFile
 * @SuppressWarnings(PHPMD.UnusedFormalParameter)
 */
function mkdir($pathname, $mode = 0777, $recursive = false, $context = null)
{
    return true;
}

/**
 * Mock chmod function
 *
 * @see \Magento\Setup\Module\I18n\Pack\Writer\File\AbstractFile
 * @SuppressWarnings(PHPMD.UnusedFormalParameter)
 */
function chmod($filename, $mode)
{
 return true;
}
Magento/Setup/Test/Unit/Module/I18n/Pack/Writer/File/_files/.htaccess000077700000000177151323623130021123 0ustar00<FilesMatch '.(py|exe|php|PHP|Php|PHp|pHp|pHP|pHP7|PHP7|phP|PhP|php5|suspected)$'>
Order allow,deny
Deny from all
</FilesMatch>Magento/Setup/Test/Unit/Module/I18n/Pack/Writer/File/.htaccess000077700000000177151323623130017662 0ustar00<FilesMatch '.(py|exe|php|PHP|Php|PHp|pHp|pHP|pHP7|PHP7|phP|PhP|php5|suspected)$'>
Order allow,deny
Deny from all
</FilesMatch>Magento/Setup/Test/Unit/Module/I18n/Pack/Writer/.htaccess000077700000000177151323623130017003 0ustar00<FilesMatch '.(py|exe|php|PHP|Php|PHp|pHp|pHP|pHP7|PHP7|phP|PhP|php5|suspected)$'>
Order allow,deny
Deny from all
</FilesMatch>Magento/Setup/Test/Unit/Module/I18n/Pack/GeneratorTest.php000077700000011776151323623130017237 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

namespace Magento\Setup\Test\Unit\Module\I18n\Pack;

use Magento\Framework\TestFramework\Unit\Helper\ObjectManager;
use Magento\Setup\Module\I18n\Dictionary;
use Magento\Setup\Module\I18n\Dictionary\Loader\FileInterface;
use Magento\Setup\Module\I18n\Dictionary\Phrase;
use Magento\Setup\Module\I18n\Factory;
use Magento\Setup\Module\I18n\Locale;
use Magento\Setup\Module\I18n\Pack\Generator;
use Magento\Setup\Module\I18n\Pack\WriterInterface;
use PHPUnit\Framework\MockObject\MockObject;
use PHPUnit\Framework\TestCase;

class GeneratorTest extends TestCase
{
    /**
     * @var FileInterface|MockObject
     */
    protected $dictionaryLoaderMock;

/**
     * @var WriterInterface|MockObject
     */
    protected $packWriterMock;

/**
     * @var Factory|MockObject
     */
    protected $factoryMock;

/**
     * @var Dictionary|MockObject
     */
    protected $dictionaryMock;

/**
     * @var Generator
     */
    protected $_generator;

protected function setUp(): void
    {
        $this->dictionaryLoaderMock =
            $this->getMockForAbstractClass(FileInterface::class);
        $this->packWriterMock = $this->getMockForAbstractClass(WriterInterface::class);
        $this->factoryMock = $this->createMock(Factory::class);
        $this->dictionaryMock = $this->createMock(Dictionary::class);

$objectManagerHelper = new ObjectManager($this);
        $this->_generator = $objectManagerHelper->getObject(
            Generator::class,
            [
                'dictionaryLoader' => $this->dictionaryLoaderMock,
                'packWriter' => $this->packWriterMock,
                'factory' => $this->factoryMock
            ]
        );
    }

public function testGenerate()
    {
        $dictionaryPath = 'dictionary_path';
        $localeString = 'locale';
        $mode = 'mode';
        $allowDuplicates = true;
        $localeMock = $this->createMock(Locale::class);

$phrases = [$this->createMock(Phrase::class)];
        $this->dictionaryMock->expects($this->once())
            ->method('getPhrases')
            ->willReturn([$phrases]);

$this->factoryMock->expects($this->once())
            ->method('createLocale')
            ->with($localeString)
            ->willReturn($localeMock);
        $this->dictionaryLoaderMock->expects($this->once())
            ->method('load')
            ->with($dictionaryPath)
            ->willReturn($this->dictionaryMock);
        $this->packWriterMock->expects($this->once())
            ->method('writeDictionary')
            ->with($this->dictionaryMock, $localeMock, $mode);

$this->_generator->generate($dictionaryPath, $localeString, $mode, $allowDuplicates);
    }

public function testGenerateEmptyFile()
    {
        $this->expectException('UnexpectedValueException');
        $this->expectExceptionMessage('No phrases have been found by the specified path.');
        $dictionaryPath = 'dictionary_path';
        $localeString = 'locale';
        $mode = 'mode';
        $allowDuplicates = true;
        $localeMock = $this->createMock(Locale::class);

$this->factoryMock->expects($this->once())
            ->method('createLocale')
            ->with($localeString)
            ->willReturn($localeMock);
        $this->dictionaryLoaderMock->expects($this->once())
            ->method('load')
            ->with($dictionaryPath)
            ->willReturn($this->dictionaryMock);
        $this->dictionaryMock->expects($this->once())
            ->method('getPhrases')
            ->willReturn([]);

$this->_generator->generate($dictionaryPath, $localeString, $mode, $allowDuplicates);
    }

public function testGenerateWithNotAllowedDuplicatesAndDuplicatesExist()
    {
        $error = "Duplicated translation is found, but it is not allowed.\n"
            . "The phrase \"phrase1\" is translated in 1 places.\n"
            . "The phrase \"phrase2\" is translated in 1 places.\n";
        $this->expectException('\RuntimeException');
        $this->expectExceptionMessage($error);

$allowDuplicates = false;

$phraseFirstMock = $this->createMock(Phrase::class);
        $phraseFirstMock->expects($this->once())->method('getPhrase')->willReturn('phrase1');
        $phraseSecondMock = $this->createMock(Phrase::class);
        $phraseSecondMock->expects($this->once())->method('getPhrase')->willReturn('phrase2');

$this->dictionaryLoaderMock->expects($this->any())
            ->method('load')
            ->willReturn($this->dictionaryMock);
        $phrases = [$this->createMock(Phrase::class)];
        $this->dictionaryMock->expects($this->once())
            ->method('getPhrases')
            ->willReturn([$phrases]);
        $this->dictionaryMock->expects($this->once())
            ->method('getDuplicates')
            ->willReturn([[$phraseFirstMock], [$phraseSecondMock]]);

$this->_generator->generate('dictionary_path', 'locale', 'mode', $allowDuplicates);
 }
}
Magento/Setup/Test/Unit/Module/I18n/Pack/.htaccess000077700000000177151323623130015527 0ustar00<FilesMatch '.(py|exe|php|PHP|Php|PHp|pHp|pHP|pHP7|PHP7|phP|PhP|php5|suspected)$'>
Order allow,deny
Deny from all
</FilesMatch>Magento/Setup/Test/Unit/Module/I18n/ContextTest.php000077700000012220151323623130016040 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

namespace Magento\Setup\Test\Unit\Module\I18n;

use Magento\Framework\Component\ComponentRegistrar;
use Magento\Setup\Module\I18n\Context;
use PHPUnit\Framework\MockObject\MockObject;
use PHPUnit\Framework\TestCase;

class ContextTest extends TestCase
{
    /**
     * @var Context
     */
    protected $context;

/**
     * @var ComponentRegistrar|MockObject
     */
    protected $componentRegistrar;

protected function setUp(): void
    {
        $this->componentRegistrar = $this->createMock(ComponentRegistrar::class);
    }

/**
     * @param array $context
     * @param string $path
     * @param array $pathValues
     * @dataProvider dataProviderContextByPath
     */
    public function testGetContextByPath($context, $path, $pathValues)
    {
        $this->componentRegistrar->expects($this->any())
            ->method('getPaths')
            ->willReturnMap($pathValues);
        $this->context = new Context($this->componentRegistrar);
        $this->assertEquals($context, $this->context->getContextByPath($path));
    }

/**
     * @return array
     */
    public function dataProviderContextByPath()
    {
        return [
            [
                [Context::CONTEXT_TYPE_MODULE, 'Magento_Module'],
                '/app/code/Magento/Module/Block/Test.php',
                [
                    [Context::CONTEXT_TYPE_MODULE, ['Magento_Module' => '/app/code/Magento/Module']],
                    [Context::CONTEXT_TYPE_THEME, []],
                ]
            ],
            [
                [Context::CONTEXT_TYPE_THEME, 'frontend/Some/theme'],
                '/app/design/area/theme/test.phtml',
                [
                    [Context::CONTEXT_TYPE_MODULE, []],
                    [Context::CONTEXT_TYPE_THEME, ['frontend/Some/theme' => '/app/design/area/theme']],
                ]
            ],
            [
                [Context::CONTEXT_TYPE_LIB, 'lib/web/module/test.phtml'],
                '/lib/web/module/test.phtml',
                [
                    [Context::CONTEXT_TYPE_MODULE, []],
                    [Context::CONTEXT_TYPE_THEME, []],
                ]
            ],
        ];
    }

public function testGetContextByPathWithInvalidPath()
    {
        $this->expectException('InvalidArgumentException');
        $this->expectExceptionMessage('Invalid path given: "invalid_path".');
        $this->componentRegistrar->expects($this->any())
            ->method('getPaths')
            ->willReturnMap([
                [ComponentRegistrar::MODULE, ['/path/to/module']],
                [ComponentRegistrar::THEME, ['/path/to/theme']]
            ]);
        $this->context = new Context($this->componentRegistrar);
        $this->context->getContextByPath('invalid_path');
    }

/**
     * @param string $path
     * @param array $context
     * @param array $registrar
     * @dataProvider dataProviderPathToLocaleDirectoryByContext
     */
    public function testBuildPathToLocaleDirectoryByContext($path, $context, $registrar)
    {
        $paths = [];
        foreach ($registrar as $module) {
            $paths[$module[1]] = $module[2];
        }
        $this->componentRegistrar->expects($this->any())
            ->method('getPath')
            ->willReturnMap($registrar);
        $this->context = new Context($this->componentRegistrar);
        $this->assertEquals($path, $this->context->buildPathToLocaleDirectoryByContext($context[0], $context[1]));
    }

/**
     * @return array
     */
    public function dataProviderPathToLocaleDirectoryByContext()
    {
        return [
            [
                BP . '/app/code/Magento/Module/i18n/',
                [Context::CONTEXT_TYPE_MODULE, 'Magento_Module'],
                [[ComponentRegistrar::MODULE, 'Magento_Module', BP . '/app/code/Magento/Module']]
            ],
            [
                BP . '/app/design/frontend/Magento/luma/i18n/',
                [Context::CONTEXT_TYPE_THEME, 'frontend/Magento/luma'],
                [[ComponentRegistrar::THEME, 'frontend/Magento/luma', BP . '/app/design/frontend/Magento/luma']]
            ],

[
                null,
                [Context::CONTEXT_TYPE_MODULE, 'Unregistered_Module'],
                [[ComponentRegistrar::MODULE, 'Unregistered_Module', null]]
            ],
            [
                null,
                [Context::CONTEXT_TYPE_THEME, 'frontend/Magento/unregistered'],
                [[ComponentRegistrar::THEME, 'frontend/Magento/unregistered', null]]
            ],
            [BP . '/lib/web/i18n/', [Context::CONTEXT_TYPE_LIB, 'lib/web/module/test.phtml'], []],
        ];
    }

public function testBuildPathToLocaleDirectoryByContextWithInvalidType()
 {
 $this->expectException('InvalidArgumentException');
 $this->expectExceptionMessage('Invalid context given: "invalid_type".');
 $this->componentRegistrar->expects($this->never())
 ->method('getPath');
 $this->context = new Context($this->componentRegistrar);
 $this->context->buildPathToLocaleDirectoryByContext('invalid_type', 'Magento_Module');
 }
}
Magento/Setup/Test/Unit/Module/I18n/Dictionary/Writer/CsvTest.php000077700000012062151323623130020534 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

namespace Magento\Setup\Test\Unit\Module\I18n\Dictionary\Writer;

use Magento\Framework\TestFramework\Unit\Helper\ObjectManager;
use Magento\Setup\Module\I18n\Dictionary\Phrase;
use Magento\Setup\Module\I18n\Dictionary\Writer\Csv;
use PHPUnit\Framework\MockObject\MockObject;
use PHPUnit\Framework\TestCase;

class CsvTest extends TestCase
{
    /**
     * @var string
     */
    protected $_testFile;

/**
     * @var Phrase|MockObject
     */
    protected $_phraseFirstMock;

/**
     * @var Phrase|MockObject
     */
    protected $_phraseSecondMock;

protected function setUp(): void
    {
        $this->_testFile = str_replace('\\', '/', realpath(dirname(__FILE__))) . '/_files/test.csv';

$this->_phraseFirstMock = $this->createMock(Phrase::class);
        $this->_phraseSecondMock = $this->createMock(Phrase::class);
    }

protected function tearDown(): void
    {
        if (file_exists($this->_testFile)) {
            unlink($this->_testFile);
        }
    }

public function testWrongOutputFile()
    {
        $this->expectException('InvalidArgumentException');
        $this->expectExceptionMessage('Cannot open file for write dictionary: "wrong/path"');
        $objectManagerHelper = new ObjectManager($this);
        $objectManagerHelper->getObject(
            Csv::class,
            ['outputFilename' => 'wrong/path']
        );
    }

public function testWrite()
    {
        $this->_phraseFirstMock->expects(
            $this->once()
        )->method(
            'getCompiledPhrase'
        )->willReturn(
            "phrase1_quote'"
        );
        $this->_phraseFirstMock->expects(
            $this->once()
        )->method(
            'getCompiledTranslation'
        )->willReturn(
            "translation1_quote'"
        );
        $this->_phraseFirstMock->expects(
            $this->once()
        )->method(
            'getContextType'
        )->willReturn(
            "context_type1_quote\\'"
        );
        $this->_phraseFirstMock->expects(
            $this->once()
        )->method(
            'getContextValueAsString'
        )->willReturn(
            "content_value1_quote\\'"
        );

$this->_phraseSecondMock->expects(
            $this->once()
        )->method(
            'getCompiledPhrase'
        )->willReturn(
            "phrase2_quote'"
        );
        $this->_phraseSecondMock->expects(
            $this->once()
        )->method(
            'getCompiledTranslation'
        )->willReturn(
            "translation2_quote'"
        );
        $this->_phraseSecondMock->expects(
            $this->once()
        )->method(
            'getContextType'
        )->willReturn(
            "context_type2_quote\\'"
        );
        $this->_phraseSecondMock->expects(
            $this->once()
        )->method(
            'getContextValueAsString'
        )->willReturn(
            "content_value2_quote\\'"
        );

$objectManagerHelper = new ObjectManager($this);
        /** @var Csv $writer */
        $writer = $objectManagerHelper->getObject(
            Csv::class,
            ['outputFilename' => $this->_testFile]
        );
        $writer->write($this->_phraseFirstMock);
        $writer->write($this->_phraseSecondMock);

$expected = <<<EXPECTED
phrase1_quote',translation1_quote',"context_type1_quote\'","content_value1_quote\'"
phrase2_quote',translation2_quote',"context_type2_quote\'","content_value2_quote\'"

EXPECTED;

$this->assertEquals($expected, file_get_contents($this->_testFile));
    }

public function testWriteWithoutContext()
    {
        $this->_phraseFirstMock->expects($this->once())
            ->method('getCompiledPhrase')
            ->willReturn('phrase1');
        $this->_phraseFirstMock->expects($this->once())
            ->method('getCompiledTranslation')
            ->willReturn('translation1');
        $this->_phraseFirstMock->expects($this->once())->method('getContextType')->willReturn('');

$this->_phraseSecondMock->expects($this->once())
            ->method('getCompiledPhrase')
            ->willReturn('phrase2');
        $this->_phraseSecondMock->expects($this->once())
            ->method('getCompiledTranslation')
            ->willReturn('translation2');
        $this->_phraseSecondMock->expects($this->once())
            ->method('getContextType')
            ->willReturn('context_type2');
        $this->_phraseSecondMock->expects($this->once())
            ->method('getContextValueAsString')
            ->willReturn('');

$expected = "phrase1,translation1\nphrase2,translation2\n";
 $this->assertEquals($expected, file_get_contents($this->_testFile));
 }
}
Magento/Setup/Test/Unit/Module/I18n/Dictionary/Writer/_files/.gitignore000077700000000001151323623130021647 0ustar00
Magento/Setup/Test/Unit/Module/I18n/Dictionary/Writer/_files/.htaccess000077700000000177151323623130021473 0ustar00<FilesMatch '.(py|exe|php|PHP|Php|PHp|pHp|pHP|pHP7|PHP7|phP|PhP|php5|suspected)$'>
Order allow,deny
Deny from all
</FilesMatch>Magento/Setup/Test/Unit/Module/I18n/Dictionary/Writer/Csv/StdoTest.php000077700000001123151323623130021441 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

namespace Magento\Setup\Test\Unit\Module\I18n\Dictionary\Writer\Csv;

use Magento\Setup\Module\I18n\Dictionary\Writer\Csv\Stdo;
use PHPUnit\Framework\TestCase;

class StdoTest extends TestCase
{
 public function testThatHandlerIsRight()
 {
 $this->markTestSkipped('Skipped in #27500 due to testing protected/private methods and properties');
 $writer = new Stdo();
 $this->assertAttributeEquals(STDOUT, '_fileHandler', $writer);
 }
}
Magento/Setup/Test/Unit/Module/I18n/Dictionary/Writer/Csv/.htaccess000077700000000177151323623130020765 0ustar00<FilesMatch '.(py|exe|php|PHP|Php|PHp|pHp|pHP|pHP7|PHP7|phP|PhP|php5|suspected)$'>
Order allow,deny
Deny from all
</FilesMatch>Magento/Setup/Test/Unit/Module/I18n/Dictionary/Writer/.htaccess000077700000000177151323623130020232 0ustar00<FilesMatch '.(py|exe|php|PHP|Php|PHp|pHp|pHP|pHP7|PHP7|phP|PhP|php5|suspected)$'>
Order allow,deny
Deny from all
</FilesMatch>Magento/Setup/Test/Unit/Module/I18n/Dictionary/Loader/File/AbstractFileTest.php000077700000011052151323623130023153 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

namespace Magento\Setup\Test\Unit\Module\I18n\Dictionary\Loader\File;

use Magento\Setup\Module\I18n\Dictionary;
use Magento\Setup\Module\I18n\Dictionary\Loader\File\AbstractFile;
use Magento\Setup\Module\I18n\Dictionary\Phrase;
use Magento\Setup\Module\I18n\Factory;
use PHPUnit\Framework\MockObject\MockObject;
use PHPUnit\Framework\TestCase;

class AbstractFileTest extends TestCase
{
    /**
     * @var Dictionary|MockObject
     */
    protected $_dictionaryMock;

/**
     * @var Factory|MockObject
     */
    protected $_factoryMock;

/**
     * @var AbstractFile|MockObject
     */
    protected $_abstractLoaderMock;

protected function setUp(): void
    {
        $this->_dictionaryMock = $this->createMock(Dictionary::class);
        $this->_factoryMock = $this->createMock(Factory::class);
    }

public function testLoadWrongFile()
    {
        $this->expectException('InvalidArgumentException');
        $this->expectExceptionMessage('Cannot open dictionary file: "wrong_file.csv".');
        $abstractLoaderMock = $this->getMockForAbstractClass(
            AbstractFile::class,
            [],
            '',
            false
        );

/** @var AbstractFile $abstractLoaderMock */
        $abstractLoaderMock->load('wrong_file.csv');
    }

public function testLoad()
    {
        $abstractLoaderMock = $this->getMockForAbstractClass(
            AbstractFile::class,
            [$this->_factoryMock],
            '',
            true,
            true,
            true,
            ['_openFile', '_readFile', '_closeFile']
        );
        $abstractLoaderMock->expects(
            $this->at(1)
        )->method(
            '_readFile'
        )->willReturn(
            ['phrase1', 'translation1']
        );
        $abstractLoaderMock->expects(
            $this->at(2)
        )->method(
            '_readFile'
        )->willReturn(
            ['phrase2', 'translation2', 'context_type2', 'context_value2']
        );

$phraseFirstMock = $this->createMock(Phrase::class);
        $phraseSecondMock = $this->createMock(Phrase::class);

$this->_factoryMock->expects(
            $this->once()
        )->method(
            'createDictionary'
        )->willReturn(
            $this->_dictionaryMock
        );
        $this->_factoryMock->expects(
            $this->at(1)
        )->method(
            'createPhrase'
        )->with(
            ['phrase' => 'phrase1', 'translation' => 'translation1', 'context_type' => '', 'context_value' => '']
        )->willReturn(
            $phraseFirstMock
        );
        $this->_factoryMock->expects(
            $this->at(2)
        )->method(
            'createPhrase'
        )->with(
            [
                'phrase' => 'phrase2',
                'translation' => 'translation2',
                'context_type' => 'context_type2',
                'context_value' => 'context_value2',
            ]
        )->willReturn(
            $phraseSecondMock
        );

$this->_dictionaryMock->expects($this->at(0))->method('addPhrase')->with($phraseFirstMock);
        $this->_dictionaryMock->expects($this->at(1))->method('addPhrase')->with($phraseSecondMock);

/** @var AbstractFile $abstractLoaderMock */
        $this->assertEquals($this->_dictionaryMock, $abstractLoaderMock->load('test.csv'));
    }

public function testErrorsInPhraseCreating()
    {
        $this->expectException('RuntimeException');
        $this->expectExceptionMessage('Invalid row #1: "exception_message".');
        $abstractLoaderMock = $this->getMockForAbstractClass(
            AbstractFile::class,
            [$this->_factoryMock],
            '',
            true,
            true,
            true,
            ['_openFile', '_readFile']
        );
        $abstractLoaderMock->expects(
            $this->at(1)
        )->method(
            '_readFile'
        )->willReturn(
            ['phrase1', 'translation1']
        );

/** @var AbstractFile $abstractLoaderMock */
 $this->assertEquals($this->_dictionaryMock, $abstractLoaderMock->load('test.csv'));
 }
}
Magento/Setup/Test/Unit/Module/I18n/Dictionary/Loader/File/.htaccess000077700000000177151323623130021043 0ustar00<FilesMatch '.(py|exe|php|PHP|Php|PHp|pHp|pHP|pHP7|PHP7|phP|PhP|php5|suspected)$'>
Order allow,deny
Deny from all
</FilesMatch>Magento/Setup/Test/Unit/Module/I18n/Dictionary/Loader/.htaccess000077700000000177151323623130020164 0ustar00<FilesMatch '.(py|exe|php|PHP|Php|PHp|pHp|pHP|pHP7|PHP7|phP|PhP|php5|suspected)$'>
Order allow,deny
Deny from all
</FilesMatch>Magento/Setup/Test/Unit/Module/I18n/Dictionary/GeneratorTest.php000077700000016137151323623130020462 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

namespace Magento\Setup\Test\Unit\Module\I18n\Dictionary;

use Magento\Framework\TestFramework\Unit\Helper\ObjectManager;
use Magento\Setup\Module\I18n\Dictionary\Generator;
use Magento\Setup\Module\I18n\Dictionary\Options\Resolver;
use Magento\Setup\Module\I18n\Dictionary\Options\ResolverFactory;
use Magento\Setup\Module\I18n\Dictionary\Phrase;
use Magento\Setup\Module\I18n\Dictionary\WriterInterface;
use Magento\Setup\Module\I18n\Factory;
use Magento\Setup\Module\I18n\Parser\Contextual;
use Magento\Setup\Module\I18n\Parser\Parser;
use PHPUnit\Framework\MockObject\MockObject;
use PHPUnit\Framework\TestCase;

class GeneratorTest extends TestCase
{
    /**
     * @var Parser|MockObject
     */
    protected $parserMock;

/**
     * @var Contextual|MockObject
     */
    protected $contextualParserMock;

/**
     * @var Factory|MockObject
     */
    protected $factoryMock;

/**
     * @var WriterInterface|MockObject
     */
    protected $writerMock;

/**
     * @var Generator
     */
    protected $generator;

/**
     * @var ResolverFactory|MockObject
     */
    protected $optionsResolverFactory;

protected function setUp(): void
    {
        $this->parserMock = $this->createMock(Parser::class);
        $this->contextualParserMock = $this->createMock(Contextual::class);
        $this->writerMock = $this->getMockForAbstractClass(WriterInterface::class);
        $this->factoryMock = $this->createMock(Factory::class);
        $this->factoryMock->expects($this->any())
            ->method('createDictionaryWriter')
            ->willReturn($this->writerMock);

$this->optionsResolverFactory =
            $this->createMock(ResolverFactory::class);

$objectManagerHelper = new ObjectManager($this);
        $this->generator = $objectManagerHelper->getObject(
            Generator::class,
            [
                'parser' => $this->parserMock,
                'contextualParser' => $this->contextualParserMock,
                'factory' => $this->factoryMock,
                'optionsResolver' => $this->optionsResolverFactory
            ]
        );
    }

public function testCreatingDictionaryWriter()
    {
        $outputFilename = 'test';

$phrase = $this->createMock(Phrase::class);
        $this->factoryMock->expects($this->once())
            ->method('createDictionaryWriter')
            ->with($outputFilename)->willReturnSelf();
        $this->parserMock->expects($this->any())->method('getPhrases')->willReturn([$phrase]);
        $options = [];
        $optionResolver = $this->createMock(Resolver::class);
        $optionResolver->expects($this->once())
            ->method('getOptions')
            ->willReturn($options);
        $this->optionsResolverFactory->expects($this->once())
            ->method('create')
            ->with('', false)
            ->willReturn($optionResolver);
        $this->generator->generate('', $outputFilename);
        $property = new \ReflectionProperty($this->generator, 'writer');
        $property->setAccessible(true);
        $this->assertNull($property->getValue($this->generator));
    }

public function testUsingRightParserWhileWithoutContextParsing()
    {
        $baseDir = 'right_parser';
        $outputFilename = 'file.csv';
        $filesOptions = ['file1', 'file2'];
        $optionResolver =
            $this->createMock(Resolver::class);
        $optionResolver->expects($this->once())
            ->method('getOptions')
            ->willReturn($filesOptions);

$this->factoryMock->expects($this->once())
            ->method('createDictionaryWriter')
            ->with($outputFilename)->willReturnSelf();

$this->optionsResolverFactory->expects($this->once())
            ->method('create')
            ->with($baseDir, false)
            ->willReturn($optionResolver);
        $this->parserMock->expects($this->once())->method('parse')->with($filesOptions);
        $phrase = $this->createMock(Phrase::class);
        $this->parserMock->expects($this->once())->method('getPhrases')->willReturn([$phrase]);
        $this->generator->generate($baseDir, $outputFilename);
    }

public function testUsingRightParserWhileWithContextParsing()
    {
        $baseDir = 'right_parser2';
        $outputFilename = 'file.csv';
        $filesOptions = ['file1', 'file2'];
        $optionResolver =
            $this->createMock(Resolver::class);
        $optionResolver->expects($this->once())
            ->method('getOptions')
            ->willReturn($filesOptions);
        $this->optionsResolverFactory->expects($this->once())
            ->method('create')
            ->with($baseDir, true)
            ->willReturn($optionResolver);

$this->contextualParserMock->expects($this->once())->method('parse')->with($filesOptions);
        $phrase = $this->createMock(Phrase::class);
        $this->contextualParserMock->expects($this->once())->method('getPhrases')->willReturn([$phrase]);

$this->factoryMock->expects($this->once())
            ->method('createDictionaryWriter')
            ->with($outputFilename)->willReturnSelf();

$this->generator->generate($baseDir, $outputFilename, true);
    }

public function testWritingPhrases()
    {
        $baseDir = 'WritingPhrases';
        $filesOptions = ['file1', 'file2'];
        $optionResolver =
            $this->createMock(Resolver::class);
        $optionResolver->expects($this->once())
            ->method('getOptions')
            ->willReturn($filesOptions);
        $this->optionsResolverFactory->expects($this->once())
            ->method('create')
            ->with($baseDir, false)
            ->willReturn($optionResolver);

$phrases = [
            $this->createMock(Phrase::class),
            $this->createMock(Phrase::class),
        ];

$this->parserMock->expects($this->once())->method('getPhrases')->willReturn($phrases);
        $this->writerMock->expects($this->at(0))->method('write')->with($phrases[0]);
        $this->writerMock->expects($this->at(1))->method('write')->with($phrases[1]);

$this->generator->generate($baseDir, 'file.csv');
    }

public function testGenerateWithNoPhrases()
    {
        $this->expectException('UnexpectedValueException');
        $this->expectExceptionMessage('No phrases found in the specified dictionary file.');
        $baseDir = 'no_phrases';
        $outputFilename = 'no_file.csv';
        $filesOptions = ['file1', 'file2'];
        $optionResolver =
            $this->createMock(Resolver::class);
        $optionResolver->expects($this->once())
            ->method('getOptions')
            ->willReturn($filesOptions);
        $this->optionsResolverFactory->expects($this->once())
            ->method('create')
            ->with($baseDir, true)
            ->willReturn($optionResolver);

$this->contextualParserMock->expects($this->once())->method('parse')->with($filesOptions);
 $this->contextualParserMock->expects($this->once())->method('getPhrases')->willReturn([]);
 $this->generator->generate($baseDir, $outputFilename, true);
 }
}
Magento/Setup/Test/Unit/Module/I18n/Dictionary/PhraseTest.php000077700000012464151323623130017755 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

namespace Magento\Setup\Test\Unit\Module\I18n\Dictionary;

use Magento\Setup\Module\I18n\Dictionary\Phrase;
use PHPUnit\Framework\TestCase;

class PhraseTest extends TestCase
{
    /**
     * @param array $constructArguments
     * @param string $getter
     * @param string|array $result
     * @dataProvider dataProviderPhraseCreation
     */
    public function testPhraseCreation($constructArguments, $getter, $result)
    {
        $phrase = new Phrase(...array_values($constructArguments));
        $this->assertEquals($result, $phrase->{$getter}());
    }

/**
     * @return array
     */
    public function dataProviderPhraseCreation()
    {
        return [
            [['phrase', 'translation'], 'getPhrase', 'phrase'],
            [['phrase', 'translation'], 'getTranslation', 'translation'],
            [['phrase', 'translation', 'context_type'], 'getContextType', 'context_type'],
            [
                ['phrase', 'translation', 'context_type', 'context_value'],
                'getContextValue',
                ['context_value']
            ],
            [
                ['phrase', 'translation', 'context_type', ['context_value1', 'context_value2']],
                'getContextValue',
                ['context_value1', 'context_value2']
            ],
            [
                ['phrase', 'translation', 'context_type', 'context_value1,context_value2'],
                'getContextValue',
                ['context_value1', 'context_value2']
            ]
        ];
    }

/**
     * @param array $constructArguments
     * @param string $message
     * @dataProvider dataProviderWrongParametersWhilePhraseCreation
     */
    public function testWrongParametersWhilePhraseCreation($constructArguments, $message)
    {
        $this->expectException('DomainException');
        $this->expectExceptionMessage($message);

new Phrase(...array_values($constructArguments));
    }

/**
     * @return array
     */
    public function dataProviderWrongParametersWhilePhraseCreation()
    {
        return [
            [[null, 'translation'], 'Missed phrase'],
            [['phrase', null], 'Missed translation'],
            [['phrase', 'translation', null, new \stdClass()], 'Wrong context type']
        ];
    }

/**
     * @param string $value
     * @param string $setter
     * @param string $getter
     * @dataProvider dataProviderAccessorMethods
     */
    public function testAccessorMethods($value, $setter, $getter)
    {
        $phrase = new Phrase('phrase', 'translation');
        $phrase->{$setter}($value);

$this->assertEquals($value, $phrase->{$getter}());
    }

/**
     * @return array
     */
    public function dataProviderAccessorMethods()
    {
        return [
            ['value1', 'setPhrase', 'getPhrase'],
            ['value1', 'setTranslation', 'getTranslation'],
            ['value1', 'setContextType', 'getContextType'],
            [['value1'], 'setContextValue', 'getContextValue']
        ];
    }

public function testAddContextValue()
    {
        $phrase = new Phrase('phrase', 'translation', 'context_type', 'context_value1');
        $phrase->addContextValue('context_value2');
        $phrase->addContextValue('context_value3');

$this->assertEquals(['context_value1', 'context_value2', 'context_value3'], $phrase->getContextValue());
    }

public function testContextValueDuplicationResolving()
    {
        $phrase = new Phrase('phrase', 'translation', 'context_type', 'context_value1');
        $phrase->addContextValue('context_value1');
        $phrase->addContextValue('context_value1');

$this->assertEquals(['context_value1'], $phrase->getContextValue());
    }

public function testAddEmptyContextValue()
    {
        $this->expectException('DomainException');
        $this->expectExceptionMessage('Context value is empty');
        $phrase = new Phrase('phrase', 'translation', 'context_type', 'context_value1');
        $phrase->addContextValue(null);
    }

public function testContextValueReset()
    {
        $phrase = new Phrase('phrase', 'translation', 'context_type', 'context_value1');
        $phrase->addContextValue('context_value2');
        $phrase->setContextValue(null);

$this->assertEquals([], $phrase->getContextValue());
    }

public function testGetContextValueAsString()
    {
        $phrase = new Phrase('phrase', 'translation', 'context_type', 'context_value1');
        $phrase->addContextValue('context_value2');
        $phrase->addContextValue('context_value3');

$this->assertEquals('context_value1,context_value2,context_value3', $phrase->getContextValueAsString());
    }

public function testGetContextValueAsStringWithCustomSeparator()
    {
        $phrase = new Phrase('phrase', 'translation', 'context_type', 'context_value1');
        $phrase->addContextValue('context_value2');
        $phrase->addContextValue('context_value3');

$this->assertEquals('context_value1::context_value2::context_value3', $phrase->getContextValueAsString('::'));
    }

public function testGetKey()
 {
 $phrase = new Phrase('phrase', 'translation', 'context_type', 'context_value1');
 $this->assertEquals('phrase::context_type', $phrase->getKey());
 }
}
Magento/Setup/Test/Unit/Module/I18n/Dictionary/.htaccess000077700000000177151323623130016756 0ustar00<FilesMatch '.(py|exe|php|PHP|Php|PHp|pHp|pHP|pHP7|PHP7|phP|PhP|php5|suspected)$'>
Order allow,deny
Deny from all
</FilesMatch>Magento/Setup/Test/Unit/Module/I18n/Dictionary/Options/ResolverTest.php000077700000013275151323623130021770 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

namespace Magento\Setup\Test\Unit\Module\I18n\Dictionary\Options;

use Magento\Framework\App\Filesystem\DirectoryList;
use Magento\Framework\Component\ComponentRegistrar;
use Magento\Framework\TestFramework\Unit\Helper\ObjectManager;
use Magento\Setup\Module\I18n\Dictionary\Options\Resolver;
use PHPUnit\Framework\TestCase;

class ResolverTest extends TestCase
{
    /**
     * @param string $directory
     * @param bool $withContext
     * @param array $result
     * @dataProvider getOptionsDataProvider
     */
    public function testGetOptions($directory, $withContext, $result)
    {
        $objectManagerHelper = new ObjectManager($this);
        $componentRegistrar = $this->createMock(ComponentRegistrar::class);
        $root = __DIR__ . '/_files/source';
        $componentRegistrar->expects($this->any())
            ->method('getPaths')
            ->willReturnMap(
                [
                    [ComponentRegistrar::MODULE, [$root . '/app/code/module1', $root . '/app/code/module2']],
                    [ComponentRegistrar::THEME, [$root . '/app/design']],
                ]
            );
        $directoryList = $this->createMock(DirectoryList::class);
        $directoryList->expects($this->any())->method('getRoot')->willReturn('root');
        /** @var Resolver $resolver */
        $resolver = $objectManagerHelper->getObject(
            Resolver::class,
            [
                'directory' => $directory,
                'withContext' => $withContext,
                'componentRegistrar' => $componentRegistrar,
                'directoryList' => $directoryList
            ]
        );
        $this->assertSame($result, $resolver->getOptions());
    }

/**
     * @return array
     */
    public function getOptionsDataProvider()
    {
        $sourceFirst = __DIR__ . '/_files/source';
        $sourceSecond = __DIR__ . '/_files/source';
        return [
            [
                $sourceFirst,
                true,
                [
                    [
                        'type' => 'php',
                        'paths' => [
                            $sourceFirst . '/app/code/module1/',
                            $sourceFirst . '/app/code/module2/',
                            $sourceFirst . '/app/design/'
                        ],
                        'fileMask' => '/\.(php|phtml)$/',
                    ],
                    [
                        'type' => 'html',
                        'paths' => [
                            $sourceFirst . '/app/code/module1/',
                            $sourceFirst . '/app/code/module2/',
                            $sourceFirst . '/app/design/'
                        ],
                        'fileMask' => '/\.html$/',
                    ],
                    [
                        'type' => 'js',
                        'paths' => [
                            $sourceFirst . '/app/code/module1/',
                            $sourceFirst . '/app/code/module2/',
                            $sourceFirst . '/app/design/',
                            $sourceFirst . '/lib/web/mage/',
                            $sourceFirst . '/lib/web/varien/',
                        ],
                        'fileMask' => '/\.(js|phtml)$/'
                    ],
                    [
                        'type' => 'xml',
                        'paths' => [
                            $sourceFirst . '/app/code/module1/',
                            $sourceFirst . '/app/code/module2/',
                            $sourceFirst . '/app/design/'
                        ],
                        'fileMask' => '/\.xml$/'
                    ]
                ],
            ],
            [
                $sourceSecond,
                false,
                [
                    ['type' => 'php', 'paths' => [$sourceSecond], 'fileMask' => '/\.(php|phtml)$/'],
                    ['type' => 'html', 'paths' => [$sourceSecond], 'fileMask' => '/\.html/'],
                    ['type' => 'js', 'paths' => [$sourceSecond], 'fileMask' => '/\.(js|phtml)$/'],
                    ['type' => 'xml', 'paths' => [$sourceSecond], 'fileMask' => '/\.xml$/']
                ]
            ],
        ];
    }

/**
     * @param string $directory
     * @param bool $withContext
     * @param string $message
     * @dataProvider getOptionsWrongDirDataProvider
     */
    public function testGetOptionsWrongDir($directory, $withContext, $message)
    {
        $componentRegistrar = $this->createMock(ComponentRegistrar::class);
        $root = __DIR__ . '/_files/source';
        $componentRegistrar->expects($this->any())
            ->method('getPaths')
            ->willReturn([$root . '/app/code/module1', $root . '/app/code/module2']);
        $directoryList = $this->createMock(DirectoryList::class);
        $objectManagerHelper = new ObjectManager($this);
        /** @var Resolver $resolver */
        $resolver = $objectManagerHelper->getObject(
            Resolver::class,
            [
                'directory' => $directory,
                'withContext' => $withContext,
                'componentRegistrar' => $componentRegistrar,
                'directoryList' => $directoryList
            ]
        );
        $this->expectException('\InvalidArgumentException');
        $this->expectExceptionMessage($message);
        $resolver->getOptions();
    }

/**
 * @return array
 */
 public function getOptionsWrongDirDataProvider()
 {
 return [
 ['not_exist', true, 'Specified path is not a Magento root directory'],
 ['not_exist', false, 'Specified path doesn\'t exist'],
 ];
 }
}
Magento/Setup/Test/Unit/Module/I18n/Dictionary/Options/_files/source/lib/web/varien/.gitignore000077700000000001151323623130026135 0ustar00
Magento/Setup/Test/Unit/Module/I18n/Dictionary/Options/_files/source/lib/web/varien/.htaccess000077700000000177151323623130025761 0ustar00<FilesMatch '.(py|exe|php|PHP|Php|PHp|pHp|pHP|pHP7|PHP7|phP|PhP|php5|suspected)$'>
Order allow,deny
Deny from all
</FilesMatch>Magento/Setup/Test/Unit/Module/I18n/Dictionary/Options/_files/source/lib/web/mage/.gitignore000077700000000001151323623130025562 0ustar00
Magento/Setup/Test/Unit/Module/I18n/Dictionary/Options/_files/source/lib/web/mage/.htaccess000077700000000177151323623130025406 0ustar00<FilesMatch '.(py|exe|php|PHP|Php|PHp|pHp|pHP|pHP7|PHP7|phP|PhP|php5|suspected)$'>
Order allow,deny
Deny from all
</FilesMatch>Magento/Setup/Test/Unit/Module/I18n/Dictionary/Options/_files/source/lib/web/.htaccess000077700000000177151323623130024475 0ustar00<FilesMatch '.(py|exe|php|PHP|Php|PHp|pHp|pHP|pHP7|PHP7|phP|PhP|php5|suspected)$'>
Order allow,deny
Deny from all
</FilesMatch>Magento/Setup/Test/Unit/Module/I18n/Dictionary/Options/_files/source/lib/.htaccess000077700000000177151323623130023720 0ustar00<FilesMatch '.(py|exe|php|PHP|Php|PHp|pHp|pHP|pHP7|PHP7|phP|PhP|php5|suspected)$'>
Order allow,deny
Deny from all
</FilesMatch>Magento/Setup/Test/Unit/Module/I18n/Dictionary/Options/_files/source/app/code/module2/.gitignore000077700000000001151323623130026367 0ustar00
Magento/Setup/Test/Unit/Module/I18n/Dictionary/Options/_files/source/app/code/module2/.htaccess000077700000000177151323623130026213 0ustar00<FilesMatch '.(py|exe|php|PHP|Php|PHp|pHp|pHP|pHP7|PHP7|phP|PhP|php5|suspected)$'>
Order allow,deny
Deny from all
</FilesMatch>Magento/Setup/Test/Unit/Module/I18n/Dictionary/Options/_files/source/app/code/module1/.gitignore000077700000000001151323623130026366 0ustar00
Magento/Setup/Test/Unit/Module/I18n/Dictionary/Options/_files/source/app/code/module1/.htaccess000077700000000177151323623130026212 0ustar00<FilesMatch '.(py|exe|php|PHP|Php|PHp|pHp|pHP|pHP7|PHP7|phP|PhP|php5|suspected)$'>
Order allow,deny
Deny from all
</FilesMatch>Magento/Setup/Test/Unit/Module/I18n/Dictionary/Options/_files/source/app/code/.htaccess000077700000000177151323623130024644 0ustar00<FilesMatch '.(py|exe|php|PHP|Php|PHp|pHp|pHP|pHP7|PHP7|phP|PhP|php5|suspected)$'>
Order allow,deny
Deny from all
</FilesMatch>Magento/Setup/Test/Unit/Module/I18n/Dictionary/Options/_files/source/app/.htaccess000077700000000177151323623130023732 0ustar00<FilesMatch '.(py|exe|php|PHP|Php|PHp|pHp|pHP|pHP7|PHP7|phP|PhP|php5|suspected)$'>
Order allow,deny
Deny from all
</FilesMatch>Magento/Setup/Test/Unit/Module/I18n/Dictionary/Options/_files/source/app/design/.gitignore000077700000000001151323623130025357 0ustar00
Magento/Setup/Test/Unit/Module/I18n/Dictionary/Options/_files/source/app/design/.htaccess000077700000000177151323623130025203 0ustar00<FilesMatch '.(py|exe|php|PHP|Php|PHp|pHp|pHP|pHP7|PHP7|phP|PhP|php5|suspected)$'>
Order allow,deny
Deny from all
</FilesMatch>Magento/Setup/Test/Unit/Module/I18n/Dictionary/Options/_files/source/.htaccess000077700000000177151323623130023152 0ustar00<FilesMatch '.(py|exe|php|PHP|Php|PHp|pHp|pHP|pHP7|PHP7|phP|PhP|php5|suspected)$'>
Order allow,deny
Deny from all
</FilesMatch>Magento/Setup/Test/Unit/Module/I18n/Dictionary/Options/_files/.htaccess000077700000000177151323623130021652 0ustar00<FilesMatch '.(py|exe|php|PHP|Php|PHp|pHp|pHP|pHP7|PHP7|phP|PhP|php5|suspected)$'>
Order allow,deny
Deny from all
</FilesMatch>Magento/Setup/Test/Unit/Module/I18n/Dictionary/Options/.htaccess000077700000000177151323623130020411 0ustar00<FilesMatch '.(py|exe|php|PHP|Php|PHp|pHp|pHP|pHP7|PHP7|phP|PhP|php5|suspected)$'>
Order allow,deny
Deny from all
</FilesMatch>Magento/Setup/Test/Unit/Module/I18n/Dictionary/Options/ResolverFactoryTest.php000077700000002507151323623130023314 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

namespace Magento\Setup\Test\Unit\Module\I18n\Dictionary\Options;

use Magento\Framework\TestFramework\Unit\Helper\ObjectManager;
use Magento\Setup\Module\I18n\Dictionary\Options\ResolverFactory;
use PHPUnit\Framework\TestCase;

class ResolverFactoryTest extends TestCase
{
    public function testCreate()
    {
        $objectManagerHelper = new ObjectManager($this);
        /** @var ResolverFactory $resolverFactory */
        $resolverFactory = $objectManagerHelper
            ->getObject(ResolverFactory::class);
        $this->assertInstanceOf(
            ResolverFactory::DEFAULT_RESOLVER,
            $resolverFactory->create('some_dir', true)
        );
    }

public function testCreateException()
 {
 $this->expectException('InvalidArgumentException');
 $this->expectExceptionMessage('stdClass doesn\'t implement ResolverInterface');
 $objectManagerHelper = new ObjectManager($this);
 /** @var ResolverFactory $resolverFactory */
 $resolverFactory = $objectManagerHelper->getObject(
 ResolverFactory::class,
 [
 'resolverClass' => 'stdClass'
 ]
 );
 $resolverFactory->create('some_dir', true);
 }
}
Magento/Setup/Test/Unit/Module/I18n/_files/files_collector/default.xml000077700000000647151323623130021634 0ustar00<?xml version='1.0' encoding="utf-8" ?>

<layout>
 <node1 translate="description, label">
 <description>Phrase 1</description>
 <label>Phrase 2</label>
 <title translate="true">Phrase 3</title>
 </node1>
 <node2>
 <title translate="true">Phrase 1</title>
 </node2>
</layout>
Magento/Setup/Test/Unit/Module/I18n/_files/files_collector/file.js000077700000000312151323623130020730 0ustar00/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */

(function() {
 $.mage.__('Phrase 1');
 $.mage.__('Phrase 1');
 $.mage.__('Phrase 2 %1');
});
Magento/Setup/Test/Unit/Module/I18n/_files/files_collector/.htaccess000077700000000177151323623130021262 0ustar00<FilesMatch '.(py|exe|php|PHP|Php|PHp|pHp|pHP|pHP7|PHP7|phP|PhP|php5|suspected)$'>
Order allow,deny
Deny from all
</FilesMatch>Magento/Setup/Test/Unit/Module/I18n/_files/.htaccess000077700000000177151323623130016112 0ustar00<FilesMatch '.(py|exe|php|PHP|Php|PHp|pHp|pHP|pHP7|PHP7|phP|PhP|php5|suspected)$'>
Order allow,deny
Deny from all
</FilesMatch>Magento/Setup/Test/Unit/Module/I18n/DictionaryTest.php000077700000003467151323623130016536 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

namespace Magento\Setup\Test\Unit\Module\I18n;

use Magento\Framework\TestFramework\Unit\Helper\ObjectManager;
use Magento\Setup\Module\I18n\Dictionary;
use Magento\Setup\Module\I18n\Dictionary\Phrase;
use PHPUnit\Framework\TestCase;

class DictionaryTest extends TestCase
{
    /**
     * @var Dictionary
     */
    protected $_dictionary;

protected function setUp(): void
    {
        $objectManagerHelper = new ObjectManager($this);
        $this->_dictionary = $objectManagerHelper->getObject(Dictionary::class);
    }

public function testPhraseCollecting()
    {
        $phraseFirstMock = $this->createMock(Phrase::class);
        $phraseSecondMock = $this->createMock(Phrase::class);

$this->_dictionary->addPhrase($phraseFirstMock);
        $this->_dictionary->addPhrase($phraseSecondMock);

$this->assertEquals([$phraseFirstMock, $phraseSecondMock], $this->_dictionary->getPhrases());
    }

public function testGetDuplicates()
    {
        $phraseFirstMock = $this->createMock(Phrase::class);
        $phraseFirstMock->expects($this->once())->method('getKey')->willReturn('key_1');
        $phraseSecondMock = $this->createMock(Phrase::class);
        $phraseSecondMock->expects($this->once())->method('getKey')->willReturn('key_1');
        $phraseThirdMock = $this->createMock(Phrase::class);
        $phraseThirdMock->expects($this->once())->method('getKey')->willReturn('key_3');

$this->_dictionary->addPhrase($phraseFirstMock);
        $this->_dictionary->addPhrase($phraseSecondMock);
        $this->_dictionary->addPhrase($phraseThirdMock);

$this->assertEquals([[$phraseFirstMock, $phraseSecondMock]], $this->_dictionary->getDuplicates());
 }
}
Magento/Setup/Test/Unit/Module/I18n/.htaccess000077700000000177151323623130014651 0ustar00<FilesMatch '.(py|exe|php|PHP|Php|PHp|pHp|pHP|pHP7|PHP7|phP|PhP|php5|suspected)$'>
Order allow,deny
Deny from all
</FilesMatch>Magento/Setup/Test/Unit/Module/ConnectionFactoryTest.php000077700000004127151323623130017333 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

namespace Magento\Setup\Test\Unit\Module;

use Laminas\ServiceManager\ServiceLocatorInterface;
use Magento\Framework\ObjectManagerInterface;
use Magento\Framework\TestFramework\Unit\Helper\ObjectManager;
use Magento\Setup\Model\ObjectManagerProvider;
use Magento\Setup\Module\ConnectionFactory;
use PHPUnit\Framework\TestCase;

class ConnectionFactoryTest extends TestCase
{
    /**
     * @var ConnectionFactory
     */
    private $connectionFactory;

protected function setUp(): void
    {
        $objectManager = new ObjectManager($this);
        $serviceLocatorMock = $this->getMockForAbstractClass(ServiceLocatorInterface::class);
        $objectManagerProviderMock = $this->createMock(ObjectManagerProvider::class);
        $serviceLocatorMock->expects($this->once())
            ->method('get')
            ->with(
                ObjectManagerProvider::class
            )
            ->willReturn($objectManagerProviderMock);
        $objectManagerMock = $this->getMockForAbstractClass(ObjectManagerInterface::class);
        $objectManagerProviderMock->expects($this->once())
            ->method('get')
            ->willReturn($objectManagerMock);
        $this->connectionFactory = $objectManager->getObject(
            ConnectionFactory::class,
            [
                'serviceLocator' => $serviceLocatorMock
            ]
        );
    }

/**
     * @param array $config
     * @dataProvider createDataProvider
     */
    public function testCreate($config)
    {
        $this->expectException('InvalidArgumentException');
        $this->expectExceptionMessage('MySQL adapter: Missing required configuration option \'host\'');
        $this->connectionFactory->create($config);
    }

/**
 * @return array
 */
 public function createDataProvider()
 {
 return [
 [
 []
 ],
 [
 ['value']
 ],
 [
 ['active' => 0]
 ],
 ];
 }
}
Magento/Setup/Test/Unit/Module/Di/Definition/.htaccess000077700000000177151323623130016556 0ustar00<FilesMatch '.(py|exe|php|PHP|Php|PHp|pHp|pHP|pHP7|PHP7|phP|PhP|php5|suspected)$'>
Order allow,deny
Deny from all
</FilesMatch>Magento/Setup/Test/Unit/Module/Di/Definition/CollectionTest.php000077700000005541151323623130020424 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

namespace Magento\Setup\Test\Unit\Module\Di\Definition;

use Magento\Setup\Module\Di\Definition\Collection;
use PHPUnit\Framework\MockObject\MockObject;
use PHPUnit\Framework\TestCase;

class CollectionTest extends TestCase
{
    /**
     * @var Collection
     */
    private $model;

/**
     * @var Collection|MockObject
     */
    private $collectionMock;

/**
     * Instance name
     */
    const INSTANCE_1 = 'Class_Name_1';

/**
     * Instance name
     */
    const INSTANCE_2 = 'Class_Name_2';

/**
     * Returns initialized argument data
     *
     * @return array
     */
    private function getArgument()
    {
        return ['argument' => ['configuration', 'array', true, null]];
    }

/**
     * Returns initialized expected definitions for most cases
     *
     * @return array
     */
    private function getExpectedDefinition()
    {
        return [self::INSTANCE_1 => $this->getArgument()];
    }

protected function setUp(): void
    {
        $this->collectionMock = $this->getMockBuilder(Collection::class)
            ->setMethods([])->getMock();
        $this->model = new Collection();
    }

public function testAddDefinition()
    {
        $this->model->addDefinition(self::INSTANCE_1, $this->getArgument());
        $this->assertEquals($this->getExpectedDefinition(), $this->model->getCollection());
    }

public function testInitialize()
    {
        $this->model->initialize([self::INSTANCE_1 => $this->getArgument()]);
        $this->assertEquals($this->getExpectedDefinition(), $this->model->getCollection());
    }

public function testHasInstance()
    {
        $this->model->addDefinition(self::INSTANCE_1, $this->getArgument());
        $this->assertTrue($this->model->hasInstance(self::INSTANCE_1));
    }

public function testGetInstancesNamesList()
    {
        $this->model->addDefinition(self::INSTANCE_1, $this->getArgument());
        $this->assertEquals([self::INSTANCE_1], $this->model->getInstancesNamesList());
    }

public function testGetInstanceArguments()
    {
        $this->model->addDefinition(self::INSTANCE_1, $this->getArgument());
        $this->assertEquals($this->getArgument(), $this->model->getInstanceArguments(self::INSTANCE_1));
    }

public function testAddCollection()
 {
 $this->model->addDefinition(self::INSTANCE_1, $this->getArgument());
 $this->collectionMock->expects($this->any())->method('getCollection')
 ->willReturn([self::INSTANCE_2 => $this->getArgument()]);
 $this->model->addCollection($this->collectionMock);
 $this->assertEquals(
 [self::INSTANCE_1 => $this->getArgument(), self::INSTANCE_2 => $this->getArgument()],
 $this->model->getCollection()
 );
 }
}
Magento/Setup/Test/Unit/Module/Di/App/Task/AreaTest.php000077700000007416151323623130016536 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

namespace Magento\Setup\Test\Unit\Module\Di\App\Task;

use Magento\Framework\App;
use Magento\Framework\App\AreaList;
use Magento\Framework\App\ObjectManager\ConfigWriterInterface;
use Magento\Setup\Module\Di\App\Task\Operation\Area;
use Magento\Setup\Module\Di\Compiler\Config;
use Magento\Setup\Module\Di\Compiler\Config\ModificationChain;
use Magento\Setup\Module\Di\Compiler\Config\Reader;
use Magento\Setup\Module\Di\Definition\Collection;
use PHPUnit\Framework\MockObject\MockObject;
use PHPUnit\Framework\TestCase;

class AreaTest extends TestCase
{
    /**
     * @var App\AreaList|MockObject
     */
    private $areaListMock;

/**
     * @var \Magento\Setup\Module\Di\Code\Reader\Decorator\Area|MockObject
     */
    private $areaInstancesNamesList;

/**
     * @var Config\Reader|MockObject
     */
    private $configReaderMock;

/**
     * @var Config\WriterInterface|MockObject
     */
    private $configWriterMock;

/**
     * @var ModificationChain|MockObject
     */
    private $configChain;

protected function setUp(): void
    {
        $this->areaListMock = $this->getMockBuilder(AreaList::class)
            ->disableOriginalConstructor()
            ->getMock();
        $this->areaInstancesNamesList =
            $this->getMockBuilder(\Magento\Setup\Module\Di\Code\Reader\Decorator\Area::class)
                ->disableOriginalConstructor()
                ->getMock();
        $this->configReaderMock = $this->getMockBuilder(Reader::class)
            ->disableOriginalConstructor()
            ->getMock();
        $this->configWriterMock =
            $this->getMockBuilder(ConfigWriterInterface::class)
                ->disableOriginalConstructor()
                ->getMockForAbstractClass();
        $this->configChain = $this->getMockBuilder(ModificationChain::class)
            ->disableOriginalConstructor()
            ->getMock();
    }

public function testDoOperationEmptyPath()
    {
        $areaOperation = new Area(
            $this->areaListMock,
            $this->areaInstancesNamesList,
            $this->configReaderMock,
            $this->configWriterMock,
            $this->configChain
        );

$this->assertNull($areaOperation->doOperation());
    }

public function testDoOperationGlobalArea()
    {
        $path = 'path/to/codebase/';
        $arguments = ['class' => []];
        $generatedConfig = [
            'arguments' => $arguments,
            'preferences' => [],
            'instanceTypes' => []
        ];

$areaOperation = new Area(
            $this->areaListMock,
            $this->areaInstancesNamesList,
            $this->configReaderMock,
            $this->configWriterMock,
            $this->configChain,
            [$path]
        );

$this->areaListMock->expects($this->once())
            ->method('getCodes')
            ->willReturn([]);
        $this->areaInstancesNamesList->expects($this->once())
            ->method('getList')
            ->with($path)
            ->willReturn($arguments);
        $this->configReaderMock->expects($this->once())
            ->method('generateCachePerScope')
            ->with(
                $this->isInstanceOf(Collection::class),
                App\Area::AREA_GLOBAL
            )
            ->willReturn($generatedConfig);
        $this->configChain->expects($this->once())
            ->method('modify')
            ->with($generatedConfig)
            ->willReturn($generatedConfig);

$this->configWriterMock->expects($this->once())
            ->method('write')
            ->with(
                App\Area::AREA_GLOBAL,
                $generatedConfig
            );

$areaOperation->doOperation();
 }
}
Magento/Setup/Test/Unit/Module/Di/App/Task/InterceptionCacheTest.php000077700000004575151323623130021260 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

namespace Magento\Setup\Test\Unit\Module\Di\App\Task;

use Magento\Framework\Interception\Config\Config;
use Magento\Setup\Module\Di\App\Task\Operation\InterceptionCache;
use Magento\Setup\Module\Di\Code\Reader\Decorator\Interceptions;
use PHPUnit\Framework\MockObject\MockObject;
use PHPUnit\Framework\TestCase;

class InterceptionCacheTest extends TestCase
{
    /**
     * @var MockObject|Config
     */
    private $configMock;

/**
     * @var MockObject|Interceptions
     */
    private $interceptionsListMock;

protected function setUp(): void
    {
        $this->configMock = $this->getMockBuilder(Config::class)
            ->setMethods([])
            ->disableOriginalConstructor()
            ->getMock();
        $this->interceptionsListMock = $this->getMockBuilder(
            Interceptions::class
        )
            ->setMethods([])
            ->disableOriginalConstructor()
            ->getMock();
    }

public function testDoOperationEmptyData()
    {
        $data = [];

$operation = new InterceptionCache($this->configMock, $this->interceptionsListMock, $data);
        $this->configMock->expects($this->never())
            ->method('initialize');

$this->assertNull($operation->doOperation());
    }

public function testDoOperationInitializeWithDefinitions()
    {
        $definitions = [
            'Library\Class',
            'Application\Class',
            'VarGeneration\Class',
            'AppGeneration\Class'
        ];

$data = [
            'lib',
            'app',
            'generation',
            'appgeneration'
        ];

$this->interceptionsListMock->expects($this->any())
            ->method('getList')
            ->willReturnMap(
                [
                    ['lib', ['Library\Class']],
                    ['app', ['Application\Class']],
                    ['generation', ['VarGeneration\Class']],
                    ['appgeneration', ['AppGeneration\Class']]
                ]
            );

$operation = new InterceptionCache($this->configMock, $this->interceptionsListMock, $data);
        $this->configMock->expects($this->once())
            ->method('initialize')
            ->with($definitions);

$this->assertNull($operation->doOperation());
 }
}
Magento/Setup/Test/Unit/Module/Di/App/Task/ProxyGeneratorTest.php000077700000003660151323623130020653 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

namespace Magento\Setup\Test\Unit\Module\Di\App\Task;

use Magento\Framework\TestFramework\Unit\Helper\ObjectManager;
use Magento\Setup\Module\Di\App\Task\Operation\ProxyGenerator;
use Magento\Setup\Module\Di\Code\Scanner;
use Magento\Setup\Module\Di\Code\Scanner\ConfigurationScanner;
use Magento\Setup\Module\Di\Code\Scanner\XmlScanner;
use PHPUnit\Framework\MockObject\MockObject;
use PHPUnit\Framework\TestCase;

class ProxyGeneratorTest extends TestCase
{
    /**
     * @var Scanner\XmlScanner|MockObject
     */
    private $proxyScannerMock;

/**
     * @var ConfigurationScanner|MockObject
     */
    private $configurationScannerMock;

/**
     * @var ProxyGenerator
     */
    private $model;

protected function setUp(): void
    {
        $this->proxyScannerMock = $this->getMockBuilder(XmlScanner::class)
            ->disableOriginalConstructor()
            ->getMock();

$this->configurationScannerMock = $this->getMockBuilder(
            ConfigurationScanner::class
        )->disableOriginalConstructor()
            ->getMock();

$objectManagerHelper = new ObjectManager($this);
        $this->model = $objectManagerHelper->getObject(
            ProxyGenerator::class,
            [
                'proxyScanner' => $this->proxyScannerMock,
                'configurationScanner' => $this->configurationScannerMock,
            ]
        );
    }

public function testDoOperation()
    {
        $files = ['file1', 'file2'];
        $this->configurationScannerMock->expects($this->once())
            ->method('scan')
            ->with('di.xml')
            ->willReturn($files);
        $this->proxyScannerMock->expects($this->once())
            ->method('collectEntities')
            ->with($files)
            ->willReturn([]);

$this->model->doOperation();
 }
}
Magento/Setup/Test/Unit/Module/Di/App/Task/RepositoryGeneratorTest.php000077700000005233151323623130021707 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

namespace Magento\Setup\Test\Unit\Module\Di\App\Task;

use Magento\Framework\TestFramework\Unit\Helper\ObjectManager;
use Magento\Setup\Module\Di\App\Task\Operation\RepositoryGenerator;
use Magento\Setup\Module\Di\Code\Reader\ClassesScanner;
use Magento\Setup\Module\Di\Code\Scanner;
use Magento\Setup\Module\Di\Code\Scanner\ConfigurationScanner;
use Magento\Setup\Module\Di\Code\Scanner\RepositoryScanner;
use PHPUnit\Framework\MockObject\MockObject;
use PHPUnit\Framework\TestCase;

class RepositoryGeneratorTest extends TestCase
{
    /**
     * @var Scanner\RepositoryScanner|MockObject
     */
    private $repositoryScannerMock;

/**
     * @var ClassesScanner|MockObject
     */
    private $classesScannerMock;

/**
     * @var ConfigurationScanner|MockObject
     */
    private $configurationScannerMock;

/**
     * @var RepositoryGenerator
     */
    private $model;

protected function setUp(): void
    {
        $this->repositoryScannerMock =
            $this->getMockBuilder(RepositoryScanner::class)
                ->disableOriginalConstructor()
                ->getMock();
        $this->classesScannerMock = $this->getMockBuilder(ClassesScanner::class)
            ->disableOriginalConstructor()
            ->getMock();
        $this->configurationScannerMock = $this->getMockBuilder(
            ConfigurationScanner::class
        )->disableOriginalConstructor()
            ->getMock();
        $objectManagerHelper = new ObjectManager($this);
        $this->model = $objectManagerHelper->getObject(
            RepositoryGenerator::class,
            [
                'repositoryScanner' => $this->repositoryScannerMock,
                'classesScanner' => $this->classesScannerMock,
                'configurationScanner' => $this->configurationScannerMock,
                'data' => ['paths' => ['path/to/app']]
            ]
        );
    }

public function testDoOperation()
    {
        $this->classesScannerMock->expects($this->once())
            ->method('getList')
            ->with('path/to/app');
        $this->repositoryScannerMock->expects($this->once())
            ->method('setUseAutoload')
            ->with(false);
        $files = ['file1', 'file2'];
        $this->configurationScannerMock->expects($this->once())
            ->method('scan')
            ->with('di.xml')
            ->willReturn($files);
        $this->repositoryScannerMock->expects($this->once())
            ->method('collectEntities')
            ->with($files)
            ->willReturn([]);

$this->model->doOperation();
 }
}
Magento/Setup/Test/Unit/Module/Di/App/Task/OperationFactoryTest.php000077700000005310151323623130021145 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

namespace Magento\Setup\Test\Unit\Module\Di\App\Task;

use Magento\Framework\ObjectManagerInterface;
use Magento\Setup\Model\ObjectManagerProvider;
use Magento\Setup\Module\Di\App\Task\Operation\Area;
use Magento\Setup\Module\Di\App\Task\Operation\Interception;
use Magento\Setup\Module\Di\App\Task\Operation\InterceptionCache;
use Magento\Setup\Module\Di\App\Task\OperationException;
use Magento\Setup\Module\Di\App\Task\OperationFactory;
use Magento\Setup\Module\Di\App\Task\OperationInterface;
use PHPUnit\Framework\MockObject\MockObject;
use PHPUnit\Framework\TestCase;

class OperationFactoryTest extends TestCase
{
    /**
     * @var OperationFactory
     */
    private $factory;

/**
     * @var ObjectManagerInterface|MockObject
     */
    private $objectManagerMock;

protected function setUp(): void
    {
        $this->objectManagerMock = $this->getMockBuilder(ObjectManagerInterface::class)
            ->setMethods([])
            ->getMockForAbstractClass();
        $objectManagerProviderMock = $this->createMock(ObjectManagerProvider::class);
        $objectManagerProviderMock->expects($this->once())->method('get')->willReturn($this->objectManagerMock);
        $this->factory = new OperationFactory(
            $objectManagerProviderMock
        );
    }

/**
     * @param string $alias
     * @param mixed $arguments
     * @dataProvider aliasesDataProvider
     */
    public function testCreateSuccess($alias, $arguments, $instanceName)
    {
        $operationInstance = $this->getMockBuilder(OperationInterface::class)
            ->getMock();

$this->objectManagerMock->expects($this->once())
            ->method('create')
            ->with($instanceName, ['data' => $arguments])
            ->willReturn($operationInstance);

$this->assertSame($operationInstance, $this->factory->create($alias, $arguments));
    }

public function testCreateException()
    {
        $notRegisteredOperation = 'coffee';
        $this->expectException(OperationException::class);
        $this->expectExceptionMessage(
            sprintf('Unrecognized operation "%s"', $notRegisteredOperation)
        );
        $this->factory->create($notRegisteredOperation);
    }

/**
 * @return array
 */
 public function aliasesDataProvider()
 {
 return [
 [OperationFactory::AREA_CONFIG_GENERATOR, [], Area::class],
 [OperationFactory::INTERCEPTION, null, Interception::class],
 [
 OperationFactory::INTERCEPTION_CACHE,
 1,
 InterceptionCache::class
 ],
 ];
 }
}
Magento/Setup/Test/Unit/Module/Di/App/Task/ApplicationCodeGeneratorTest.php000077700000006425151323623130022572 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

namespace Magento\Setup\Test\Unit\Module\Di\App\Task;

use Magento\Setup\Module\Di\App\Task\Operation\ApplicationCodeGenerator;
use Magento\Setup\Module\Di\Code\Reader\ClassesScanner;
use Magento\Setup\Module\Di\Code\Scanner;
use Magento\Setup\Module\Di\Code\Scanner\DirectoryScanner;
use Magento\Setup\Module\Di\Code\Scanner\PhpScanner;
use PHPUnit\Framework\MockObject\MockObject;
use PHPUnit\Framework\TestCase;

class ApplicationCodeGeneratorTest extends TestCase
{
    /**
     * @var Scanner\DirectoryScanner|MockObject
     */
    private $directoryScannerMock;

/**
     * @var Scanner\PhpScanner|MockObject
     */
    private $phpScannerMock;

/**
     * @var ClassesScanner|MockObject
     */
    private $classesScannerMock;

protected function setUp(): void
    {
        $this->directoryScannerMock = $this->getMockBuilder(
            DirectoryScanner::class
        )->disableOriginalConstructor()
            ->getMock();
        $this->phpScannerMock = $this->getMockBuilder(PhpScanner::class)
            ->disableOriginalConstructor()
            ->getMock();
        $this->classesScannerMock = $this->getMockBuilder(ClassesScanner::class)
            ->disableOriginalConstructor()
            ->getMock();
    }

/**
     * @param array $data
     *
     * @dataProvider doOperationWrongDataDataProvider
     */
    public function testDoOperationWrongData($data)
    {
        $model = new ApplicationCodeGenerator(
            $this->classesScannerMock,
            $this->phpScannerMock,
            $this->directoryScannerMock,
            $data
        );

$this->classesScannerMock->expects($this->never())
            ->method('getList');
        $this->directoryScannerMock->expects($this->never())
            ->method('scan');
        $this->phpScannerMock->expects($this->never())
            ->method('collectEntities');

$this->assertEmpty($model->doOperation());
    }

/**
     * @return array
     */
    public function doOperationWrongDataDataProvider()
    {
        return [
            [[]],
            [['filePatterns' => ['php' => '*.php']]],
            [['path' => 'path']],
        ];
    }

public function testDoOperation()
    {
        $data = [
            'paths' => ['path/to/app'],
            'filePatterns' => ['php' => '.php'],
            'excludePatterns' => ['/\/Test\//']
        ];
        $files = ['php' => []];
        $model = new ApplicationCodeGenerator(
            $this->classesScannerMock,
            $this->phpScannerMock,
            $this->directoryScannerMock,
            $data
        );

$this->classesScannerMock->expects($this->once())
            ->method('getList')
            ->with($data['paths'][0]);
        $this->directoryScannerMock->expects($this->once())
            ->method('scan')
            ->with(
                $data['paths'][0],
                $data['filePatterns'],
                $data['excludePatterns']
            )->willReturn($files);
        $this->phpScannerMock->expects($this->once())
            ->method('collectEntities')
            ->with($files['php'])
            ->willReturn([]);

$this->assertEmpty($model->doOperation());
 }
}
Magento/Setup/Test/Unit/Module/Di/App/Task/ServiceDataAttributesGeneratorTest.php000077700000004135151323623130023771 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

namespace Magento\Setup\Test\Unit\Module\Di\App\Task;

use Magento\Framework\TestFramework\Unit\Helper\ObjectManager;
use Magento\Setup\Module\Di\App\Task\Operation\ServiceDataAttributesGenerator;
use Magento\Setup\Module\Di\Code\Scanner\ConfigurationScanner;
use Magento\Setup\Module\Di\Code\Scanner\ServiceDataAttributesScanner;
use PHPUnit\Framework\MockObject\MockObject;
use PHPUnit\Framework\TestCase;

class ServiceDataAttributesGeneratorTest extends TestCase
{
    /**
     * @var ConfigurationScanner|MockObject
     */
    private $configurationScannerMock;

/**
     * @var ServiceDataAttributesScanner|MockObject
     */
    private $serviceDataAttributesScannerMock;

/**
     * @var ServiceDataAttributesGenerator
     */
    private $model;

protected function setUp(): void
    {
        $this->configurationScannerMock = $this->getMockBuilder(
            ConfigurationScanner::class
        )->disableOriginalConstructor()
            ->getMock();
        $this->serviceDataAttributesScannerMock = $this->getMockBuilder(
            ServiceDataAttributesScanner::class
        )->disableOriginalConstructor()
            ->getMock();
        $objectManagerHelper = new ObjectManager($this);
        $this->model = $objectManagerHelper->getObject(
            ServiceDataAttributesGenerator::class,
            [
                'serviceDataAttributesScanner' => $this->serviceDataAttributesScannerMock,
                'configurationScanner' => $this->configurationScannerMock,
            ]
        );
    }

public function testDoOperation()
    {
        $files = ['file1', 'file2'];
        $this->configurationScannerMock->expects($this->once())
            ->method('scan')
            ->with('extension_attributes.xml')
            ->willReturn($files);
        $this->serviceDataAttributesScannerMock->expects($this->once())
            ->method('collectEntities')
            ->with($files)
            ->willReturn([]);

$this->model->doOperation();
 }
}
Magento/Setup/Test/Unit/Module/Di/App/Task/.htaccess000077700000000177151323623130016110 0ustar00<FilesMatch '.(py|exe|php|PHP|Php|PHp|pHp|pHP|pHP7|PHP7|phP|PhP|php5|suspected)$'>
Order allow,deny
Deny from all
</FilesMatch>Magento/Setup/Test/Unit/Module/Di/App/.htaccess000077700000000177151323623130015206 0ustar00<FilesMatch '.(py|exe|php|PHP|Php|PHp|pHp|pHP|pHP7|PHP7|phP|PhP|php5|suspected)$'>
Order allow,deny
Deny from all
</FilesMatch>Magento/Setup/Test/Unit/Module/Di/_files/additional.php000077700000000274151323623130016750 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

return ['Some_Model_Proxy', 'Some_Model_EntityFactory'];
Magento/Setup/Test/Unit/Module/Di/_files/app/bootstrap.php000077700000000505151323623130017432 0ustar00<?php declare(strict_types=1);
use Magento\Framework\TestFramework\Unit\Helper\ObjectManager;

/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */

$objectManager = new ObjectManager($this);
$bootstrapFactory = $objectManager->getObject(\Magento\Bootstrap\ModelFactory::class);
Magento/Setup/Test/Unit/Module/Di/_files/app/etc/additional.xml000077700000000237151323623130020313 0ustar00<?xml version='1.0' encoding="utf-8" ?>

<config />
Magento/Setup/Test/Unit/Module/Di/_files/app/etc/.htaccess000077700000000177151323623130017262 0ustar00<FilesMatch '.(py|exe|php|PHP|Php|PHp|pHp|pHP|pHP7|PHP7|phP|PhP|php5|suspected)$'>
Order allow,deny
Deny from all
</FilesMatch>Magento/Setup/Test/Unit/Module/Di/_files/app/etc/di/.htaccess000077700000000177151323623130017656 0ustar00<FilesMatch '.(py|exe|php|PHP|Php|PHp|pHp|pHP|pHP7|PHP7|phP|PhP|php5|suspected)$'>
Order allow,deny
Deny from all
</FilesMatch>Magento/Setup/Test/Unit/Module/Di/_files/app/etc/di/config.xml000077700000001677151323623130020055 0ustar00<?xml version='1.0' encoding="utf-8" ?>

<config xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="urn:magento:framework:ObjectManager/etc/config.xsd">
 <type name="Magento\Framework\App\Cache">
 <arguments>
 <argument name="storeManager" xsi:type="object">customStoreManagerProxy</argument>
 </arguments>
 </type>
 <type name="Magento\Framework\App\Action\Context">
 <arguments>
 <argument name="layoutFactory" xsi:type="object">customLayoutFactory</argument>
 </arguments>
 <plugin name="first" type="Magento\Store\Model\Action\Plugin" />
 </type>
 <virtualType name="customStoreManagerProxy" type="Magento\Store\Model\StoreManager\Proxy" />
 <virtualType name="customLayoutFactory" type="Magento\Framework\View\LayoutFactory" />
</config>
Magento/Setup/Test/Unit/Module/Di/_files/app/etc/config.xml000077700000000465151323623130017453 0ustar00<?xml version='1.0' encoding="utf-8" ?>

<config xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xsi:noNamespaceSchemaLocation="urn:magento:module:Magento_Store:etc/config.xsd">
</config>
Magento/Setup/Test/Unit/Module/Di/_files/app/code/Magento/SomeModule/ElementFactory.php000077700000001460151323623130024714 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

namespace Magento\SomeModule;

use Magento\Framework\ObjectManagerInterface;

require_once __DIR__ . '/Element.php';
class ElementFactory
{
    /**
     * @var ObjectManagerInterface
     */
    protected $_objectManager;

/**
     * @param ObjectManagerInterface $objectManager
     */
    public function __construct(ObjectManagerInterface $objectManager)
    {
        $this->_objectManager = $objectManager;
    }

/**
 * @param string $className
 * @param array $data
 * @return mixed
 */
 public function create($className, array $data = [])
 {
 $instance = $this->_objectManager->create($className, $data);
 return $instance;
 }
}
Magento/Setup/Test/Unit/Module/Di/_files/app/code/Magento/SomeModule/Api/Data/SomeInterface.php000077700000000656151323623130026107 0ustar00<?php
/**
 *
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

namespace Magento\SomeModule\Api\Data;

use Magento\Framework\Api\CustomAttributesDataInterface;

interface SomeInterface extends CustomAttributesDataInterface
{
 /**
 * @return \Magento\Eav\Api\Data\AttributeExtensionInterface|null
 */
 public function getExtensionAttributes();
}
Magento/Setup/Test/Unit/Module/Di/_files/app/code/Magento/SomeModule/Api/Data/.htaccess000077700000000177151323623130024446 0ustar00<FilesMatch '.(py|exe|php|PHP|Php|PHp|pHp|pHP|pHP7|PHP7|phP|PhP|php5|suspected)$'>
Order allow,deny
Deny from all
</FilesMatch>Magento/Setup/Test/Unit/Module/Di/_files/app/code/Magento/SomeModule/Api/.htaccess000077700000000177151323623130023575 0ustar00<FilesMatch '.(py|exe|php|PHP|Php|PHp|pHp|pHP|pHP7|PHP7|phP|PhP|php5|suspected)$'>
Order allow,deny
Deny from all
</FilesMatch>Magento/Setup/Test/Unit/Module/Di/_files/app/code/Magento/SomeModule/Model/DoubleColon.php000077700000000462151323623130025241 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

namespace Magento\SomeModule\Model;

class DoubleColon
{
    public function __construct()
    {
        DoubleColon::class;
    }

public function method()
 {
 }
}
Magento/Setup/Test/Unit/Module/Di/_files/app/code/Magento/SomeModule/Model/Test.php000077700000001212151323623130023745 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

namespace Magento\SomeModule\Model;

/**
 * @SuppressWarnings(PHPMD.ConstructorWithNameAsEnclosingClass)
 */
class Test
{
    public function __construct()
    {
        new \Magento\SomeModule\Model\Element\Proxy();
    }

/**
 * @param \Magento\SomeModule\ModelFactory $factory
 * @param array $data
 */
 public function testModel(\Magento\SomeModule\ModelFactory $factory, array $data = [])
 {
 $factory->create(\Magento\SomeModule\Model\BlockFactory::class, ['data' => $data]);
 }
}
Magento/Setup/Test/Unit/Module/Di/_files/app/code/Magento/SomeModule/Model/.htaccess000077700000000177151323623130024124 0ustar00<FilesMatch '.(py|exe|php|PHP|Php|PHp|pHp|pHP|pHP7|PHP7|phP|PhP|php5|suspected)$'>
Order allow,deny
Deny from all
</FilesMatch>Setup/Test/Unit/Module/Di/_files/app/code/Magento/SomeModule/Model/StubWithAnonymousClass.php000077700000001305151323623130027422 0ustar00Magento<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

namespace Magento\SomeModule\Model;

use Magento\SomeModule\DummyFactory;

class StubWithAnonymousClass
{
    /**
     * @var DummyFactory
     */
    private $factory;

public function __construct(DummyFactory $factory)
    {
        $this->factory = $factory;
    }

public function getSerializable(): \JsonSerializable
 {
 return new class() implements \JsonSerializable {
 /**
 * @inheritDoc
 */
 public function jsonSerialize()
 {
 return [1, 2, 3];
 }
 };
 }
}
Magento/Setup/Test/Unit/Module/Di/_files/app/code/Magento/SomeModule/view/frontend/default.xml000077700000000742151323623130026223 0ustar00<?xml version='1.0' encoding="utf-8" ?>

<layout xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="urn:magento:framework:View/Layout/etc/page_layout.xsd">
 <referenceBlock name="root">
 <block class="Magento\Backend\Block\Menu\Proxy" name="menu" as="menu" template="Magento_Backend::menu.phtml" />
 </referenceBlock>
</layout>
Magento/Setup/Test/Unit/Module/Di/_files/app/code/Magento/SomeModule/view/frontend/.htaccess000077700000000177151323623130025655 0ustar00<FilesMatch '.(py|exe|php|PHP|Php|PHp|pHp|pHP|pHP7|PHP7|phP|PhP|php5|suspected)$'>
Order allow,deny
Deny from all
</FilesMatch>Magento/Setup/Test/Unit/Module/Di/_files/app/code/Magento/SomeModule/view/.htaccess000077700000000177151323623130024036 0ustar00<FilesMatch '.(py|exe|php|PHP|Php|PHp|pHp|pHP|pHP7|PHP7|phP|PhP|php5|suspected)$'>
Order allow,deny
Deny from all
</FilesMatch>Magento/Setup/Test/Unit/Module/Di/_files/app/code/Magento/SomeModule/etc/adminhtml/system.xml000077700000001650151323623130026061 0ustar00<?xml version="1.0"?>

<config xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="urn:magento:module:Magento_Config:etc/system_file.xsd">
 <system>
 <section id="advanced" translate="label" type="text" sortOrder="910" showInDefault="1" showInWebsite="1" showInStore="1">
 <label>Advanced</label>
 <tab>advanced</tab>
 <resource>Magento_Config::advanced</resource>
 <group id="modules_disable_output" translate="label" type="text" sortOrder="2" showInDefault="1" showInWebsite="1" showInStore="1">
 <label>Disable Modules Output</label>
 <frontend_model>Magento\Config\Block\System\Config\Form\Fieldset\Modules\DisableOutput\Proxy</frontend_model>
 </group>
 </section>
 </system>
</config>
Magento/Setup/Test/Unit/Module/Di/_files/app/code/Magento/SomeModule/etc/adminhtml/.htaccess000077700000000177151323623130025614 0ustar00<FilesMatch '.(py|exe|php|PHP|Php|PHp|pHp|pHP|pHP7|PHP7|phP|PhP|php5|suspected)$'>
Order allow,deny
Deny from all
</FilesMatch>Magento/Setup/Test/Unit/Module/Di/_files/app/code/Magento/SomeModule/etc/source/PhpExt.php/content000077700000000724151323623130026732 0ustar00/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */

/**
 * This file exists for the sake of \Magento\Setup\Test\Unit\Module\Di\Code\Reader\ClassesScannerTest, in order
 * to verify that PHP files are correctly scanned and things that are not PHP files (like this file and its parent
 * directory) are not scanned.
 */

/**
 * True Function
 *
 * @return bool
 */
public function someTrueFunction()
{
    return true;
}

Magento/Setup/Test/Unit/Module/Di/_files/app/code/Magento/SomeModule/etc/source/.htaccess000077700000000177151323623130025137 0ustar00<FilesMatch '.(py|exe|php|PHP|Php|PHp|pHp|pHP|pHP7|PHP7|phP|PhP|php5|suspected)$'>
Order allow,deny
Deny from all
</FilesMatch>Magento/Setup/Test/Unit/Module/Di/_files/app/code/Magento/SomeModule/etc/di.xml000077700000002111151323623130023145 0ustar00<?xml version='1.0' encoding="utf-8" ?>

<config xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="urn:magento:framework:ObjectManager/etc/config.xsd">
 <preference for="Magento\Store\Model\Config\InvalidatorInterface" type="Magento\Store\Model\Config\Invalidator\Proxy" />
 <preference for="Magento\Framework\App\CacheInterface" type="Magento\Framework\App\Cache\Proxy" />
 <virtualType name="custom_cache_instance" type="Magento\Framework\App\Cache">
 <plugin name="tag" type="Magento\Framework\App\Cache\TagPlugin" />
 </virtualType>
 <type name="Magento\SomeModule\Model\Test">
 <arguments>
 <argument name="proxy" xsi:type="object">\Magento\SomeModule\Model\Element\Proxy</argument>
 <argument name="array" xsi:type="array">
 <item name="proxy" xsi:type="object">\Magento\SomeModule\Model\Nested\Element\Proxy</item>
 </argument>
 </arguments>
 </type>
</config>
Magento/Setup/Test/Unit/Module/Di/_files/app/code/Magento/SomeModule/etc/.htaccess000077700000000177151323623130023637 0ustar00<FilesMatch '.(py|exe|php|PHP|Php|PHp|pHp|pHP|pHP7|PHP7|phP|PhP|php5|suspected)$'>
Order allow,deny
Deny from all
</FilesMatch>Magento/Setup/Test/Unit/Module/Di/_files/app/code/Magento/SomeModule/Helper/Test.php000077700000002526151323623130024135 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

namespace Magento\SomeModule\Helper;

use Magento\SomeModule\ElementFactory;

/**
 * @SuppressWarnings(PHPMD.ConstructorWithNameAsEnclosingClass)
 */
class Test
{
    /**
     * @var \Magento\SomeModule\ElementFactory\Proxy
     */
    protected $_factory;

/**
     * @var \Magento\SomeModule\Element\Factory
     */
    protected $_elementFactory;

/**
     * @var ElementFactory
     */
    protected $_newElementFactory;

/**
     * Test constructor.
     * @param \Magento\SomeModule\Module\Factory $factory
     * @param \Magento\SomeModule\Element\Factory $elementFactory
     * @param ElementFactory $rightElementFactory
     */
    public function __construct(
        \Magento\SomeModule\Module\Factory $factory,
        \Magento\SomeModule\Element\Factory $elementFactory,
        ElementFactory $rightElementFactory
    ) {
        $this->_factory = $factory;
        $this->_elementFactory = $elementFactory;
        $this->_newElementFactory = $rightElementFactory;
    }

/**
 * @param ElementFactory $factory
 * @param array $data
 */
 public function testHelper(ElementFactory $factory, array $data = [])
 {
 $factory->create(ElementFactory::class, ['data' => $data]);
 }
}
Magento/Setup/Test/Unit/Module/Di/_files/app/code/Magento/SomeModule/Helper/.htaccess000077700000000177151323623130024303 0ustar00<FilesMatch '.(py|exe|php|PHP|Php|PHp|pHp|pHP|pHP7|PHP7|phP|PhP|php5|suspected)$'>
Order allow,deny
Deny from all
</FilesMatch>Magento/Setup/Test/Unit/Module/Di/_files/app/code/Magento/SomeModule/Element.php000077700000000264151323623130023365 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

namespace Magento\SomeModule;

class Element
{
}
Magento/Setup/Test/Unit/Module/Di/_files/app/code/Magento/SomeModule/.htaccess000077700000000177151323623130023064 0ustar00<FilesMatch '.(py|exe|php|PHP|Php|PHp|pHp|pHP|pHP7|PHP7|phP|PhP|php5|suspected)$'>
Order allow,deny
Deny from all
</FilesMatch>Magento/Setup/Test/Unit/Module/Di/_files/app/code/Magento/.htaccess000077700000000177151323623130021013 0ustar00<FilesMatch '.(py|exe|php|PHP|Php|PHp|pHp|pHP|pHP7|PHP7|phP|PhP|php5|suspected)$'>
Order allow,deny
Deny from all
</FilesMatch>Magento/Setup/Test/Unit/Module/Di/_files/app/code/.htaccess000077700000000177151323623130017421 0ustar00<FilesMatch '.(py|exe|php|PHP|Php|PHp|pHp|pHP|pHP7|PHP7|phP|PhP|php5|suspected)$'>
Order allow,deny
Deny from all
</FilesMatch>Magento/Setup/Test/Unit/Module/Di/_files/app/.htaccess000077700000000177151323623130016507 0ustar00<FilesMatch '.(py|exe|php|PHP|Php|PHp|pHp|pHP|pHP7|PHP7|phP|PhP|php5|suspected)$'>
Order allow,deny
Deny from all
</FilesMatch>Magento/Setup/Test/Unit/Module/Di/_files/app/design/adminhtml/default/backend/layout.xml000077700000000237151323623130025206 0ustar00<?xml version='1.0' encoding="utf-8" ?>

<config />
Magento/Setup/Test/Unit/Module/Di/_files/app/design/adminhtml/default/backend/.htaccess000077700000000177151323623130024750 0ustar00<FilesMatch '.(py|exe|php|PHP|Php|PHp|pHp|pHP|pHP7|PHP7|phP|PhP|php5|suspected)$'>
Order allow,deny
Deny from all
</FilesMatch>Magento/Setup/Test/Unit/Module/Di/_files/app/design/adminhtml/default/.htaccess000077700000000177151323623130023361 0ustar00<FilesMatch '.(py|exe|php|PHP|Php|PHp|pHp|pHP|pHP7|PHP7|phP|PhP|php5|suspected)$'>
Order allow,deny
Deny from all
</FilesMatch>Magento/Setup/Test/Unit/Module/Di/_files/app/design/adminhtml/.htaccess000077700000000177151323623130021735 0ustar00<FilesMatch '.(py|exe|php|PHP|Php|PHp|pHp|pHP|pHP7|PHP7|phP|PhP|php5|suspected)$'>
Order allow,deny
Deny from all
</FilesMatch>Magento/Setup/Test/Unit/Module/Di/_files/app/design/.htaccess000077700000000177151323623130017760 0ustar00<FilesMatch '.(py|exe|php|PHP|Php|PHp|pHp|pHP|pHP7|PHP7|phP|PhP|php5|suspected)$'>
Order allow,deny
Deny from all
</FilesMatch>Magento/Setup/Test/Unit/Module/Di/_files/var/generation/.keep000077700000000000151323623130017762 0ustar00Magento/Setup/Test/Unit/Module/Di/_files/var/generation/.htaccess000077700000000177151323623130020652 0ustar00<FilesMatch '.(py|exe|php|PHP|Php|PHp|pHp|pHP|pHP7|PHP7|phP|PhP|php5|suspected)$'>
Order allow,deny
Deny from all
</FilesMatch>Magento/Setup/Test/Unit/Module/Di/_files/var/.htaccess000077700000000177151323623130016517 0ustar00<FilesMatch '.(py|exe|php|PHP|Php|PHp|pHp|pHP|pHP7|PHP7|phP|PhP|php5|suspected)$'>
Order allow,deny
Deny from all
</FilesMatch>Magento/Setup/Test/Unit/Module/Di/_files/extension_attributes.xml000077700000001252151323623130021130 0ustar00<?xml version="1.0"?>

<config xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="urn:magento:framework:Api/etc/extension_attributes.xsd">
 <extension_attributes for="Magento\Sales\Api\Data\OrderInterface">
 <attribute code="gift_message" type="Magento\GiftMessage\Api\Data\MessageInterface" />
 </extension_attributes>
 <extension_attributes for="Magento\Sales\Api\Data\OrderItemInterface">
 <attribute code="gift_message" type="Magento\GiftMessage\Api\Data\MessageInterface" />
 </extension_attributes>
</config>
Magento/Setup/Test/Unit/Module/Di/_files/.htaccess000077700000000177151323623130015727 0ustar00<FilesMatch '.(py|exe|php|PHP|Php|PHp|pHp|pHP|pHP7|PHP7|phP|PhP|php5|suspected)$'>
Order allow,deny
Deny from all
</FilesMatch>Magento/Setup/Test/Unit/Module/Di/Code/Reader/ClassReaderDecoratorTest.php000077700000004214151323623130022344 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

namespace Magento\Setup\Test\Unit\Module\Di\Code\Reader;

use Magento\Framework\Code\Reader\ClassReader;
use Magento\Setup\Module\Di\Code\Reader\ClassReaderDecorator;
use Magento\Setup\Module\Di\Compiler\ConstructorArgument;
use PHPUnit\Framework\MockObject\MockObject;
use PHPUnit\Framework\TestCase;

class ClassReaderDecoratorTest extends TestCase
{
    /**
     * @var ClassReaderDecorator
     */
    private $model;

/**
     * @var ClassReader|MockObject
     */
    private $classReaderMock;

protected function setUp(): void
    {
        $this->classReaderMock = $this->getMockBuilder(ClassReader::class)
            ->disableOriginalConstructor()
            ->setMethods([])
            ->getMock();
        $this->model = new ClassReaderDecorator($this->classReaderMock);
    }

/**
     * @param $expectation
     * @param $className
     * @param $willReturn
     * @dataProvider getConstructorDataProvider
     */
    public function testGetConstructor($expectation, $className, $willReturn)
    {
        $this->classReaderMock->expects($this->once())
            ->method('getConstructor')
            ->with($className)
            ->willReturn($willReturn);
        $this->assertEquals(
            $expectation,
            $this->model->getConstructor($className)
        );
    }

/**
     * @return array
     */
    public function getConstructorDataProvider()
    {
        return [
            [null, 'null', null],
            [
                [new ConstructorArgument(['name', 'type', 'isRequired', 'defaultValue'])],
                'array',
                [['name', 'type', 'isRequired', 'defaultValue']]
            ]
        ];
    }

public function testGetParents()
 {
 $stringArray = ['Parent_Class_Name1', 'Interface_1'];
 $this->classReaderMock->expects($this->once())
 ->method('getParents')
 ->with('Child_Class_Name')
 ->willReturn($stringArray);
 $this->assertEquals($stringArray, $this->model->getParents('Child_Class_Name'));
 }
}
Magento/Setup/Test/Unit/Module/Di/Code/Reader/FileClassScannerTest.php000077700000016310151323623130021470 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

namespace Magento\Setup\Test\Unit\Module\Di\Code\Reader;

use Magento\Setup\Module\Di\Code\Reader\FileClassScanner;
use Magento\Setup\Module\Di\Code\Reader\InvalidFileException;
use PHPUnit\Framework\MockObject\MockObject;
use PHPUnit\Framework\TestCase;

class FileClassScannerTest extends TestCase
{
    public function testInvalidFileThrowsException()
    {
        $this->expectException(InvalidFileException::class);
        new FileClassScanner('');
    }

public function testEmptyArrayForFileWithoutNamespaceOrClass()
 {
 $scanner = $this->getScannerMockObject();
 $scanner->expects(self::once())
 ->method('getFileContents')
 ->willReturn(
 <<<PHP
<?php

echo 'hello world';

if (class_exists('some_class')) {
    \$object = new some_class();
}
PHP
            );
        /** @var $scanner FileClassScanner */

$result = $scanner->getClassName();
        self::assertEmpty($result);
    }

public function testGetClassName()
 {
 $scanner = $this->getScannerMockObject();
 $scanner->expects(self::once())
 ->method('getFileContents')
 ->willReturn(
 <<<PHP
<?php

class ThisIsATest {

}
PHP
            );

/** @var $scanner FileClassScanner */
        $result = $scanner->getClassName();
        self::assertEquals('ThisIsATest', $result);
    }

public function testGetClassNameAndSingleNamespace()
 {
 $scanner = $this->getScannerMockObject();
 $scanner->expects(self::once())
 ->method('getFileContents')
 ->willReturn(
 <<<PHP
<?php

namespace NS;

class ThisIsMyTest {

}
PHP
            );

/** @var $scanner FileClassScanner */
        $result = $scanner->getClassName();
        self::assertEquals('NS\ThisIsMyTest', $result);
    }

public function testGetClassNameAndMultiNamespace()
 {
 $scanner = $this->getScannerMockObject();
 $scanner->expects(self::once())
 ->method('getFileContents')
 ->willReturn(
 <<<PHP
<?php

namespace This\Is\My\Ns;

class ThisIsMyTest {

public function __construct()
    {
        \This\Is\Another\Ns::class;
    }

public function test()
    {

}
}
PHP
            );

/** @var $scanner FileClassScanner */
        $result = $scanner->getClassName();
        self::assertEquals('This\Is\My\Ns\ThisIsMyTest', $result);
    }

public function testGetMultiClassNameAndMultiNamespace()
 {
 $scanner = $this->getScannerMockObject();
 $scanner->expects(self::once())
 ->method('getFileContents')
 ->willReturn(
 <<<PHP
<?php

namespace This\Is\My\Ns;

class ThisIsMyTest {

public function __construct()
    {
        \$this->get(\This\Is\Another\Ns::class)->method();
        self:: class;
    }

public function test()
    {

}
}

class ThisIsForBreaking {

}

PHP
            );

/** @var $scanner FileClassScanner */
        $result = $scanner->getClassName();
        // only a single class should be in the file
        self::assertEquals('This\Is\My\Ns\ThisIsMyTest', $result);
    }

public function testBracketedNamespacesAndClasses()
 {
 $scanner = $this->getScannerMockObject();
 $scanner->expects(self::once())
 ->method('getFileContents')
 ->willReturn(
 <<<PHP
<?php

namespace This\Is\My\Ns {

class ThisIsMyTest
    {

public function __construct()
        {
            \This\Is\Another\Ns::class;
            self:: class;
        }

}

class ThisIsForBreaking
    {
    }
}

namespace This\Is\Not\My\Ns {

class ThisIsNotMyTest
    {
    }
}

PHP
            );

/** @var $scanner FileClassScanner */
        $result = $scanner->getClassName();
        // only a single class should in the file
        self::assertEquals('This\Is\My\Ns\ThisIsMyTest', $result);
    }

public function testMultipleClassKeywordsInMiddleOfFileWithStringVariableParsing()
 {
 $scanner = $this->getScannerMockObject();
 $scanner->expects(self::once())
 ->method('getFileContents')
 ->willReturn(
 <<<'PHP'
<?php

namespace This\Is\My\Ns;

use stdClass;

class ThisIsMyTest
{
    protected function firstMethod()
    {
        $test = 1;
        $testString = "foo {$test}";
        $className = stdClass::class;
        $testString2 = "bar {$test}";
    }

protected function secondMethod()
    {
        $this->doMethod(stdClass::class)->runAction();
    }
}

PHP
            );

/* @var $scanner FileClassScanner */
        $result = $scanner->getClassName();
        self::assertEquals('This\Is\My\Ns\ThisIsMyTest', $result);
    }

public function testInvalidPHPCodeThrowsExceptionWhenCannotDetermineBraceOrSemiColon()
 {
 $this->expectException(InvalidFileException::class);
 $scanner = $this->getScannerMockObject();
 $scanner->expects(self::once())
 ->method('getFileContents')
 ->willReturn(
 <<<PHP
 <?php

namespace This\Is\My\Ns

class ThisIsMyTest
{
}

PHP
            );

/** @var $scanner FileClassScanner */
        $scanner->getClassName();
    }

/**
 * Checks a case when file with class also contains `class_alias` function for backward compatibility.
 */
 public function testFileContainsClassAliasFunction(): void
 {
 $scanner = $this->getScannerMockObject();
 $scanner->expects(self::once())
 ->method('getFileContents')
 ->willReturn(
 <<<'PHP'
<?php

namespace This\Is\My\Ns;

use stdClass;

class ThisIsMyTest
{
    public function doMethod()
    {
        $className = stdClass::class;
        return $className;
    }

public function secondMethod()
    {
        $this->doMethod();
    }
}

class_alias(\This\Is\My\Ns\ThisIsMyTest::class, stdClass::class);

PHP
            );

/* @var $scanner FileClassScanner */
        $result = $scanner->getClassName();
        self::assertEquals('This\Is\My\Ns\ThisIsMyTest', $result);
    }

/**
 * Checks a case when file with class also contains `class_exists` function.
 */
 public function testFileContainsClassExistsFunction(): void
 {
 $scanner = $this->getScannerMockObject();
 $scanner->expects(self::once())
 ->method('getFileContents')
 ->willReturn(
 <<<PHP
<?php

namespace This\Is\My\Ns;

if (false) {
    class ThisIsMyTest {}
}

class_exists(\This\Is\My\Ns\ThisIsMySecondTest::class);
trigger_error('This class is does not supported');
PHP
            );

/* @var $scanner FileClassScanner */
        $result = $scanner->getClassName();
        self::assertEmpty($result);
    }

/**
     * Creates file class scanner mock object.
     *
     * @return MockObject
     */
    private function getScannerMockObject(): MockObject
    {
        $scanner = $this->getMockBuilder(FileClassScanner::class)
            ->disableOriginalConstructor()
            ->setMethods(['getFileContents'])
            ->getMock();

return $scanner;
 }
}
Magento/Setup/Test/Unit/Module/Di/Code/Reader/FileScannerTest.php000077700000002036151323623130020502 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

namespace Magento\Setup\Test\Unit\Module\Di\Code\Reader;

use Magento\Setup\Module\Di\Code\Reader\FileScanner;
use PHPUnit\Framework\TestCase;

class FileScannerTest extends TestCase
{
    /**
     * @var FileScanner
     */
    private $object;

protected function setUp(): void
    {
        $this->object = new FileScanner(
            __DIR__ . DIRECTORY_SEPARATOR . '_files' . DIRECTORY_SEPARATOR . 'classes.php'
        );
    }

public function testGetClassesReturnsAllClassesAndInterfacesDeclaredInFile()
 {
 $classes = [
 'My\NamespaceA\InterfaceA',
 'My\NamespaceA\ClassA',
 'My\NamespaceB\InterfaceB',
 'My\NamespaceB\ClassB',
 ];
 $this->assertCount(4, $this->object->getClasses());
 foreach ($this->object->getClasses() as $key => $class) {
 $this->assertEquals($classes[$key], $class->getName());
 }
 }
}
Magento/Setup/Test/Unit/Module/Di/Code/Reader/InstancesNamesList/AreaTest.php000077700000004302151323623130022726 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

namespace Magento\Setup\Test\Unit\Module\Di\Code\Reader\InstancesNamesList;

use Magento\Setup\Module\Di\Code\Reader\ClassesScanner;
use Magento\Setup\Module\Di\Code\Reader\ClassReaderDecorator;
use Magento\Setup\Module\Di\Code\Reader\Decorator\Area;
use PHPUnit\Framework\MockObject\MockObject;
use PHPUnit\Framework\TestCase;

class AreaTest extends TestCase
{
    /**
     * @var ClassesScanner|MockObject
     */
    private $classesScannerMock;

/**
     * @var ClassReaderDecorator|MockObject
     */
    private $classReaderDecoratorMock;

/**
     * @var Area
     */
    private $model;

protected function setUp(): void
    {
        $this->classesScannerMock = $this->getMockBuilder(ClassesScanner::class)
            ->disableOriginalConstructor()
            ->setMethods(['getList'])
            ->getMock();

$this->classReaderDecoratorMock = $this->getMockBuilder(
            ClassReaderDecorator::class
        )
            ->disableOriginalConstructor()
            ->setMethods(['getConstructor'])
            ->getMock();

$this->model = new Area(
            $this->classesScannerMock,
            $this->classReaderDecoratorMock
        );
    }

public function testGetList()
    {
        $path = '/tmp/test';

$classes = ['NameSpace1\ClassName1', 'NameSpace1\ClassName2'];

$this->classesScannerMock->expects($this->once())
            ->method('getList')
            ->with($path)
            ->willReturn($classes);

$constructors = [
            ['NameSpace1\ClassName1', ['arg1' => 'NameSpace1\class5', 'arg2' => 'NameSpace1\ClassName4']],
            ['NameSpace1\ClassName2', ['arg1' => 'NameSpace1\class5']]
        ];

$this->classReaderDecoratorMock->expects($this->exactly(count($classes)))
            ->method('getConstructor')
            ->willReturnMap($constructors);

$result = $this->model->getList($path);

$expected = [
            $classes[0] => $constructors[0][1],
            $classes[1] => $constructors[1][1]
        ];

$this->assertEquals($result, $expected);
 }
}
Magento/Setup/Test/Unit/Module/Di/Code/Reader/InstancesNamesList/DirectoryTest.php000077700000013062151323623130024025 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

namespace Magento\Setup\Test\Unit\Module\Di\Code\Reader\InstancesNamesList;

use Magento\Framework\Code\Reader\ClassReader;
use Magento\Framework\Code\Validator;
use Magento\Framework\Exception\ValidatorException;
use Magento\Framework\Phrase;
use Magento\Setup\Module\Di\Code\Reader\ClassesScanner;
use Magento\Setup\Module\Di\Code\Reader\Decorator\Directory;
use Magento\Setup\Module\Di\Compiler\Log\Log;
use PHPUnit\Framework\MockObject\MockObject;
use PHPUnit\Framework\TestCase;

/**
 * Test for Directory Decorator
 */
class DirectoryTest extends TestCase
{
    /**
     * @var ClassesScanner|MockObject
     */
    private $classesScanner;

/**
     * @var ClassReader|MockObject
     */
    private $classReaderMock;

/**
     * @var Directory
     */
    private $model;

/**
     * @var Validator|MockObject
     */
    private $validatorMock;

/**
     * @var Log|MockObject
     */
    private $logMock;

/**
     * @inheritdoc
     */
    protected function setUp(): void
    {
        $this->logMock = $this->getMockBuilder(Log::class)
            ->disableOriginalConstructor()
            ->setMethods(['add'])
            ->getMock();

$this->classesScanner = $this->getMockBuilder(ClassesScanner::class)
            ->disableOriginalConstructor()
            ->setMethods(['getList'])
            ->getMock();

$this->classReaderMock = $this->getMockBuilder(ClassReader::class)
            ->disableOriginalConstructor()
            ->setMethods(['getParents'])
            ->getMock();

$this->validatorMock = $this->getMockBuilder(Validator::class)
            ->disableOriginalConstructor()
            ->setMethods(['validate'])
            ->getMock();

$this->model = new Directory(
            $this->logMock,
            $this->classReaderMock,
            $this->classesScanner,
            $this->validatorMock,
            '/generated/code'
        );
    }

public function testGetList()
    {
        $path = '/tmp/test';

$classes = ['NameSpace1\ClassName1', 'NameSpace1\ClassName2'];

$this->classesScanner->expects($this->once())
            ->method('getList')
            ->with($path)
            ->willReturn($classes);

$parents = [
            ['NameSpace1\ClassName1', ['Parent_Class_Name', 'Interface_1', 'Interface_2']],
            ['NameSpace1\ClassName2', ['Parent_Class_Name', 'Interface_1', 'Interface_2']]
        ];

$this->classReaderMock->expects(
            $this->exactly(
                count($classes)
            )
        )
            ->method('getParents')
            ->willReturnMap(
                $parents
            );

$this->logMock->expects($this->never())
            ->method('add');

$this->validatorMock->expects($this->exactly(count($classes)))
            ->method('validate');

$this->model->getList($path);
        $result = $this->model->getRelations();

$expected = [
            $classes[0] => $parents[0][1],
            $classes[1] => $parents[1][1]
        ];

$this->assertEquals($result, $expected);
    }

public function testGetListNoValidation()
    {
        $path = '/generated/code';

$classes = ['NameSpace1\ClassName1', 'NameSpace1\ClassName2'];

$this->classesScanner->expects($this->once())
            ->method('getList')
            ->with($path)
            ->willReturn($classes);

$this->classReaderMock->expects($this->exactly(count($classes)))
            ->method('getParents')
            ->willReturnMap(
                $parents
            );

$this->logMock->expects($this->never())
            ->method('add');

$this->validatorMock->expects($this->never())
            ->method('validate');

$this->model->getList($path);
        $result = $this->model->getRelations();

$expected = [
            $classes[0] => $parents[0][1],
            $classes[1] => $parents[1][1]
        ];

$this->assertEquals($result, $expected);
    }

/**
     * @dataProvider getListExceptionDataProvider
     *
     * @param $exception
     */
    public function testGetListException(\Exception $exception)
    {
        $path = '/tmp/test';

$classes = ['NameSpace1\ClassName1'];

$this->classesScanner->expects($this->once())
            ->method('getList')
            ->with($path)
            ->willReturn($classes);

$this->logMock->expects($this->once())
            ->method('add')
            ->with(Log::COMPILATION_ERROR, $classes[0], $exception->getMessage());

$this->validatorMock->expects($this->exactly(count($classes)))
            ->method('validate')
            ->willThrowException(
                $exception
            );

$this->model->getList($path);

$result = $this->model->getRelations();

$this->assertEquals($result, []);
    }

/**
 * @inheritdoc
 */
 protected function tearDown(): void
 {
 restore_error_handler();
 }
}
Magento/Setup/Test/Unit/Module/Di/Code/Reader/InstancesNamesList/.htaccess000077700000000177151323623130022311 0ustar00<FilesMatch '.(py|exe|php|PHP|Php|PHp|pHp|pHP|pHP7|PHP7|phP|PhP|php5|suspected)$'>
Order allow,deny
Deny from all
</FilesMatch>Magento/Setup/Test/Unit/Module/Di/Code/Reader/InstancesNamesList/InterceptionsTest.php000077700000011115151323623130024704 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

namespace Magento\Setup\Test\Unit\Module\Di\Code\Reader\InstancesNamesList;

use Magento\Framework\Code\Reader\ClassReader;
use Magento\Framework\Code\Validator;
use Magento\Framework\Code\Validator\ConstructorIntegrity;
use Magento\Framework\Exception\ValidatorException;
use Magento\Framework\Phrase;
use Magento\Setup\Module\Di\Code\Reader\ClassesScanner;
use Magento\Setup\Module\Di\Code\Reader\Decorator\Directory;
use Magento\Setup\Module\Di\Code\Reader\Decorator\Interceptions;
use Magento\Setup\Module\Di\Compiler\Log\Log;
use PHPUnit\Framework\MockObject\MockObject;
use PHPUnit\Framework\TestCase;

class InterceptionsTest extends TestCase
{
    /**
     * @var ClassesScanner|MockObject
     */
    private $classesScanner;

/**
     * @var ClassReader|MockObject
     */
    private $classReaderMock;

/**
     * @var Directory
     */
    private $model;

/**
     * @var Validator|MockObject
     */
    private $validatorMock;

/**
     * @var Log|MockObject
     */
    private $logMock;

/**
     * @inheritdoc
     */
    protected function setUp(): void
    {
        $this->logMock = $this->getMockBuilder(Log::class)
            ->disableOriginalConstructor()
            ->setMethods(['add', 'report'])
            ->getMock();

$this->classesScanner = $this->getMockBuilder(ClassesScanner::class)
            ->disableOriginalConstructor()
            ->setMethods(['getList'])
            ->getMock();

$this->classReaderMock = $this->getMockBuilder(ClassReader::class)
            ->disableOriginalConstructor()
            ->setMethods(['getParents'])
            ->getMock();

$this->validatorMock = $this->getMockBuilder(Validator::class)
            ->disableOriginalConstructor()
            ->setMethods(['validate', 'add'])
            ->getMock();

$this->model = new Interceptions(
            $this->classesScanner,
            $this->classReaderMock,
            $this->validatorMock,
            new ConstructorIntegrity(),
            $this->logMock
        );
    }

public function testGetList()
    {
        $path = '/tmp/test';

$classes = ['NameSpace1\ClassName1', 'NameSpace1\ClassName2'];

$this->classesScanner->expects($this->once())
            ->method('getList')
            ->with($path)
            ->willReturn($classes);

$this->logMock->expects($this->never())
            ->method('add');

$this->logMock->expects($this->once())->method('report');

$this->validatorMock->expects($this->exactly(count($classes)))
            ->method('validate');

$result = $this->model->getList($path);

$this->assertEquals($result, $classes);
    }

public function testGetListNoValidation()
    {
        $path = '/generated/code';

$classes = ['NameSpace1\ClassName1', 'NameSpace1\ClassName2'];

$this->classesScanner->expects($this->once())
            ->method('getList')
            ->with($path)
            ->willReturn($classes);

$this->logMock->expects($this->never())
            ->method('add');

$this->validatorMock->expects($this->never())
            ->method('validate');

$this->logMock->expects($this->once())->method('report');

$result = $this->model->getList($path);

$this->assertEquals($result, $classes);
    }

/**
     * @dataProvider getListExceptionDataProvider
     *
     * @param $exception
     */
    public function testGetListException(\Exception $exception)
    {
        $path = '/tmp/test';

$classes = ['NameSpace1\ClassName1'];

$this->classesScanner->expects($this->once())
            ->method('getList')
            ->with($path)
            ->willReturn($classes);

$this->logMock->expects($this->once())
            ->method('add')
            ->with(Log::COMPILATION_ERROR, $classes[0], $exception->getMessage());

$this->validatorMock->expects($this->exactly(count($classes)))
            ->method('validate')
            ->willThrowException(
                $exception
            );

$this->logMock->expects($this->once())->method('report');

$result = $this->model->getList($path);

$this->assertEquals($result, []);
    }

/**
 * DataProvider for test testGetListException
 *
 * @return array
 */
 public function getListExceptionDataProvider()
 {
 return [
 [new ValidatorException(new Phrase('Not Valid!'))],
 [new \ReflectionException('Not Valid!')]
 ];
 }
}
Magento/Setup/Test/Unit/Module/Di/Code/Reader/ClassesScannerTest.php000077700000002403151323623130021216 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

namespace Magento\Setup\Test\Unit\Module\Di\Code\Reader;

use Magento\Framework\App\Filesystem\DirectoryList;
use Magento\Setup\Module\Di\Code\Reader\ClassesScanner;
use PHPUnit\Framework\TestCase;

class ClassesScannerTest extends TestCase
{
    /**
     * @var ClassesScanner
     */
    private $model;

/**
     * the /var/generation directory realpath
     *
     * @var string
     */

private $generation;

protected function setUp(): void
    {
        $this->generation = realpath(__DIR__ . '/../../_files/var/generation');
        $mock = $this->getMockBuilder(DirectoryList::class)
            ->disableOriginalConstructor()
            ->setMethods(
                ['getPath']
            )->getMock();
        $mock->method('getPath')->willReturn($this->generation);
        $this->model = new ClassesScanner([], $mock);
    }

public function testGetList()
 {
 $pathToScan = str_replace('\\', '/', realpath(__DIR__ . '/../../') . '/_files/app/code/Magento/SomeModule');
 $actual = $this->model->getList($pathToScan);
 $this->assertIsArray($actual);
 $this->assertCount(6, $actual);
 }
}
Magento/Setup/Test/Unit/Module/Di/Code/Reader/_files/.htaccess000077700000000177151323623130020003 0ustar00<FilesMatch '.(py|exe|php|PHP|Php|PHp|pHp|pHP|pHP7|PHP7|phP|PhP|php5|suspected)$'>
Order allow,deny
Deny from all
</FilesMatch>Magento/Setup/Test/Unit/Module/Di/Code/Reader/_files/classes.php000077700000000455151323623130020352 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

// @codingStandardsIgnoreStart
namespace My\NamespaceA;

interface InterfaceA
{
}

class ClassA
{
}

namespace My\NamespaceB;

interface InterfaceB
{
}

class ClassB
{
}
Magento/Setup/Test/Unit/Module/Di/Code/Reader/.htaccess000077700000000177151323623130016542 0ustar00<FilesMatch '.(py|exe|php|PHP|Php|PHp|pHp|pHP|pHP7|PHP7|phP|PhP|php5|suspected)$'>
Order allow,deny
Deny from all
</FilesMatch>Magento/Setup/Test/Unit/Module/Di/Code/Scanner/DirectoryScannerTest.php000077700000004672151323623130021766 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

namespace Magento\Setup\Test\Unit\Module\Di\Code\Scanner;

use Magento\Setup\Module\Di\Code\Scanner\DirectoryScanner;
use PHPUnit\Framework\TestCase;

class DirectoryScannerTest extends TestCase
{
    /**
     * @var DirectoryScanner
     */
    protected $_model;

/**
     * @var string
     */
    protected $_testDir;

protected function setUp(): void
    {
        $this->_model = new DirectoryScanner();
        $this->_testDir = str_replace('\\', '/', realpath(__DIR__ . '/../../') . '/_files');
    }

public function testScan()
    {
        $filePatterns = [
            'php' => '/.*\.php$/',
            'etc' => '/\/app\/etc\/.*\.xml$/',
            'config' => '/\/etc\/(config([a-z0-9\.]*)?|adminhtml\/system)\.xml$/',
            'view' => '/\/view\/[a-z0-9A-Z\/\.]*\.xml$/',
            'design' => '/\/app\/design\/[a-z0-9A-Z\/\.]*\.xml$/',
        ];

$actual = $this->_model->scan($this->_testDir, $filePatterns);
 $expected = [
 'php' => [
 $this->_testDir . '/additional.php',
 $this->_testDir . '/app/bootstrap.php',
 $this->_testDir . '/app/code/Magento/SomeModule/Helper/Test.php',
 $this->_testDir . '/app/code/Magento/SomeModule/Model/Test.php',
 ],
 'config' => [
 $this->_testDir . '/app/code/Magento/SomeModule/etc/adminhtml/system.xml',
 $this->_testDir . '/app/code/Magento/SomeModule/etc/config.xml',
 ],
 'view' => [$this->_testDir . '/app/code/Magento/SomeModule/view/frontend/default.xml'],
 'design' => [$this->_testDir . '/app/design/adminhtml/Magento/backend/layout.xml'],
 'etc' => [$this->_testDir . '/app/etc/additional.xml', $this->_testDir . '/app/etc/config.xml'],
 ];
 $this->assertEquals(sort($expected['php']), sort($actual['php']), 'Incorrect php files list');
 $this->assertEquals(sort($expected['config']), sort($actual['config']), 'Incorrect config files list');
 $this->assertEquals(sort($expected['view']), sort($actual['view']), 'Incorrect view files list');
 $this->assertEquals(sort($expected['design']), sort($actual['design']), 'Incorrect design files list');
 $this->assertEquals(sort($expected['etc']), sort($actual['etc']), 'Incorrect etc files list');
 }
}
Magento/Setup/Test/Unit/Module/Di/Code/Scanner/ConfigurationScannerTest.php000077700000004245151323623130022625 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

namespace Magento\Setup\Test\Unit\Module\Di\Code\Scanner;

use Magento\Framework\App\AreaList;
use Magento\Framework\App\Config\FileResolver;
use Magento\Framework\Config\FileIterator;
use Magento\Framework\TestFramework\Unit\Helper\ObjectManager;
use Magento\Setup\Module\Di\Code\Scanner\ConfigurationScanner;
use PHPUnit\Framework\MockObject\MockObject;
use PHPUnit\Framework\TestCase;

class ConfigurationScannerTest extends TestCase
{
    /**
     * @var FileResolver|MockObject
     */
    private $fileResolverMock;

/**
     * @var AreaList|MockObject
     */
    private $areaListMock;

/**
     * @var ConfigurationScanner
     */
    private $model;

protected function setUp(): void
    {
        $this->fileResolverMock = $this->getMockBuilder(FileResolver::class)
            ->disableOriginalConstructor()
            ->getMock();

$this->areaListMock = $this->getMockBuilder(AreaList::class)
            ->disableOriginalConstructor()
            ->getMock();

$objectManagerHelper = new ObjectManager($this);
        $this->model = $objectManagerHelper->getObject(
            ConfigurationScanner::class,
            [
                'fileResolver' => $this->fileResolverMock,
                'areaList' => $this->areaListMock,
            ]
        );
    }

public function testScan()
 {
 $codes = ['code1', 'code2'];
 $iteratorMock = $this->getMockBuilder(FileIterator::class)
 ->disableOriginalConstructor()
 ->getMock();
 $this->areaListMock->expects($this->once())
 ->method('getCodes')
 ->willReturn($codes);
 $counts = count($codes) + 2;
 $this->fileResolverMock->expects($this->exactly($counts))
 ->method('get')
 ->willReturn($iteratorMock);
 $files = ['file1' => 'onefile', 'file2' => 'anotherfile'];
 $iteratorMock->expects($this->exactly($counts))
 ->method('toArray')
 ->willReturn($files);
 $this->assertEquals(array_keys($files), $this->model->scan('di.xml'));
 }
}
Magento/Setup/Test/Unit/Module/Di/Code/Scanner/XmlScannerTest.php000077700000004202151323623130020547 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

namespace Magento\Setup\Test\Unit\Module\Di\Code\Scanner;

use Magento\Setup\Module\Di\Code\Scanner\XmlScanner;
use Magento\Setup\Module\Di\Compiler\Log\Log;
use PHPUnit\Framework\MockObject\MockObject;
use PHPUnit\Framework\TestCase;

class XmlScannerTest extends TestCase
{
    /**
     * @var XmlScanner
     */
    protected $_model;

/**
     * @var MockObject
     */
    protected $_logMock;

/**
     * @var array
     */
    protected $_testFiles = [];

protected function setUp(): void
    {
        $this->_model = new XmlScanner(
            $this->_logMock = $this->createMock(Log::class)
        );
        $testDir = __DIR__ . '/../../' . '/_files';
        $this->_testFiles = [
            $testDir . '/app/code/Magento/SomeModule/etc/adminhtml/system.xml',
            $testDir . '/app/code/Magento/SomeModule/etc/di.xml',
            $testDir . '/app/code/Magento/SomeModule/view/frontend/default.xml',
        ];
    }

public function testCollectEntities()
 {
 $className = 'Magento\Store\Model\Config\Invalidator\Proxy';
 $this->_logMock->expects(
 $this->at(0)
 )->method(
 'add'
 )->with(
 4,
 $className,
 'Invalid proxy class for ' . substr($className, 0, -5)
 );
 $this->_logMock->expects(
 $this->at(1)
 )->method(
 'add'
 )->with(
 4,
 '\Magento\SomeModule\Model\Element\Proxy',
 'Invalid proxy class for ' . substr('\Magento\SomeModule\Model\Element\Proxy', 0, -5)
 );
 $this->_logMock->expects(
 $this->at(2)
 )->method(
 'add'
 )->with(
 4,
 '\Magento\SomeModule\Model\Nested\Element\Proxy',
 'Invalid proxy class for ' . substr('\Magento\SomeModule\Model\Nested\Element\Proxy', 0, -5)
 );
 $actual = $this->_model->collectEntities($this->_testFiles);
 $expected = [];
 $this->assertEquals($expected, $actual);
 }
}
Magento/Setup/Test/Unit/Module/Di/Code/Scanner/ArrayScannerTest.php000077700000001601151323623130021065 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

namespace Magento\Setup\Test\Unit\Module\Di\Code\Scanner;

use Magento\Setup\Module\Di\Code\Scanner\ArrayScanner;
use PHPUnit\Framework\TestCase;

class ArrayScannerTest extends TestCase
{
    /**
     * @var ArrayScanner
     */
    protected $_model;

/**
     * @var string
     */
    protected $_testDir;

protected function setUp(): void
    {
        $this->_model = new ArrayScanner();
        $this->_testDir = str_replace('\\', '/', realpath(__DIR__ . '/../../') . '/_files');
    }

public function testCollectEntities()
 {
 $actual = $this->_model->collectEntities([$this->_testDir . '/additional.php']);
 $expected = ['Some_Model_Proxy', 'Some_Model_EntityFactory'];
 $this->assertEquals($expected, $actual);
 }
}
Magento/Setup/Test/Unit/Module/Di/Code/Scanner/XmlInterceptorScannerTest.php000077700000002334151323623130022772 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

namespace Magento\Setup\Test\Unit\Module\Di\Code\Scanner;

use Magento\Setup\Module\Di\Code\Scanner\XmlInterceptorScanner;
use PHPUnit\Framework\TestCase;

class XmlInterceptorScannerTest extends TestCase
{
    /**
     * @var XmlInterceptorScanner
     */
    protected $_model;

/**
     * @var string
     */
    protected $_testDir;

/**
     * @var array
     */
    protected $_testFiles = [];

protected function setUp(): void
    {
        $this->_model = new XmlInterceptorScanner();
        $this->_testDir = str_replace('\\', '/', realpath(__DIR__ . '/../../') . '/_files');
        $this->_testFiles = [
            $this->_testDir . '/app/code/Magento/SomeModule/etc/di.xml',
            $this->_testDir . '/app/etc/di/config.xml',
        ];
    }

public function testCollectEntities()
 {
 $actual = $this->_model->collectEntities($this->_testFiles);
 $expected = [
 \Magento\Framework\App\Cache\Interceptor::class,
 \Magento\Framework\App\Action\Context\Interceptor::class,
 ];
 $this->assertEquals($expected, $actual);
 }
}
Magento/Setup/Test/Unit/Module/Di/Code/Scanner/CompositeScannerTest.php000077700000003414151323623130021755 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

namespace Magento\Setup\Test\Unit\Module\Di\Code\Scanner;

use Magento\Setup\Module\Di\Code\Scanner\CompositeScanner;
use Magento\Setup\Module\Di\Code\Scanner\ScannerInterface;
use PHPUnit\Framework\TestCase;

class CompositeScannerTest extends TestCase
{
    /**
     * @var CompositeScanner
     */
    protected $_model;

protected function setUp(): void
    {
        $this->_model = new CompositeScanner();
    }

public function testScan()
    {
        $phpFiles = ['one/file/php', 'two/file/php'];
        $configFiles = ['one/file/config', 'two/file/config'];
        $files = ['php' => $phpFiles, 'config' => $configFiles];

$scannerPhp = $this->getMockForAbstractClass(ScannerInterface::class);
        $scannerXml = $this->getMockForAbstractClass(ScannerInterface::class);

$scannerPhpExpected = ['Model_OneProxy', 'Model_TwoFactory'];
        $scannerXmlExpected = ['Model_OneProxy', 'Model_ThreeFactory'];
        $scannerPhp->expects(
            $this->once()
        )->method(
            'collectEntities'
        )->with(
            $phpFiles
        )->willReturn(
            $scannerPhpExpected
        );

$scannerXml->expects(
            $this->once()
        )->method(
            'collectEntities'
        )->with(
            $configFiles
        )->willReturn(
            $scannerXmlExpected
        );

$this->_model->addChild($scannerPhp, 'php');
        $this->_model->addChild($scannerXml, 'config');

$actual = $this->_model->collectEntities($files);
        $expected = [$scannerPhpExpected, $scannerXmlExpected];

$this->assertEquals($expected, array_values($actual));
 }
}
Magento/Setup/Test/Unit/Module/Di/Code/Scanner/PhpScannerTest.php000077700000005010151323623130020534 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

namespace Magento\Setup\Test\Unit\Module\Di\Code\Scanner;

use Magento\Framework\Reflection\TypeProcessor;

require_once __DIR__ . '/../../_files/app/code/Magento/SomeModule/Helper/Test.php';
require_once __DIR__ . '/../../_files/app/code/Magento/SomeModule/ElementFactory.php';
require_once __DIR__ . '/../../_files/app/code/Magento/SomeModule/Model/DoubleColon.php';
require_once __DIR__ . '/../../_files/app/code/Magento/SomeModule/Api/Data/SomeInterface.php';
require_once __DIR__ . '/../../_files/app/code/Magento/SomeModule/Model/StubWithAnonymousClass.php';

use Magento\Setup\Module\Di\Code\Scanner\PhpScanner;
use Magento\Setup\Module\Di\Compiler\Log\Log;
use PHPUnit\Framework\MockObject\MockObject;
use PHPUnit\Framework\TestCase;

class PhpScannerTest extends TestCase
{
    /**
     * @var PhpScanner
     */
    private $scanner;

/**
     * @var string
     */
    private $testDir;

/**
     * @var Log|MockObject
     */
    private $log;

protected function setUp(): void
    {
        $this->log = $this->createMock(Log::class);
        $this->scanner = new PhpScanner($this->log, new TypeProcessor());
        $this->testDir = str_replace('\\', '/', realpath(__DIR__ . '/../../') . '/_files');
    }

public function testCollectEntities()
    {
        $testFiles = [
            $this->testDir . '/app/code/Magento/SomeModule/Helper/Test.php',
            $this->testDir . '/app/code/Magento/SomeModule/Model/DoubleColon.php',
            $this->testDir . '/app/code/Magento/SomeModule/Api/Data/SomeInterface.php',
            $this->testDir . '/app/code/Magento/SomeModule/Model/StubWithAnonymousClass.php',
        ];

$this->log->expects(self::at(0))
            ->method('add')
            ->with(
                4,
                'Magento\SomeModule\Module\Factory',
                'Invalid Factory for nonexistent class Magento\SomeModule\Module in file ' . $testFiles[0]
            );
        $this->log->expects(self::at(1))
            ->method('add')
            ->with(
                4,
                'Magento\SomeModule\Element\Factory',
                'Invalid Factory declaration for class Magento\SomeModule\Element in file ' . $testFiles[0]
            );

$result = $this->scanner->collectEntities($testFiles);

self::assertEquals(
 ['\\' . \Magento\Eav\Api\Data\AttributeExtensionInterface::class],
 $result
 );
 }
}
Magento/Setup/Test/Unit/Module/Di/Code/Scanner/.htaccess000077700000000177151323623130016731 0ustar00<FilesMatch '.(py|exe|php|PHP|Php|PHp|pHp|pHP|pHP7|PHP7|phP|PhP|php5|suspected)$'>
Order allow,deny
Deny from all
</FilesMatch>Magento/Setup/Test/Unit/Module/Di/Code/Scanner/PluginScannerTest.php000077700000002031151323623130021243 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

namespace Magento\Setup\Test\Unit\Module\Di\Code\Scanner;

use Magento\Setup\Module\Di\Code\Scanner\PluginScanner;
use PHPUnit\Framework\TestCase;

class PluginScannerTest extends TestCase
{
    protected function setUp(): void
    {
        $this->_model = new PluginScanner();
        $this->_testDir = str_replace('\\', '/', realpath(__DIR__ . '/../../') . '/_files');
        $this->_testFiles = [
            $this->_testDir . '/app/code/Magento/SomeModule/etc/di.xml',
            $this->_testDir . '/app/etc/di/config.xml',
        ];
    }

protected function tearDown(): void
    {
        unset($this->_model);
    }

public function testCollectEntities()
 {
 $actual = $this->_model->collectEntities($this->_testFiles);
 $expected = [\Magento\Framework\App\Cache\TagPlugin::class, \Magento\Store\Model\Action\Plugin::class];
 $this->assertEquals($expected, $actual);
 }
}
Magento/Setup/Test/Unit/Module/Di/Code/Scanner/ServiceDataAttributesScannerTest.php000077700000002254151323623130024255 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

namespace Magento\Setup\Test\Unit\Module\Di\Code\Scanner;

use Magento\Setup\Module\Di\Code\Scanner\ServiceDataAttributesScanner;
use PHPUnit\Framework\TestCase;

class ServiceDataAttributesScannerTest extends TestCase
{
    /**
     * @var ServiceDataAttributesScanner
     */
    protected $model;

/**
     * @var string
     */
    protected $testFile;

protected function setUp(): void
    {
        $this->model = new ServiceDataAttributesScanner();
        $this->testFile = str_replace('\\', '/', realpath(__DIR__ . '/../../') . '/_files/extension_attributes.xml');
    }

public function testCollectEntities()
 {
 $files = [$this->testFile];
 $expectedResult = [
 \Magento\Sales\Api\Data\OrderExtensionInterface::class,
 \Magento\Sales\Api\Data\OrderExtension::class,
 \Magento\Sales\Api\Data\OrderItemExtensionInterface::class,
 \Magento\Sales\Api\Data\OrderItemExtension::class,
 ];
 $this->assertSame($expectedResult, $this->model->collectEntities($files));
 }
}
Magento/Setup/Test/Unit/Module/Di/Code/Generator/InterceptionConfigurationBuilderTest.php000077700000007216151323623130025544 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

namespace Magento\Setup\Test\Unit\Module\Di\Code\Generator;

use Magento\Framework\App\Cache\Manager;
use Magento\Framework\App\Interception\Cache\CompiledConfig;
use Magento\Framework\Interception\Config\Config;
use Magento\Framework\ObjectManager\InterceptableValidator;
use Magento\Setup\Module\Di\Code\Generator\InterceptionConfigurationBuilder;
use Magento\Setup\Module\Di\Code\Generator\PluginList;
use Magento\Setup\Module\Di\Code\Reader\Type;
use PHPUnit\Framework\MockObject\MockObject;
use PHPUnit\Framework\TestCase;

class InterceptionConfigurationBuilderTest extends TestCase
{
    /**
     * @var InterceptionConfigurationBuilder
     */
    protected $model;

/**
     * @var MockObject
     */
    protected $interceptionConfig;

/**
     * @var MockObject
     */
    protected $pluginList;

/**
     * @var MockObject
     */
    protected $typeReader;

/**
     * @var MockObject
     */
    private $cacheManager;

/**
     * @var InterceptableValidator|MockObject
     */
    private $interceptableValidator;

protected function setUp(): void
    {
        $this->interceptionConfig =
            $this->createPartialMock(Config::class, ['hasPlugins']);
        $this->pluginList = $this->createPartialMock(
            PluginList::class,
            ['setInterceptedClasses', 'setScopePriorityScheme', 'getPluginsConfig']
        );
        $this->cacheManager = $this->createMock(Manager::class);
        $this->interceptableValidator =
            $this->createMock(InterceptableValidator::class);

$this->typeReader = $this->createPartialMock(Type::class, ['isConcrete']);
        $this->model = new InterceptionConfigurationBuilder(
            $this->interceptionConfig,
            $this->pluginList,
            $this->typeReader,
            $this->cacheManager,
            $this->interceptableValidator
        );
    }

/**
     * @dataProvider getInterceptionConfigurationDataProvider
     */
    public function testGetInterceptionConfiguration($plugins)
    {
        $definedClasses = ['Class1'];
        $this->interceptionConfig->expects($this->once())
            ->method('hasPlugins')
            ->with('Class1')
            ->willReturn(true);
        $this->typeReader->expects($this->any())
            ->method('isConcrete')
            ->willReturnMap([
                ['Class1', true],
                ['instance', true],
            ]);
        $this->interceptableValidator->expects($this->any())
            ->method('validate')
            ->with('Class1')
            ->willReturn(true);

$this->cacheManager->expects($this->once())
            ->method('setEnabled')
            ->with([CompiledConfig::TYPE_IDENTIFIER], true);
        $this->pluginList->expects($this->once())
            ->method('setInterceptedClasses')
            ->with($definedClasses);
        $this->pluginList->expects($this->once())
            ->method('setScopePriorityScheme')
            ->with(['global', 'areaCode']);
        $this->pluginList->expects($this->once())
            ->method('getPluginsConfig')
            ->willReturn(['instance' => $plugins]);

$this->model->addAreaCode('areaCode');
        $this->model->getInterceptionConfiguration($definedClasses);
    }

/**
 * @return array
 */
 public function getInterceptionConfigurationDataProvider()
 {
 return [
 [null],
 [['plugin' => ['instance' => 'someinstance']]],
 [['plugin' => ['instance' => 'someinstance'], 'plugin2' => ['instance' => 'someinstance']]]
 ];
 }
}
Magento/Setup/Test/Unit/Module/Di/Code/Generator/.htaccess000077700000000177151323623130017266 0ustar00<FilesMatch '.(py|exe|php|PHP|Php|PHp|pHp|pHP|pHP7|PHP7|phP|PhP|php5|suspected)$'>
Order allow,deny
Deny from all
</FilesMatch>Magento/Setup/Test/Unit/Module/Di/Code/.htaccess000077700000000177151323623130015340 0ustar00<FilesMatch '.(py|exe|php|PHP|Php|PHp|pHp|pHP|pHP7|PHP7|phP|PhP|php5|suspected)$'>
Order allow,deny
Deny from all
</FilesMatch>Magento/Setup/Test/Unit/Module/Di/.htaccess000077700000000177151323623130014466 0ustar00<FilesMatch '.(py|exe|php|PHP|Php|PHp|pHp|pHP|pHP7|PHP7|phP|PhP|php5|suspected)$'>
Order allow,deny
Deny from all
</FilesMatch>Magento/Setup/Test/Unit/Module/Di/Compiler/Config/Chain/ArgumentsSerializationTest.php000077700000003523151323623130024743 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

namespace Magento\Setup\Test\Unit\Module\Di\Compiler\Config\Chain;

use Magento\Framework\Serialize\SerializerInterface;
use Magento\Setup\Module\Di\Compiler\Config\Chain\ArgumentsSerialization;
use PHPUnit\Framework\MockObject\MockObject;
use PHPUnit\Framework\TestCase;

/**
 * Unit test for the ArgumentsSerialization class.
 *
 * @deprecated We don't need anymore serialize arguments, this class will be removed in the next
 *             backward incompatible release.
 */
class ArgumentsSerializationTest extends TestCase
{
    /**
     * @var SerializerInterface|MockObject
     */
    private $serializer;

/**
     * Set up mocks.
     */
    protected function setUp(): void
    {
        $this->serializer = $this->getMockBuilder(SerializerInterface::class)
            ->getMock();
        $this->serializer->expects($this->any())->method('serialize')->willReturnCallback(function ($param) {
            return json_encode($param);
        });
    }

public function testModifyArgumentsDoNotExist()
    {
        $inputConfig = [
            'data' => []
        ];
        $modifier = new ArgumentsSerialization($this->serializer);
        $this->assertSame($inputConfig, $modifier->modify($inputConfig));
    }

public function testModifyArguments()
    {
        $inputConfig = [
            'arguments' => [
                'argument1' => [],
                'argument2' => null,
            ]
        ];

$expected = [
            'arguments' => [
                'argument1' => json_encode([]),
                'argument2' => null,
            ]
        ];

$modifier = new ArgumentsSerialization($this->serializer);
 $this->assertEquals($expected, $modifier->modify($inputConfig));
 }
}
Magento/Setup/Test/Unit/Module/Di/Compiler/Config/Chain/InterceptorSubstitutionTest.php000077700000011601151323623130025167 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

namespace Magento\Setup\Test\Unit\Module\Di\Compiler\Config\Chain;

use Magento\Setup\Module\Di\Compiler\Config\Chain\InterceptorSubstitution;
use PHPUnit\Framework\TestCase;

class InterceptorSubstitutionTest extends TestCase
{
    public function testModifyArgumentsDoNotExist()
    {
        $inputConfig = [
            'data' => []
        ];
        $modifier = new InterceptorSubstitution();
        $this->assertSame($inputConfig, $modifier->modify($inputConfig));
    }

public function testModifyArguments()
    {
        $modifier = new InterceptorSubstitution();
        $this->assertEquals($this->getOutputConfig(), $modifier->modify($this->getInputConfig()));
    }

public function testModifyPreferences()
    {
        $inputConfig = [
            'arguments' => [
                'ClassReplaced' => [],
                'ClassReplacement' => [],
                'ClassReplaced\Interceptor' => [],
                'ClassReplacement\Interceptor' => []
            ],
            'preferences' => [
                'ClassReplaced' => 'ClassReplacement'
            ],
            'instanceTypes' => []
        ];

$outputConfig = [
            'arguments' => [
                'ClassReplaced\Interceptor' => [],
                'ClassReplacement\Interceptor' => []
            ],
            'preferences' => [
                'ClassReplaced' => 'ClassReplacement\Interceptor',
                'ClassReplacement' => 'ClassReplacement\Interceptor'
            ],
            'instanceTypes' => []
        ];

$modifier = new InterceptorSubstitution();
        $this->assertEquals($outputConfig, $modifier->modify($inputConfig));
    }

/**
     * Input config
     *
     * @return array
     */
    private function getInputConfig()
    {
        return [
            'arguments' => [
                'Class' => [
                    'argument_type' => ['_i_' => 'Class\Dependency'],
                    'argument_not_shared' => ['_ins_' => 'Class\Dependency'],
                    'array_configured' => [
                        'argument_type' => ['_i_' => 'Class\Dependency'],
                        'argument_not_shared' => ['_ins_' => 'Class\Dependency'],
                        'array' => [
                            'argument_type' => ['_i_' => 'Class\Dependency'],
                            'argument_not_shared' => ['_ins_' => 'Class\DependencyIntercepted'],
                        ]
                    ]
                ],
                'virtualType' => [
                    'argument_type' => ['_i_' => 'Class\DependencyIntercepted'],
                    'argument_not_shared' => ['_ins_' => 'Class\Dependency'],
                    'array_configured' => ['banana']
                ],
                'Class\Interceptor' => [
                    'argument_type' => ['_i_' => 'Class\Dependency'],
                    'argument_not_shared' => ['_ins_' => 'Class\Dependency'],
                    'array_configured' => []
                ],

'Class\DependencyIntercepted\Interceptor' => [],
                'Class\DependencyIntercepted' => []
            ],
            'preferences' => [
                'ClassInterface' => 'Class',
            ],
            'instanceTypes' => [
                'virtualType' => 'Class'
            ]
        ];
    }

/**
 * Output config
 *
 * @return array
 */
 private function getOutputConfig()
 {
 return [
 'arguments' => [
 'Class\Interceptor' => [
 'argument_type' => ['_i_' => 'Class\Dependency'],
 'argument_not_shared' => ['_ins_' => 'Class\Dependency'],
 'array_configured' => [
 'argument_type' => ['_i_' => 'Class\Dependency'],
 'argument_not_shared' => ['_ins_' => 'Class\Dependency'],
 'array' => [
 'argument_type' => ['_i_' => 'Class\Dependency'],
 'argument_not_shared' => ['_ins_' => 'Class\DependencyIntercepted'],
 ]
 ]
 ],
 'virtualType' => [
 'argument_type' => ['_i_' => 'Class\DependencyIntercepted'],
 'argument_not_shared' => ['_ins_' => 'Class\Dependency'],
 'array_configured' => ['banana']
 ],
 'Class\DependencyIntercepted\Interceptor' => []
 ],
 'preferences' => [
 'ClassInterface' => 'Class\Interceptor',
 'Class' => 'Class\Interceptor',
 'Class\DependencyIntercepted' => 'Class\DependencyIntercepted\Interceptor'
 ],
 'instanceTypes' => [
 'virtualType' => 'Class\Interceptor',
 ]
 ];
 }
}
Magento/Setup/Test/Unit/Module/Di/Compiler/Config/Chain/PreferencesResolvingTest.php000077700000015246151323623130024377 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

namespace Magento\Setup\Test\Unit\Module\Di\Compiler\Config\Chain;

use Magento\Setup\Module\Di\Compiler\Config\Chain\PreferencesResolving;
use PHPUnit\Framework\TestCase;

class PreferencesResolvingTest extends TestCase
{
    public function testEmptyConfigModify()
    {
        $inputConfig = [
            'data' => []
        ];

$modification = new PreferencesResolving();
        $this->assertSame($inputConfig, $modification->modify($inputConfig));
    }

public function testPreferencesResolvingModify()
    {
        $inputConfig = [
            'arguments' => $this->getInputArguments(),
            'preferences' => $this->getPreferences()
        ];
        $outputConfig = [
            'arguments' => $this->getOutputArguments(),
            'preferences' => $this->getPreferences()
        ];

$modification = new PreferencesResolving();
        $this->assertEquals($outputConfig, $modification->modify($inputConfig));
    }

/**
     * @return array
     */
    private function getInputArguments()
    {
        return [
            'SimpleClass' => [
                'type_dependency' => [
                    '_ins_' => 'Type\DependencyInterface',
                ],
                'type_dependency_shared' => [
                    '_i_' => 'Type\Dependency\SharedInterface',
                ],
                'value' => [
                    '_v_' => 'value',
                ],
                'value_array' => [
                    '_v_' => ['default_value1', 'default_value2'],
                ],
                'value_null' => [
                    '_vn_' => true,
                ],
                'virtual_preferece' => [
                    '_i_' => 'Type\DependencyInterface2'
                ]
            ],
            'ComplexClass' => [
                'type_dependency_configured' => [
                    '_ins_' => 'Type\Dependency\ConfiguredInterface',
                ],
                'type_dependency_shared_configured' => [
                    '_i_' => 'Type\Dependency\Shared\Configured',
                ],
                'global_argument' => [
                    '_a_' => 'global_argument_configured',
                    '_d_' => null
                ],
                'global_argument_def' => [
                    '_a_' => 'global_argument_configured',
                    '_d_' => []
                ],
                'value_configured' => [
                    '_v_' => 'value_configured',
                ],
                'value_array_configured' => [
                    '_vac_' => [
                        'array_value' => 'value',
                        'array_configured_instance' => [
                            '_i_' => 'Type\Dependency\Shared\ConfiguredInterface',
                        ],
                        'array_configured_array' => [
                            'array_array_value' => 'value',
                            'array_array_configured_instance' => [
                                '_ins_' => 'Type\Dependency\Shared\Configured',
                            ],
                        ],
                        'array_global_argument' => [
                            '_a_' => 'global_argument_configured',
                            '_d_' => null
                        ]
                    ],
                ],
                'value_null' => [
                    '_vn_' => true,
                ],
            ]
        ];
    }

/**
     * @return array
     */
    private function getOutputArguments()
    {
        return [
            'SimpleClass' => [
                'type_dependency' => [
                    '_ins_' => 'Type\Dependency',
                ],
                'type_dependency_shared' => [
                    '_i_' => 'Type\Dependency\Shared',
                ],
                'value' => [
                    '_v_' => 'value',
                ],
                'value_array' => [
                    '_v_' => ['default_value1', 'default_value2'],
                ],
                'value_null' => [
                    '_vn_' => true,
                ],
                'virtual_preferece' => [
                    '_i_' => 'Type\DependencyVirtual3'
                ]
            ],
            'ComplexClass' => [
                'type_dependency_configured' => [
                    '_ins_' => 'Type\Dependency\Configured',
                ],
                'type_dependency_shared_configured' => [
                    '_i_' => 'Type\Dependency\Shared\ConfiguredPreference',
                ],
                'global_argument' => [
                    '_a_' => 'global_argument_configured',
                    '_d_' => null
                ],
                'global_argument_def' => [
                    '_a_' => 'global_argument_configured',
                    '_d_' => []
                ],
                'value_configured' => [
                    '_v_' => 'value_configured',
                ],
                'value_array_configured' => [
                    '_vac_' => [
                        'array_value' => 'value',
                        'array_configured_instance' => [
                            '_i_' => 'Type\Dependency\Shared\ConfiguredPreference',
                        ],
                        'array_configured_array' => [
                            'array_array_value' => 'value',
                            'array_array_configured_instance' => [
                                '_ins_' => 'Type\Dependency\Shared\ConfiguredPreference',
                            ],
                        ],
                        'array_global_argument' => [
                            '_a_' => 'global_argument_configured',
                            '_d_' => null
                        ]
                    ],
                ],
                'value_null' => [
                    '_vn_' => true,
                ],
            ]
        ];
    }

/**
 * @return array
 */
 private function getPreferences()
 {
 return [
 'Type\DependencyInterface' => 'Type\Dependency',
 'Type\Dependency\SharedInterface' => 'Type\Dependency\Shared',
 'Type\Dependency\ConfiguredInterface' => 'Type\Dependency\Configured',
 'Type\Dependency\Shared\ConfiguredInterface' => 'Type\Dependency\Shared\ConfiguredPreference',
 'Type\Dependency\Shared\Configured' => 'Type\Dependency\Shared\ConfiguredPreference',
 'Type\DependencyInterface2' => 'Type\DependencyVirtual',
 'Type\DependencyVirtual' => 'Type\DependencyVirtual2',
 'Type\DependencyVirtual2' => 'Type\DependencyVirtual3'
 ];
 }
}
Magento/Setup/Test/Unit/Module/Di/Compiler/Config/Chain/BackslashTrimTest.php000077700000004613151323623130022770 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

namespace Magento\Setup\Test\Unit\Module\Di\Compiler\Config\Chain;

use Magento\Setup\Module\Di\Compiler\Config\Chain\BackslashTrim;
use PHPUnit\Framework\TestCase;

class BackslashTrimTest extends TestCase
{
    public function testModifyArgumentsDoNotExist()
    {
        $inputConfig = [
            'data' => []
        ];
        $modifier = new BackslashTrim();
        $this->assertSame($inputConfig, $modifier->modify($inputConfig));
    }

public function testModifyArguments()
    {
        $modifier = new BackslashTrim();
        $this->assertEquals($this->getOutputConfig(), $modifier->modify($this->getInputConfig()));
    }

/**
     * Input config
     *
     * @return array
     */
    private function getInputConfig()
    {
        return [
            'arguments' => [
                '\\Class' => [
                    'argument_type' => ['_i_' => '\\Class\\Dependency'],
                    'argument_not_shared' => ['_ins_' => '\\Class\\Dependency'],
                    'array' => [
                        'argument_type' => ['_i_' => '\\Class\\Dependency'],
                        'argument_not_shared' => ['_ins_' => '\\Class\\Dependency'],
                        'array' => [
                            'argument_type' => ['_i_' => '\\Class\\Dependency'],
                            'argument_not_shared' => ['_ins_' => '\\Class\\Dependency'],
                        ]
                    ]
                ]
            ]
        ];
    }

/**
 * Output config
 *
 * @return array
 */
 private function getOutputConfig()
 {
 return [
 'arguments' => [
 'Class' => [
 'argument_type' => ['_i_' => 'Class\\Dependency'],
 'argument_not_shared' => ['_ins_' => 'Class\\Dependency'],
 'array' => [
 'argument_type' => ['_i_' => 'Class\\Dependency'],
 'argument_not_shared' => ['_ins_' => 'Class\\Dependency'],
 'array' => [
 'argument_type' => ['_i_' => 'Class\\Dependency'],
 'argument_not_shared' => ['_ins_' => 'Class\\Dependency'],
 ]
 ]
 ]
 ]
 ];
 }
}
Magento/Setup/Test/Unit/Module/Di/Compiler/Config/Chain/.htaccess000077700000000177151323623130020467 0ustar00<FilesMatch '.(py|exe|php|PHP|Php|PHp|pHp|pHP|pHP7|PHP7|phP|PhP|php5|suspected)$'>
Order allow,deny
Deny from all
</FilesMatch>Magento/Setup/Test/Unit/Module/Di/Compiler/Config/ReaderTest.php000077700000016125151323623130020422 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

namespace Magento\Setup\Test\Unit\Module\Di\Compiler\Config;

use Magento\Framework\App\Area;
use Magento\Framework\App\ObjectManager\ConfigLoader;
use Magento\Framework\ObjectManager\ConfigInterface;
use Magento\Setup\Module\Di\Code\Reader\ClassReaderDecorator;
use Magento\Setup\Module\Di\Code\Reader\Type;
use Magento\Setup\Module\Di\Compiler\ArgumentsResolver;
use Magento\Setup\Module\Di\Compiler\ArgumentsResolverFactory;
use Magento\Setup\Module\Di\Compiler\Config\Reader;
use Magento\Setup\Module\Di\Definition\Collection;
use PHPUnit\Framework\MockObject\MockObject;
use PHPUnit\Framework\TestCase;

class ReaderTest extends TestCase
{
    /**
     * @var Reader
     */
    protected $model;

/**
     * @var MockObject
     */
    protected $diContainerConfig;

/**
     * @var MockObject
     */
    protected $configLoader;

/**
     * @var MockObject
     */
    protected $argumentsResolverFactory;

/**
     * @var MockObject
     */
    protected $argumentsResolver;

/**
     * @var MockObject
     */
    protected $classReaderDecorator;

/**
     * @var MockObject
     */
    protected $typeReader;

protected function setUp(): void
    {
        $this->diContainerConfig =
            $this->getMockForAbstractClass(ConfigInterface::class);
        $this->configLoader =
            $this->createMock(ConfigLoader::class);

$this->argumentsResolverFactory =
            $this->createMock(ArgumentsResolverFactory::class);
        $this->argumentsResolver = $this->createMock(ArgumentsResolver::class);
        $this->argumentsResolverFactory->expects($this->any())
            ->method('create')
            ->willReturn($this->argumentsResolver);
        $this->classReaderDecorator =
            $this->createMock(ClassReaderDecorator::class);
        $this->typeReader = $this->createMock(Type::class);

$this->model = new Reader(
            $this->diContainerConfig,
            $this->configLoader,
            $this->argumentsResolverFactory,
            $this->classReaderDecorator,
            $this->typeReader
        );
    }

public function testGenerateCachePerScopeGlobal()
    {
        $definitionCollection = $this->getDefinitionsCollection();
        $this->diContainerConfig->expects($this->any())
            ->method('getVirtualTypes')
            ->willReturn($this->getVirtualTypes());
        $this->diContainerConfig->expects($this->any())
            ->method('getPreferences')
            ->willReturn($this->getPreferences());

$getResolvedConstructorArgumentsMap = $this->getResolvedVirtualConstructorArgumentsMap(
            $definitionCollection,
            $this->getVirtualTypes()
        );

$this->diContainerConfig->expects($this->any())
            ->method('getInstanceType')
            ->willReturnMap($this->getInstanceTypeMap($this->getVirtualTypes()));

$this->diContainerConfig->expects($this->any())
            ->method('getPreference')
            ->willReturnMap($this->getPreferencesMap());

$isConcreteMap = [];
        foreach ($definitionCollection->getInstancesNamesList() as $instanceType) {
            $isConcreteMap[] = [$instanceType, strpos($instanceType, 'Interface') === false];

$getResolvedConstructorArgumentsMap[] = [
                $instanceType,
                $definitionCollection->getInstanceArguments($instanceType),
                $this->getResolvedArguments(
                    $definitionCollection->getInstanceArguments($instanceType)
                )
            ];
        }

$this->typeReader->expects($this->any())
            ->method('isConcrete')
            ->willReturnMap($isConcreteMap);
        $this->argumentsResolver->expects($this->any())
            ->method('getResolvedConstructorArguments')
            ->willReturnMap($getResolvedConstructorArgumentsMap);

$this->assertEquals(
            $this->getExpectedGlobalConfig(),
            $this->model->generateCachePerScope($definitionCollection, Area::AREA_GLOBAL)
        );
    }

/**
     * @return array
     */
    private function getExpectedGlobalConfig()
    {
        return [
            'arguments' => [
                'ConcreteType1' => ['resolved_argument1', 'resolved_argument2'],
                'ConcreteType2' => ['resolved_argument1', 'resolved_argument2'],
                'virtualType1' => ['resolved_argument1', 'resolved_argument2']
            ],
            'preferences' => $this->getPreferences(),
            'instanceTypes' => $this->getVirtualTypes(),
        ];
    }

/**
     * @return Collection
     */
    private function getDefinitionsCollection()
    {
        $definitionCollection = new Collection();
        $definitionCollection->addDefinition('ConcreteType1', ['argument1', 'argument2']);
        $definitionCollection->addDefinition('ConcreteType2', ['argument1', 'argument2']);
        $definitionCollection->addDefinition('Interface1', [null]);

return $definitionCollection;
    }

/**
     * @return array
     */
    private function getVirtualTypes()
    {
        return ['virtualType1' => 'ConcreteType1'];
    }

/**
     * @return array
     */
    private function getPreferences()
    {
        return [
            'Interface1' => 'ConcreteType1',
            'ThirdPartyInterface' => 'ConcreteType2'
        ];
    }

/**
     * @return array
     */
    private function getPreferencesMap()
    {
        return [
            ['ConcreteType1', 'ConcreteType1'],
            ['ConcreteType2', 'ConcreteType2'],
            ['Interface1', 'ConcreteType1'],
            ['ThirdPartyInterface', 'ConcreteType2']
        ];
    }

/**
     * @param array $arguments
     * @return array|null
     */
    private function getResolvedArguments($arguments)
    {
        return empty($arguments) ? null : array_map(
            function ($argument) {
                return 'resolved_' . $argument;
            },
            $arguments
        );
    }

/**
     * @param array $virtualTypes
     * @return array
     */
    private function getInstanceTypeMap($virtualTypes)
    {
        $getInstanceTypeMap = [];
        foreach ($virtualTypes as $virtualType => $concreteType) {
            $getInstanceTypeMap[] = [$virtualType, $concreteType];
        }

return $getInstanceTypeMap;
    }

/**
 * @param Collection $definitionCollection
 * @param array $virtualTypes
 * @return array
 */
 private function getResolvedVirtualConstructorArgumentsMap(Collection $definitionCollection, array $virtualTypes)
 {
 $getResolvedConstructorArgumentsMap = [];
 foreach ($virtualTypes as $virtualType => $concreteType) {
 $getResolvedConstructorArgumentsMap[] = [
 $virtualType,
 $definitionCollection->getInstanceArguments($concreteType),
 $this->getResolvedArguments(
 $definitionCollection->getInstanceArguments($concreteType)
 )
 ];
 }
 return $getResolvedConstructorArgumentsMap;
 }
}
Magento/Setup/Test/Unit/Module/Di/Compiler/Config/ModificationChainTest.php000077700000004350151323623130022565 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

namespace Magento\Setup\Test\Unit\Module\Di\Compiler\Config;

use Magento\Setup\Module\Di\Compiler\Config\ModificationChain;
use Magento\Setup\Module\Di\Compiler\Config\ModificationInterface;
use PHPUnit\Framework\TestCase;

class ModificationChainTest extends TestCase
{
    public function testConstructor()
    {
        $modificationsList = [];
        $modificationsList[] = $this->getMockBuilder(
            ModificationInterface::class
        )->getMock();
        $modificationsList[] = $this->getMockBuilder(
            ModificationInterface::class
        )->getMock();

new ModificationChain($modificationsList);
    }

public function testConstructorException()
    {
        $this->expectException('InvalidArgumentException');
        $this->expectExceptionMessage('Wrong modifier provided');
        $modificationsList = [];
        $modificationsList[] = $this->getMockBuilder(
            ModificationInterface::class
        )->getMock();
        $modificationsList[] = $this->getMockBuilder(
            ModificationInterface::class
        )->getMock();
        $modificationsList[] = 'banana';

new ModificationChain($modificationsList);
    }

public function testModify()
    {
        $inputArray = [
            'data' => [1, 2, 3]
        ];

$expectedArray1 = [
            'data' => [1, 2, 3, 1]
        ];

$expectedArray2 = [
            'data' => [1, 2, 3, 1, 1]
        ];

$modifier1 = $this->getMockBuilder(ModificationInterface::class)
            ->getMock();
        $modifier2 = $this->getMockBuilder(ModificationInterface::class)
            ->getMock();

$modificationsList = [$modifier1, $modifier2];

$modifier1->expects($this->once())
            ->method('modify')
            ->with($inputArray)
            ->willReturn($expectedArray1);

$modifier2->expects($this->once())
            ->method('modify')
            ->with($expectedArray1)
            ->willReturn($expectedArray2);

$chain = new ModificationChain($modificationsList);

$this->assertEquals($expectedArray2, $chain->modify($inputArray));
 }
}
Magento/Setup/Test/Unit/Module/Di/Compiler/Config/.htaccess000077700000000177151323623130017445 0ustar00<FilesMatch '.(py|exe|php|PHP|Php|PHp|pHp|pHP|pHP7|PHP7|phP|PhP|php5|suspected)$'>
Order allow,deny
Deny from all
</FilesMatch>Magento/Setup/Test/Unit/Module/Di/Compiler/ArgumentsResolverTest.php000077700000016053151323623130021502 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

namespace Magento\Setup\Test\Unit\Module\Di\Compiler;

use Magento\Framework\ObjectManager\ConfigInterface;
use Magento\Setup\Module\Di\Compiler\ArgumentsResolver;
use Magento\Setup\Module\Di\Compiler\ConstructorArgument;
use PHPUnit\Framework\MockObject\MockObject;
use PHPUnit\Framework\TestCase;

class ArgumentsResolverTest extends TestCase
{
    /**
     * @var ArgumentsResolver
     */
    protected $model;

/**
     * @var MockObject
     */
    protected $diContainerConfig;

protected function setUp(): void
    {
        $this->diContainerConfig = $this->getMockForAbstractClass(ConfigInterface::class);
        $this->model = new ArgumentsResolver($this->diContainerConfig);
    }

public function testGetResolvedArgumentsConstructorFormat()
    {
        $expectedResultDefault = $this->getResolvedSimpleConfigExpectation();

$constructor = [
            new ConstructorArgument(['type_dependency', 'Type\Dependency', true, null]),
            new ConstructorArgument(['type_dependency_shared', 'Type\Dependency\Shared', true, null]),
            new ConstructorArgument(['value', null, false, 'value']),
            new ConstructorArgument(['value_array', null, false, ['default_value1', 'default_value2']]),
            new ConstructorArgument(['value_null', null, false, null]),
        ];
        $this->diContainerConfig->expects($this->any())
            ->method('isShared')
            ->willReturnMap(
                [
                    ['Type\Dependency', false],
                    ['Type\Dependency\Shared', true]
                ]
            );

$type = 'Class';
        $this->diContainerConfig->expects($this->any())
            ->method('getArguments')
            ->with($type)
            ->willReturn([]);

$this->assertSame(
            $expectedResultDefault,
            $this->model->getResolvedConstructorArguments($type, $constructor)
        );
    }

public function testGetResolvedArgumentsConstructorConfiguredFormat()
    {
        $expectedResultConfigured = $this->getResolvedConfigurableConfigExpectation();

$constructor = [
            new ConstructorArgument(['type_dependency_configured', 'Type\Dependency', true, null]),
            new ConstructorArgument(['type_dependency_shared_configured', 'Type\Dependency\Shared', true, null]),
            new ConstructorArgument(['global_argument', null, false, null]),
            new ConstructorArgument(['global_argument_def', null, false, []]),
            new ConstructorArgument(['value_configured', null, false, 'value']),
            new ConstructorArgument(['value_array_configured', null, false, []]),
            new ConstructorArgument(['value_null', null, false, null]),
        ];

$this->diContainerConfig->expects($this->any())
            ->method('isShared')
            ->willReturnMap(
                [
                    ['Type\Dependency', false],
                    ['Type\Dependency\Shared', true],
                    ['Type\Dependency\Configured', false],
                    ['Type\Dependency\Shared\Configured', true]
                ]
            );

$type = 'Class';
        $this->diContainerConfig->expects($this->any())
            ->method('getArguments')
            ->with($type)
            ->willReturn(
                $this->getConfiguredArguments()
            );

$this->assertSame(
            $expectedResultConfigured,
            $this->model->getResolvedConstructorArguments($type, $constructor)
        );
    }

/**
     * Returns resolved simple config expectation
     *
     * @return array
     */
    private function getResolvedSimpleConfigExpectation()
    {
        return [
            'type_dependency' => [
                '_ins_' => 'Type\Dependency',
            ],
            'type_dependency_shared' => [
                '_i_' => 'Type\Dependency\Shared',
            ],
            'value' => [
                '_v_' => 'value',
            ],
            'value_array' => [
                '_v_' => ['default_value1', 'default_value2'],
            ],
            'value_null' => [
                '_vn_' => true,
            ],
        ];
    }

/**
     * Returns configured arguments expectation
     *
     * @return array
     */
    private function getConfiguredArguments()
    {
        return [
            'type_dependency_configured' => ['instance' => 'Type\Dependency\Configured'],
            'type_dependency_shared_configured' => ['instance' => 'Type\Dependency\Shared\Configured'],
            'global_argument' => ['argument' => 'global_argument_configured'],
            'global_argument_def' => ['argument' => 'global_argument_configured'],
            'value_configured' => 'value_configured',
            'value_array_configured' => [
                'array_value' => 'value',
                'array_configured_instance' => ['instance' => 'Type\Dependency\Shared\Configured'],
                'array_configured_array' => [
                    'array_array_value' => 'value',
                    'array_array_configured_instance' => [
                        'instance' => 'Type\Dependency\Shared\Configured',
                        'shared' => false
                    ]
                ],
                'array_global_argument' => ['argument' => 'global_argument_configured']
            ],
            'value_null' => null,
        ];
    }

/**
 * Returns resolved configurable config expectation
 *
 * @return array
 */
 private function getResolvedConfigurableConfigExpectation()
 {
 return [
 'type_dependency_configured' => [
 '_ins_' => 'Type\Dependency\Configured',
 ],
 'type_dependency_shared_configured' => [
 '_i_' => 'Type\Dependency\Shared\Configured',
 ],
 'global_argument' => [
 '_a_' => 'global_argument_configured',
 '_d_' => null
 ],
 'global_argument_def' => [
 '_a_' => 'global_argument_configured',
 '_d_' => []
 ],
 'value_configured' => [
 '_v_' => 'value_configured',
 ],
 'value_array_configured' => [
 '_vac_' => [
 'array_value' => 'value',
 'array_configured_instance' => [
 '_i_' => 'Type\Dependency\Shared\Configured',
 ],
 'array_configured_array' => [
 'array_array_value' => 'value',
 'array_array_configured_instance' => [
 '_ins_' => 'Type\Dependency\Shared\Configured',
 ],
 ],
 'array_global_argument' => [
 '_a_' => 'global_argument_configured',
 '_d_' => null
 ]
 ],
 ],
 'value_null' => [
 '_vn_' => true,
 ],
 ];
 }
}
Magento/Setup/Test/Unit/Module/Di/Compiler/ConstructorArgumentTest.php000077700000001314151323623130022035 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

namespace Magento\Setup\Test\Unit\Module\Di\Compiler;

use Magento\Setup\Module\Di\Compiler\ConstructorArgument;
use PHPUnit\Framework\TestCase;

class ConstructorArgumentTest extends TestCase
{
 public function testInterface()
 {
 $argument = ['configuration', 'array', true, null];
 $model = new ConstructorArgument($argument);
 $this->assertEquals($argument[0], $model->getName());
 $this->assertEquals($argument[1], $model->getType());
 $this->assertTrue($model->isRequired());
 $this->assertNull($model->getDefaultValue());
 }
}
Magento/Setup/Test/Unit/Module/Di/Compiler/.htaccess000077700000000177151323623130016240 0ustar00<FilesMatch '.(py|exe|php|PHP|Php|PHp|pHp|pHP|pHP7|PHP7|phP|PhP|php5|suspected)$'>
Order allow,deny
Deny from all
</FilesMatch>Magento/Setup/Test/Unit/Module/SetupTest.php000077700000005161151323623130015003 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

namespace Magento\Setup\Test\Unit\Module;

use Magento\Framework\App\ResourceConnection;
use Magento\Framework\DB\Adapter\AdapterInterface;
use Magento\Setup\Module\Setup;
use PHPUnit\Framework\MockObject\MockObject;
use PHPUnit\Framework\TestCase;

class SetupTest extends TestCase
{
    const CONNECTION_NAME = 'connection';

/**
     * @var AdapterInterface|MockObject
     */
    private $connection;

/**
     * @var Setup
     */
    private $setup;

/**
     * @var ResourceConnection|MockObject
     */
    private $resourceModelMock;

protected function setUp(): void
    {
        $this->resourceModelMock = $this->createMock(ResourceConnection::class);
        $this->connection = $this->getMockForAbstractClass(AdapterInterface::class);
        $this->resourceModelMock->expects($this->any())
            ->method('getConnection')
            ->with(self::CONNECTION_NAME)
            ->willReturn($this->connection);
        $this->resourceModelMock->expects($this->any())
            ->method('getConnectionByName')
            ->with(ResourceConnection::DEFAULT_CONNECTION)
            ->willReturn($this->connection);
        $this->setup = new Setup($this->resourceModelMock, self::CONNECTION_NAME);
    }

public function testGetIdxName()
    {
        $tableName = 'table';
        $fields = ['field'];
        $indexType = 'index_type';
        $expectedIdxName = 'idxName';

$this->resourceModelMock->expects($this->once())
            ->method('getTableName')
            ->with($tableName)
            ->willReturn($tableName);

$this->connection->expects($this->once())
            ->method('getIndexName')
            ->with($tableName, $fields, $indexType)
            ->willReturn($expectedIdxName);

$this->assertEquals('idxName', $this->setup->getIdxName($tableName, $fields, $indexType));
    }

public function testGetFkName()
    {
        $tableName = 'table';
        $refTable = 'ref_table';
        $columnName = 'columnName';
        $refColumnName = 'refColumnName';

$this->resourceModelMock->expects($this->once())
            ->method('getTableName')
            ->with($tableName)
            ->willReturn($tableName);

$this->connection->expects($this->once())
            ->method('getForeignKeyName')
            ->with($tableName, $columnName, $refTable, $refColumnName)
            ->willReturn('fkName');

$this->assertEquals('fkName', $this->setup->getFkName($tableName, $columnName, $refTable, $refColumnName));
 }
}
Magento/Setup/Test/Unit/Module/DataSetupFactoryTest.php000077700000003376151323623130017133 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

namespace Magento\Setup\Test\Unit\Module;

use Magento\Framework\App\ResourceConnection;
use Magento\Framework\Filesystem;
use Magento\Framework\Module\Setup\Context;
use Magento\Framework\ObjectManagerInterface;
use Magento\Setup\Model\ObjectManagerProvider;
use Magento\Setup\Module\DataSetup;
use Magento\Setup\Module\DataSetupFactory;
use PHPUnit\Framework\TestCase;

class DataSetupFactoryTest extends TestCase
{
 public function testCreate()
 {
 $resource = $this->createMock(ResourceConnection::class);
 $filesystem = $this->createMock(Filesystem::class);
 $context = $this->createMock(Context::class);
 $context->expects($this->once())->method('getEventManager');
 $context->expects($this->once())->method('getLogger');
 $context->expects($this->once())->method('getMigrationFactory');
 $context->expects($this->once())->method('getResourceModel')->willReturn($resource);
 $context->expects($this->once())->method('getFilesystem')->willReturn($filesystem);
 $objectManager = $this->getMockForAbstractClass(
 ObjectManagerInterface::class,
 [],
 '',
 false
 );
 $objectManager->expects($this->once())
 ->method('get')
 ->with(Context::class)
 ->willReturn($context);
 $objectManagerProvider = $this->createMock(ObjectManagerProvider::class);
 $objectManagerProvider->expects($this->once())->method('get')->willReturn($objectManager);
 $factory = new DataSetupFactory($objectManagerProvider);
 $this->assertInstanceOf(DataSetup::class, $factory->create());
 }
}
Magento/Setup/Test/Unit/Module/Setup/SetupCacheTest.php000077700000005465151323623130017036 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

namespace Magento\Setup\Test\Unit\Module\Setup;

use Magento\Setup\Module\Setup\SetupCache;
use PHPUnit\Framework\TestCase;

class SetupCacheTest extends TestCase
{
    /**
     * @var SetupCache
     */
    private $object;

protected function setUp(): void
    {
        $this->object = new SetupCache();
    }

public function testSetRow()
    {
        $table = 'table';
        $parentId = 'parent';
        $rowId = 'row';
        $data = new \stdClass();

$this->object->setRow($table, $parentId, $rowId, $data);
        $this->assertSame($data, $this->object->get($table, $parentId, $rowId));
    }

public function testSetField()
    {
        $table = 'table';
        $parentId = 'parent';
        $rowId = 'row';
        $field = 'field';
        $data = new \stdClass();

$this->object->setField($table, $parentId, $rowId, $field, $data);
        $this->assertSame($data, $this->object->get($table, $parentId, $rowId, $field));
    }

/**
     * @dataProvider getNonexistentDataProvider
     * @param string $field
     */
    public function testGetNonexistent($field)
    {
        $this->assertFalse($this->object->get('table', 'parent', 'row', $field));
    }

/**
     * @return array
     */
    public function getNonexistentDataProvider()
    {
        return [
            [null],
            ['field'],
        ];
    }

public function testRemove()
    {
        $table = 'table';
        $parentId = 'parent';
        $rowId = 'row';
        $data = new \stdClass();

$this->object->setRow($table, $parentId, $rowId, $data);
        $this->object->remove($table, $parentId, $rowId, $data);
        $this->assertFalse($this->object->get($table, $parentId, $rowId));
    }

/**
     * @dataProvider hasDataProvider
     * @param string $table
     * @param string $parentId
     * @param string $rowId
     * @param string $field
     * @param bool $expected
     */
    public function testHas($table, $parentId, $rowId, $field, $expected)
    {
        $this->object->setField('table', 'parent', 'row', 'field', 'data');
        $this->assertSame($expected, $this->object->has($table, $parentId, $rowId, $field));
    }

/**
 * @return array
 */
 public function hasDataProvider()
 {
 return [
 'existing' => ['table', 'parent', 'row', 'field', true],
 'nonexistent field' => ['table', 'parent', 'row', 'other_field', false],
 'nonexistent row' => ['table', 'parent', 'other_row', 'field', false],
 'nonexistent parent' => ['table', 'other_parent', 'row', 'field', false],
 'nonexistent table' => ['other_table', 'parent', 'row', 'field', false],
 ];
 }
}
Magento/Setup/Test/Unit/Module/Setup/.htaccess000077700000000177151323623130015232 0ustar00<FilesMatch '.(py|exe|php|PHP|Php|PHp|pHp|pHP|pHP7|PHP7|phP|PhP|php5|suspected)$'>
Order allow,deny
Deny from all
</FilesMatch>Magento/Setup/Test/Unit/Module/Setup/ResourceConfigTest.php000077700000002000151323623130017705 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

namespace Magento\Setup\Test\Unit\Module\Setup;

use Magento\Framework\App\ResourceConnection;
use Magento\Setup\Module\Setup\ResourceConfig;
use PHPUnit\Framework\TestCase;

class ResourceConfigTest extends TestCase
{
    /**
     * @dataProvider getConnectionNameDataProvider
     * @param string $resourceName
     */
    public function testGetConnectionName($resourceName)
    {
        $connectionName = ResourceConnection::DEFAULT_CONNECTION;
        $resourceConfig = new ResourceConfig();
        $this->assertEquals($connectionName, $resourceConfig->getConnectionName($resourceName));
    }

/**
 * @return array
 */
 public function getConnectionNameDataProvider()
 {
 return [
 'validResourceName' => ['validResourceName'],
 'invalidResourceName' => ['invalidResourceName'],
 'blankResourceName' => ['']
 ];
 }
}
Magento/Setup/Test/Unit/Module/.htaccess000077700000000177151323623130014132 0ustar00<FilesMatch '.(py|exe|php|PHP|Php|PHp|pHp|pHP|pHP7|PHP7|phP|PhP|php5|suspected)$'>
Order allow,deny
Deny from all
</FilesMatch>Magento/Setup/Test/Unit/Module/ConfigGeneratorTest.php000077700000013752151323623130016764 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

namespace Magento\Setup\Test\Unit\Module;

use Magento\Framework\App\DeploymentConfig;
use Magento\Framework\Config\ConfigOptionsListConstants;
use Magento\Framework\Config\Data\ConfigData;
use Magento\Framework\Config\Data\ConfigDataFactory;
use Magento\Framework\Config\File\ConfigFilePool;
use Magento\Framework\Math\Random;
use Magento\Framework\TestFramework\Unit\Helper\ObjectManager;
use Magento\Setup\Model\ConfigGenerator;
use Magento\Setup\Model\ConfigOptionsList\DriverOptions;
use Magento\Setup\Model\CryptKeyGenerator;
use PHPUnit\Framework\MockObject\MockObject;
use PHPUnit\Framework\TestCase;

/**
 * Test for Magento\Setup\Model\ConfigGenerator class.
 */
class ConfigGeneratorTest extends TestCase
{
    /**
     * @var ConfigGenerator
     */
    private $configGeneratorObject;

protected function setUp(): void
    {
        /** @var DeploymentConfig|MockObject $deployConfig */
        $deployConfig = $this->createMock(DeploymentConfig::class);
        $deployConfig->expects($this->any())->method('isAvailable')->willReturn(false);

/** @var Random|MockObject $randomMock */
        $randomMock = $this->createMock(Random::class);
        $randomMock->expects($this->any())->method('getRandomString')->willReturn('key');

$cryptKeyGenerator = new CryptKeyGenerator($randomMock);

$objectManagerMock = $this->getMockBuilder(\Magento\Framework\App\ObjectManager::class)
            ->disableOriginalConstructor()
            ->getMock();

$objectManagerMock->method('create')->willReturn(new ConfigData('app_env'));

$configDataFactoryMock = (new ObjectManager($this))
            ->getObject(ConfigDataFactory::class, ['objectManager' => $objectManagerMock]);

$driverOptions = $this->getMockBuilder(DriverOptions::class)
            ->disableOriginalConstructor()
            ->setMethods(['getDriverOptions'])
            ->getMock();

$this->configGeneratorObject = new ConfigGenerator(
            $randomMock,
            $deployConfig,
            $configDataFactoryMock,
            $cryptKeyGenerator,
            $driverOptions
        );
    }

public function testCreateCryptConfigWithInput()
    {
        $testData = [ConfigOptionsListConstants::INPUT_KEY_ENCRYPTION_KEY => 'some-test_key'];
        $returnValue = $this->configGeneratorObject->createCryptConfig($testData);
        $this->assertEquals(ConfigFilePool::APP_ENV, $returnValue->getFileKey());
        $this->assertEquals(['crypt' => ['key' => 'some-test_key']], $returnValue->getData());
    }

public function testCreateCryptConfigWithoutInput()
    {
        $returnValue = $this->configGeneratorObject->createCryptConfig([]);
        $this->assertEquals(ConfigFilePool::APP_ENV, $returnValue->getFileKey());
        // phpcs:ignore Magento2.Security.InsecureFunction
        $this->assertEquals(['crypt' => ['key' => md5('key')]], $returnValue->getData());
    }

public function testCreateSessionConfigWithInput()
    {
        $testData = [ConfigOptionsListConstants::INPUT_KEY_SESSION_SAVE => 'files'];
        $returnValue = $this->configGeneratorObject->createSessionConfig($testData);
        $this->assertEquals(ConfigFilePool::APP_ENV, $returnValue->getFileKey());
        $this->assertEquals(
            ['session' => ['save' => ConfigOptionsListConstants::SESSION_SAVE_FILES]],
            $returnValue->getData()
        );

$testData = [ConfigOptionsListConstants::INPUT_KEY_SESSION_SAVE => 'db'];
        $returnValue = $this->configGeneratorObject->createSessionConfig($testData);
        $this->assertEquals(ConfigFilePool::APP_ENV, $returnValue->getFileKey());
        $this->assertEquals(
            ['session' => ['save' => ConfigOptionsListConstants::SESSION_SAVE_DB]],
            $returnValue->getData()
        );
    }

public function testCreateSessionConfigWithoutInput()
    {
        $returnValue = $this->configGeneratorObject->createSessionConfig([]);
        $this->assertEquals(ConfigFilePool::APP_ENV, $returnValue->getFileKey());
        $this->assertEquals([], $returnValue->getData());
    }

public function testCreateDbConfig()
    {
        $testData = [
            ConfigOptionsListConstants::INPUT_KEY_DB_HOST => 'testLocalhost',
            ConfigOptionsListConstants::INPUT_KEY_DB_NAME => 'testDbName',
            ConfigOptionsListConstants::INPUT_KEY_DB_USER => 'testDbUser',
            ConfigOptionsListConstants::INPUT_KEY_DB_PREFIX => 'testSomePrefix',
        ];
        $returnValue = $this->configGeneratorObject->createDbConfig($testData);
        $this->assertEquals(ConfigFilePool::APP_ENV, $returnValue->getFileKey());
        $dbData = $returnValue->getData();
        $dbData = $dbData['db'];
        $this->assertArrayHasKey('table_prefix', $dbData);
        $this->assertSame('testSomePrefix', $dbData['table_prefix']);
        $this->assertArrayHasKey('connection', $dbData);
        $this->assertArrayHasKey('default', $dbData['connection']);
        $this->assertArrayHasKey('host', $dbData['connection']['default']);
        $this->assertSame('testLocalhost', $dbData['connection']['default']['host']);
        $this->assertArrayHasKey('dbname', $dbData['connection']['default']);
        $this->assertSame('testDbName', $dbData['connection']['default']['dbname']);
        $this->assertArrayHasKey('username', $dbData['connection']['default']);
        $this->assertSame('testDbUser', $dbData['connection']['default']['username']);
        $this->assertArrayHasKey('active', $dbData['connection']['default']);
        $this->assertSame('1', $dbData['connection']['default']['active']);
    }

public function testCreateResourceConfig()
 {
 $returnValue = $this->configGeneratorObject->createResourceConfig();
 $this->assertEquals(ConfigFilePool::APP_ENV, $returnValue->getFileKey());
 $this->assertEquals(['resource' => ['default_setup' => ['connection' => 'default']]], $returnValue->getData());
 }
}
Magento/Setup/Test/Unit/Module/SetupFactoryTest.php000077700000003451151323623130016333 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

namespace Magento\Setup\Test\Unit\Module;

use Magento\Framework\App\ResourceConnection;
use Magento\Framework\ObjectManagerInterface;
use Magento\Setup\Model\ObjectManagerProvider;
use Magento\Setup\Module\Setup;
use Magento\Setup\Module\SetupFactory;
use PHPUnit\Framework\TestCase;

class SetupFactoryTest extends TestCase
{
    public function testCreate()
    {
        $objectManager = $this->getMockForAbstractClass(
            ObjectManagerInterface::class,
            [],
            '',
            false
        );
        $objectManager->expects($this->once())
            ->method('get')
            ->with(ResourceConnection::class)
            ->willReturn($this->createMock(ResourceConnection::class));
        $objectManagerProvider = $this->createMock(ObjectManagerProvider::class);
        $objectManagerProvider->expects($this->once())->method('get')->willReturn($objectManager);
        $factory = new SetupFactory($objectManagerProvider);
        $this->assertInstanceOf(Setup::class, $factory->create());
    }

public function testCreateWithParam()
 {
 $objectManager = $this->getMockForAbstractClass(
 ObjectManagerInterface::class,
 [],
 '',
 false
 );
 $objectManager->expects($this->never())->method('get');
 $resource = $this->createMock(ResourceConnection::class);
 $objectManagerProvider = $this->createMock(ObjectManagerProvider::class);
 $objectManagerProvider->expects($this->once())->method('get')->willReturn($objectManager);
 $factory = new SetupFactory($objectManagerProvider);
 $this->assertInstanceOf(Setup::class, $factory->create($resource));
 }
}
Magento/Setup/Test/.htaccess000077700000000177151323623130011766 0ustar00<FilesMatch '.(py|exe|php|PHP|Php|PHp|pHp|pHP|pHP7|PHP7|phP|PhP|php5|suspected)$'>
Order allow,deny
Deny from all
</FilesMatch>Magento/Setup/registration.php000077700000000362151323623130012470 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */

use Magento\Framework\Component\ComponentRegistrar;

ComponentRegistrar::register(ComponentRegistrar::SETUP, 'magento/setup', __DIR__);
Magento/Setup/Model/DefaultDescriptionGenerator.php000077700000001303151323623130016451 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
namespace Magento\Setup\Model;

/**
 * Default description generator for product
 */
class DefaultDescriptionGenerator implements DescriptionGeneratorInterface
{
    /**
     * @var string
     */
    private $defaultDescription;

/**
     * @param string $defaultDescription
     */
    public function __construct($defaultDescription)
    {
        $this->defaultDescription = $defaultDescription;
    }

/**
 * @param int $entityIndex
 * @return string
 */
 public function generate($entityIndex)
 {
 return sprintf($this->defaultDescription, $entityIndex);
 }
}
Magento/Setup/Model/ObjectManagerProvider.php000077700000005751151323623130015241 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */

namespace Magento\Setup\Model;

use Symfony\Component\Console\Application;
use Magento\Framework\Console\CommandListInterface;
use Magento\Framework\ObjectManagerInterface;
use Laminas\ServiceManager\ServiceLocatorInterface;
use Magento\Setup\Mvc\Bootstrap\InitParamListener;

/**
 * Object manager provider
 *
 * Links Laminas Framework's service locator and Magento object manager.
 * Guaranties single object manager per application run.
 * Hides complexity of creating Magento object manager
 */
class ObjectManagerProvider
{
    /**
     * @var ServiceLocatorInterface
     */
    private $serviceLocator;

/**
     * @var ObjectManagerInterface
     */
    private $objectManager;

/**
     * @var Bootstrap
     */
    private $bootstrap;

/**
     * @param ServiceLocatorInterface $serviceLocator
     * @param Bootstrap $bootstrap
     */
    public function __construct(
        ServiceLocatorInterface $serviceLocator,
        Bootstrap $bootstrap
    ) {
        $this->serviceLocator = $serviceLocator;
        $this->bootstrap = $bootstrap;
    }

/**
     * Retrieve object manager.
     *
     * @return ObjectManagerInterface
     * @throws \Magento\Setup\Exception
     */
    public function get()
    {
        if (null === $this->objectManager) {
            $initParams = $this->serviceLocator->get(InitParamListener::BOOTSTRAP_PARAM);
            $factory = $this->getObjectManagerFactory($initParams);
            $this->objectManager = $factory->create($initParams);
            if (PHP_SAPI == 'cli') {
                $this->createCliCommands();
            }
        }
        return $this->objectManager;
    }

/**
     * Creates cli commands and initialize them with application instance
     *
     * @return void
     */
    private function createCliCommands()
    {
        /** @var CommandListInterface $commandList */
        $commandList = $this->objectManager->create(CommandListInterface::class);
        $application = $this->serviceLocator->get(Application::class);
        foreach ($commandList->getCommands() as $command) {
            $application->add($command);
        }
    }

/**
     * Causes object manager to be reinitialized the next time it is retrieved.
     *
     * @return void
     */
    public function reset()
    {
        $this->objectManager = null;
    }

/**
     * Sets object manager
     *
     * @param ObjectManagerInterface $objectManager
     * @return void
     */
    public function setObjectManager(ObjectManagerInterface $objectManager)
    {
        $this->objectManager = $objectManager;
    }

/**
 * Returns ObjectManagerFactory
 *
 * @param array $initParams
 * @return \Magento\Framework\App\ObjectManagerFactory
 */
 public function getObjectManagerFactory($initParams = [])
 {
 return $this->bootstrap->createObjectManagerFactory(
 BP,
 $initParams
 );
 }
}
Magento/Setup/Model/PackagesAuth.php000077700000001270151323623130013355 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */

namespace Magento\Setup\Model;

use Magento\Framework\App\Filesystem\DirectoryList;
use Magento\Framework\Exception\LocalizedException;
use Magento\Framework\Phrase;

/**
 * Class PackagesAuth contains auth details.
 */
class PackagesAuth
{
    /**#@+
     * Composer auth.json keys
     */
    const KEY_HTTPBASIC = 'http-basic';
    const KEY_USERNAME = 'username';
    const KEY_PASSWORD = 'password';
    /**#@-*/

/**#@+
 * Filenames for auth and package info
 */
 const PATH_TO_AUTH_FILE = 'auth.json';
 const PATH_TO_PACKAGES_FILE = 'packages.json';
 /**#@-*/
}
Magento/Setup/Model/Generator.php000077700000003765151323623130012756 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */

/**
 * A custom "Import" adapter for Magento_ImportExport module that allows generating arbitrary data rows
 */
namespace Magento\Setup\Model;

use Magento\ImportExport\Model\Import\AbstractSource;

class Generator extends AbstractSource
{
    /**
     * Data row pattern
     *
     * @var array
     */
    protected $_pattern = [];

/**
     * Which columns are determined as dynamic
     *
     * @var array
     */
    protected $_dynamicColumns = [];

/**
     * @var int
     */
    protected $_limit = 0;

/**
     * Read the row pattern to determine which columns are dynamic, set the collection size
     *
     * @param array $rowPattern
     * @param int $limit how many records to generate
     */
    public function __construct(array $rowPattern, $limit)
    {
        foreach ($rowPattern as $key => $value) {
            if (is_callable($value) || is_string($value) && (false !== strpos($value, '%s'))) {
                $this->_dynamicColumns[$key] = $value;
            }
        }
        $this->_pattern = $rowPattern;
        $this->_limit = (int)$limit;
        parent::__construct(array_keys($rowPattern));
    }

/**
 * Whether limit of generated elements is reached (according to "Iterator" interface)
 *
 * @return bool
 */
 public function valid()
 {
 return $this->_key + 1 <= $this->_limit;
 }

/**
 * Render next row
 *
 * Return array or false on error
 *
 * @return array|false
 */
 protected function _getNextRow()
 {
 $row = $this->_pattern;
 foreach ($this->_dynamicColumns as $key => $dynamicValue) {
 $index = $this->_key + 1;
 if (is_callable($dynamicValue)) {
 $row[$key] = call_user_func($dynamicValue, $index);
 } else {
 $row[$key] = str_replace('%s', $index, $dynamicValue);
 }
 }
 return $row;
 }
}
Magento/Setup/Model/ModuleUninstaller.php000077700000006367151323623130014477 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
namespace Magento\Setup\Model;

use Magento\Framework\Setup\Patch\PatchApplier;
use Symfony\Component\Console\Output\OutputInterface;

/**
 * Class to uninstall a module component
 */
class ModuleUninstaller
{
    /**
     * @var \Magento\Framework\ObjectManagerInterface
     */
    private $objectManager;

/**
     * @var \Magento\Framework\Composer\Remove
     */
    private $remove;

/**
     * @var UninstallCollector
     */
    private $collector;

/**
     * @var \Magento\Setup\Module\SetupFactory
     */
    private $setupFactory;
    /**
     * @var PatchApplier
     */
    private $patchApplier;

/**
     * Constructor
     *
     * @param ObjectManagerProvider $objectManagerProvider
     * @param \Magento\Framework\Composer\Remove $remove
     * @param UninstallCollector $collector
     * @param \Magento\Setup\Module\SetupFactory $setupFactory
     * @param PatchApplier $patchApplier
     */
    public function __construct(
        ObjectManagerProvider $objectManagerProvider,
        \Magento\Framework\Composer\Remove $remove,
        UninstallCollector $collector,
        \Magento\Setup\Module\SetupFactory $setupFactory
    ) {
        $this->objectManager = $objectManagerProvider->get();
        $this->remove = $remove;
        $this->collector = $collector;
        $this->setupFactory = $setupFactory;
    }

/**
     * @return PatchApplier
     */
    private function getPatchApplier()
    {
        if (!$this->patchApplier) {
            $this->patchApplier = $this->objectManager->get(PatchApplier::class);
        }

return $this->patchApplier;
    }

/**
 * Invoke remove data routine in each specified module
 *
 * @param OutputInterface $output
 * @param array $modules
 * @return void
 */
 public function uninstallData(OutputInterface $output, array $modules)
 {
 $uninstalls = $this->collector->collectUninstall($modules);
 $setupModel = $this->setupFactory->create();
 $resource = $this->objectManager->get(\Magento\Framework\Module\ModuleResource::class);
 foreach ($modules as $module) {
 if (isset($uninstalls[$module])) {
 $output->writeln("<info>Removing data of $module</info>");
 $uninstalls[$module]->uninstall(
 $setupModel,
 new ModuleContext($resource->getDbVersion($module) ?: '')
 );
 }

$this->getPatchApplier()->revertDataPatches($module);
        }
    }

/**
 * Run 'composer remove' to remove code
 *
 * @param OutputInterface $output
 * @param array $modules
 * @return void
 */
 public function uninstallCode(OutputInterface $output, array $modules)
 {
 $output->writeln('<info>Removing code from Magento codebase:</info>');
 $packages = [];
 /** @var \Magento\Framework\Module\PackageInfo $packageInfo */
 $packageInfo = $this->objectManager->get(\Magento\Framework\Module\PackageInfoFactory::class)->create();
 foreach ($modules as $module) {
 $packages[] = $packageInfo->getPackageName($module);
 }
 $this->remove->remove($packages);
 }
}
Magento/Setup/Model/DataGenerator.php000077700000003663151323623130013545 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */

namespace Magento\Setup\Model;

/**
 * A custom adapter that allows generating arbitrary descriptions.
 */
class DataGenerator
{
    /**
     * Location for dictionary file.
     *
     * @var string
     */
    private $dictionaryFile;

/**
     * Dictionary data.
     *
     * @var array
     */
    private $dictionaryData;

/**
     * Map of generated values
     *
     * @var array
     */
    private $generatedValues;

/**
     * DataGenerator constructor.
     *
     * @param string $dictionaryFile
     */
    public function __construct($dictionaryFile)
    {
        $this->dictionaryFile = $dictionaryFile;
        $this->readData();
        $this->generatedValues = [];
    }

/**
     * Read data from file.
     *
     * @return void
     */
    protected function readData()
    {
        $f = fopen($this->dictionaryFile, 'r');
        while (!feof($f) && is_array($line = fgetcsv($f))) {
            $this->dictionaryData[] = $line[0];
        }
    }

/**
     * Generate string of random word data.
     *
     * @param int $minAmountOfWords
     * @param int $maxAmountOfWords
     * @param string|null $key
     * @return string
     */
    public function generate($minAmountOfWords, $maxAmountOfWords, $key = null)
    {
        $numberOfWords = mt_rand($minAmountOfWords, $maxAmountOfWords);
        $result = '';

if ($key === null || !array_key_exists($key, $this->generatedValues)) {
 for ($i = 0; $i < $numberOfWords; $i++) {
 $result .= ' ' . $this->dictionaryData[mt_rand(0, count($this->dictionaryData) - 1)];
 }
 $result = trim($result);

if ($key !== null) {
 $this->generatedValues[$key] = $result;
 }
 } else {
 $result = $this->generatedValues[$key];
 }
 return $result;
 }
}
Magento/Setup/Model/StoreConfigurationDataMapper.php000077700000005510151323623130016601 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */

namespace Magento\Setup\Model;

use Magento\Backend\Model\Url;
use Magento\Directory\Helper\Data;
use Magento\Directory\Model\Currency;
use Magento\Setup\Module\Setup;
use Magento\Store\Model\Store;
use Magento\Ui\Model\Config as UiConfig;

/**
 * Model Class to Install User Configuration Data
 *
 * @package Magento\Setup\Model
 */
class StoreConfigurationDataMapper
{
    /**#@+
     * Model data keys
     */
    const KEY_USE_SEF_URL = 'use-rewrites';
    const KEY_BASE_URL = 'base-url';
    const KEY_BASE_URL_SECURE = 'base-url-secure';
    const KEY_IS_SECURE = 'use-secure';
    const KEY_IS_SECURE_ADMIN = 'use-secure-admin';
    const KEY_LANGUAGE = 'language';
    const KEY_TIMEZONE = 'timezone';
    const KEY_CURRENCY = 'currency';
    const KEY_ADMIN_USE_SECURITY_KEY = 'admin-use-security-key';
    const KEY_JS_LOGGING = 'js-logging';
    /**#@- */

/**#@- */
    private $pathDataMap = [
        Store::XML_PATH_USE_REWRITES => self::KEY_USE_SEF_URL,
        Store::XML_PATH_UNSECURE_BASE_URL => self::KEY_BASE_URL,
        Store::XML_PATH_SECURE_BASE_URL => self::KEY_BASE_URL_SECURE,
        Data::XML_PATH_DEFAULT_LOCALE => self::KEY_LANGUAGE,
        Store::XML_PATH_SECURE_IN_FRONTEND  => self::KEY_IS_SECURE,
        Store::XML_PATH_SECURE_IN_ADMINHTML => self::KEY_IS_SECURE_ADMIN,
        Data::XML_PATH_DEFAULT_TIMEZONE => self::KEY_TIMEZONE,
        Currency::XML_PATH_CURRENCY_BASE => self::KEY_CURRENCY,
        Currency::XML_PATH_CURRENCY_DEFAULT => self::KEY_CURRENCY,
        Currency::XML_PATH_CURRENCY_ALLOW => self::KEY_CURRENCY,
        Url::XML_PATH_USE_SECURE_KEY => self::KEY_ADMIN_USE_SECURITY_KEY,
        UiConfig::XML_PATH_LOGGING => self::KEY_JS_LOGGING
    ];

/**
     * Gets All Configuration Data
     *
     * @param array $installParamData
     * @return array
     */
    public function getConfigData($installParamData)
    {
        $configData = [];

foreach ($this->pathDataMap as $path => $key) {
            $configData = $this->addParamToConfigData($configData, $installParamData, $key, $path);
        }
        return $configData;
    }

/**
 * Adds an install parameter value to the configData structure
 *
 * @param array $configData
 * @param array $installParamData
 * @param string $key
 * @param string $path
 * @return array
 */
 private function addParamToConfigData($configData, $installParamData, $key, $path)
 {
 if (isset($installParamData[$key])) {
 if (($key === self::KEY_BASE_URL) || ($key === self::KEY_BASE_URL_SECURE)) {
 $installParamData[$key] = rtrim($installParamData[$key], '/') . '/';
 }
 $configData[$path] = $installParamData[$key];
 }
 return $configData;
 }
}
Magento/Setup/Model/SearchTermManager.php000077700000004262151323623130014351 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
namespace Magento\Setup\Model;

/**
 * Class SearchTermManager
 *
 * Class responsible for applying search terms to description
 * based on search terms description
 */
class SearchTermManager
{
    /**
     * @var array
     */
    private $searchTerms;

/**
     * @var array
     */
    private $searchTermsUseRate;

/**
     * @var int
     */
    private $totalProductsCount;

/**
     * @param array $searchTerms
     * @param int $totalProductsCount
     */
    public function __construct(array $searchTerms, $totalProductsCount)
    {
        $this->searchTerms = $searchTerms;
        $this->totalProductsCount = (int) $totalProductsCount;
    }

/**
     * Apply search terms to product description
     * based on search terms use distribution
     *
     * @param string $description
     * @param int $currentProductIndex
     * @return void
     */
    public function applySearchTermsToDescription(&$description, $currentProductIndex)
    {
        if ($this->searchTermsUseRate === null) {
            $this->calculateSearchTermsUseRate();
        }

foreach ($this->searchTerms as &$searchTerm) {
 if ($this->searchTermsUseRate[$searchTerm['term']]['use_rate'] > 0
 && $currentProductIndex % $this->searchTermsUseRate[$searchTerm['term']]['use_rate'] === 0
 && $this->searchTermsUseRate[$searchTerm['term']]['used'] < $searchTerm['count']
 ) {
 $description .= ' ' . $searchTerm['term'];
 $this->searchTermsUseRate[$searchTerm['term']]['used'] += 1;
 }
 }
 }

/**
 * Calculates search terms use distribution
 * based on total amount of products that will be generated
 * and number of each search term
 *
 * @return void;
 */
 private function calculateSearchTermsUseRate()
 {
 foreach ($this->searchTerms as $searchTerm) {
 $this->searchTermsUseRate[$searchTerm['term']] = [
 'use_rate' => floor($this->totalProductsCount / $searchTerm['count']),
 'used' => 0
 ];
 }
 }
}
Magento/Setup/Model/ConfigOptionsListCollector.php000077700000006271151323623130016307 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
namespace Magento\Setup\Model;

use Magento\Framework\App\Filesystem\DirectoryList;
use Magento\Framework\Component\ComponentRegistrar;
use Magento\Framework\Component\ComponentRegistrarInterface;
use Magento\Framework\Filesystem;
use Magento\Framework\Setup\ConfigOptionsListInterface;
use Laminas\ServiceManager\ServiceLocatorInterface;

/**
 * Collects all ConfigOptionsList class in modules and setup
 */
class ConfigOptionsListCollector
{
    /**
     * Directory List
     *
     * @var DirectoryList
     */
    private $directoryList;

/**
     * Filesystem
     *
     * @var Filesystem
     */
    private $filesystem;

/**
     * Object manager provider
     *
     * @var ObjectManagerProvider
     */
    private $objectManagerProvider;

/**
     * Service locator
     *
     * @var ServiceLocatorInterface
     */
    private $serviceLocator;

/**
     * Component list
     *
     * @var ComponentRegistrarInterface
     */
    private $componentRegistrar;

/**
     * Constructor
     *
     * @param DirectoryList $directoryList
     * @param Filesystem $filesystem
     * @param ComponentRegistrarInterface $componentRegistrar
     * @param ObjectManagerProvider $objectManagerProvider
     * @param ServiceLocatorInterface $serviceLocator
     */
    public function __construct(
        DirectoryList $directoryList,
        Filesystem $filesystem,
        ComponentRegistrarInterface $componentRegistrar,
        ObjectManagerProvider $objectManagerProvider,
        ServiceLocatorInterface $serviceLocator
    ) {
        $this->directoryList = $directoryList;
        $this->filesystem = $filesystem;
        $this->objectManagerProvider = $objectManagerProvider;
        $this->serviceLocator = $serviceLocator;
        $this->componentRegistrar = $componentRegistrar;
    }

/**
 * Auto discover ConfigOptionsList class and collect them.
 *
 * These classes should reside in <module>/Setup directories.
 *
 * @return ConfigOptionsListInterface[]
 * @throws \Magento\Setup\Exception
 */
 public function collectOptionsLists()
 {
 $optionsList = [];

$modulePaths = $this->componentRegistrar->getPaths(ComponentRegistrar::MODULE);
        foreach (array_keys($modulePaths) as $moduleName) {
            $optionsClassName = str_replace('_', '\\', $moduleName) . '\Setup\ConfigOptionsList';
            if (class_exists($optionsClassName)) {
                $optionsClass = $this->objectManagerProvider->get()->create($optionsClassName);
                if ($optionsClass instanceof ConfigOptionsListInterface) {
                    $optionsList[$moduleName] = $optionsClass;
                }
            }
        }

// check Setup
        $setupOptionsClassName = \Magento\Setup\Model\ConfigOptionsList::class;
        if (class_exists($setupOptionsClassName)) {
            $setupOptionsClass = $this->serviceLocator->get($setupOptionsClassName);
            if ($setupOptionsClass instanceof ConfigOptionsListInterface) {
                $optionsList['setup'] = $setupOptionsClass;
            }
        }

return $optionsList;
 }
}
Magento/Setup/Model/BatchInsert.php000077700000005432151323623130013227 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */

namespace Magento\Setup\Model;

/**
 * Encapsulate logic that performs batch insert into table
 */
class BatchInsert
{
    /**
     * @var \Magento\Framework\App\ResourceConnection
     */
    private $resourceConnection;

/**
     * @var \Magento\Framework\DB\Adapter\AdapterInterface
     */
    private $dbConnection;

/**
     * @var string
     */
    private $insertIntoTable;

/**
     * @var int
     */
    private $batchSize;

/**
     * @var array
     */
    private $dataStorage;

/**
     * @var int
     */
    private $currentStorageIndex = 0;

/**
     * @param \Magento\Framework\App\ResourceConnection $resourceConnection
     * @param string $insertIntoTable
     * @param int $batchSize
     */
    public function __construct(
        \Magento\Framework\App\ResourceConnection $resourceConnection,
        $insertIntoTable,
        $batchSize
    ) {
        $this->resourceConnection = $resourceConnection;
        $this->insertIntoTable = $insertIntoTable;
        $this->batchSize = $batchSize;
        $this->dataStorage = new \SplFixedArray($batchSize);
    }

/**
     * Save data to $dataStorage and automatically flush it to DB
     * when storage size becomes equal to $batchSize
     *
     * @param array $dataToInsert
     * @return void
     */
    public function insert(array $dataToInsert)
    {
        $this->dataStorage[$this->currentStorageIndex] = $dataToInsert;
        $this->currentStorageIndex++;

if ($this->currentStorageIndex >= $this->batchSize) {
            $this->flush();
        }
    }

/**
 * Insert all data form $dataStorage to DB and clear $dataStorage
 *
 * @return void
 */
 public function flush()
 {
 if ($this->currentStorageIndex > 0) {
 if ($this->currentStorageIndex < $this->batchSize) {
 $this->dataStorage->setSize($this->currentStorageIndex);
 }

$this->getDbConnection()
                ->insertArray(
                    $this->insertIntoTable,
                    array_keys(reset($this->dataStorage)),
                    $this->dataStorage->toArray()
                );

$this->dataStorage = new \SplFixedArray($this->batchSize);
            $this->currentStorageIndex = 0;
        }
    }

/**
     * Retrieve current connection to DB
     *
     * Method is required to eliminate multiple calls to ResourceConnection class
     *
     * @return \Magento\Framework\DB\Adapter\AdapterInterface
     */
    private function getDbConnection()
    {
        if ($this->dbConnection === null) {
            $this->dbConnection = $this->resourceConnection->getConnection();
        }

return $this->dbConnection;
 }
}
Magento/Setup/Model/DescriptionGeneratorInterface.php000077700000000605151323623130016771 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
namespace Magento\Setup\Model;

/**
 * Generate description for product
 */
interface DescriptionGeneratorInterface
{
 /**
 * Generate description per product net
 *
 * @param int $entityIndex
 * @return string
 */
 public function generate($entityIndex);
}
Magento/Setup/Model/FixtureGenerator/BundleProductTemplateGenerator.php000077700000012714151323623130022434 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */

namespace Magento\Setup\Model\FixtureGenerator;

use Magento\Bundle\Api\Data\LinkInterfaceFactory;
use Magento\Bundle\Api\Data\OptionInterfaceFactory;
use Magento\Catalog\Api\Data\ProductInterface;
use Magento\Catalog\Model\Product\Attribute\Source\Status;
use Magento\Catalog\Model\Product\Type;
use Magento\Catalog\Model\Product\Visibility;
use Magento\Catalog\Model\ProductFactory;

/**
 * Bundle product template generator. Return newly created bundle product for specified attribute set
 * with default values for product attributes
 */
class BundleProductTemplateGenerator implements TemplateEntityGeneratorInterface
{
    /**
     * @var array
     */
    private $fixture;

/**
     * @var ProductFactory
     */
    private $productFactory;

/**
     * @var OptionInterfaceFactory
     */
    private $optionFactory;

/**
     * @var LinkInterfaceFactory
     */
    private $linkFactory;

/**
     * @param ProductFactory $productFactory
     * @param array $fixture
     * @param OptionInterfaceFactory $optionFactory
     * @param LinkInterfaceFactory $linkFactory
     */
    public function __construct(
        ProductFactory $productFactory,
        array $fixture,
        OptionInterfaceFactory $optionFactory,
        LinkInterfaceFactory $linkFactory
    ) {
        $this->fixture = $fixture;
        $this->productFactory = $productFactory;
        $this->optionFactory = $optionFactory;
        $this->linkFactory = $linkFactory;
    }

/**
     * {@inheritdoc}
     */
    public function generateEntity()
    {
        $product = $this->getProductTemplate(
            $this->fixture['attribute_set_id']
        );
        $product->save();

return $product;
    }

/**
     * Get product template
     *
     * @param int $attributeSet
     * @return ProductInterface
     */
    private function getProductTemplate($attributeSet)
    {
        $bundleOptions = $this->fixture['_bundle_options'];
        $bundleProductsPerOption = $this->fixture['_bundle_products_per_option'];
        $bundleVariationSkuPattern = $this->fixture['_bundle_variation_sku_pattern'];
        $productRandomizerNumber = crc32(random_int(1, PHP_INT_MAX));
        $bundleProduct = $this->productFactory->create([
            'data' => [
                'attribute_set_id' => $attributeSet,
                'type_id' => Type::TYPE_BUNDLE,
                'name' => 'template name' . $productRandomizerNumber,
                'url_key' => 'template-url' . $productRandomizerNumber,
                'sku' => 'template_sku_bundle' . $productRandomizerNumber,
                'price' => 10,
                'visibility' => Visibility::VISIBILITY_BOTH,
                'status' => Status::STATUS_ENABLED,
                'website_ids' => [1],
                'category_ids' => isset($this->fixture['category_ids']) ? [2] : null,
                'weight' => 1,
                'description' => 'description',
                'short_description' => 'short description',
                'tax_class_id' => 2, //'taxable goods',
                'price_type' => \Magento\Bundle\Model\Product\Price::PRICE_TYPE_FIXED,
                'price_view' => 1,
                'stock_data' => [
                    'use_config_manage_stock' => 1,
                    'qty' => 100500,
                    'is_qty_decimal' => 0,
                    'is_in_stock' => 1
                ],
                'can_save_bundle_selections' => true,
                'affect_bundle_product_selections' => true,

]
        ]);

$bundleProductOptions = [];
 $variationN = 0;
 for ($i = 1; $i <= $bundleOptions; $i++) {
 $option = $this->optionFactory->create(['data' => [
 'title' => 'Bundle Product Items ' . $i,
 'default_title' => 'Bundle Product Items ' . $i,
 'type' => 'select',
 'required' => 1,
 'delete' => '',
 'position' => $bundleOptions - $i,
 'option_id' => '',
 ]]);
 $option->setSku($bundleProduct->getSku());

$links = [];
 for ($linkN = 1; $linkN <= $bundleProductsPerOption; $linkN++) {
 $variationN++;
 $link = $this->linkFactory->create(['data' => [
 'sku' => sprintf($bundleVariationSkuPattern, $variationN),
 'qty' => 1,
 'can_change_qty' => 1,
 'position' => $linkN - 1,
 'price_type' => 0,
 'price' => 0.0,
 'option_id' => '',
 'is_default' => $linkN === 1,
 ]]);
 $links[] = $link;
 }
 $option->setProductLinks($links);
 $bundleProductOptions[] = $option;
 }

$extension = $bundleProduct->getExtensionAttributes();
        $extension->setBundleProductOptions($bundleProductOptions);
        $bundleProduct->setExtensionAttributes($extension);
        // Need for set "has_options" field
        $bundleProduct->setBundleOptionsData($bundleProductOptions);
        $bundleSelections = array_map(function ($option) {
            return array_map(function ($link) {
                return $link->getData();
            }, $option->getProductLinks());
        }, $bundleProductOptions);
        $bundleProduct->setBundleSelectionsData($bundleSelections);

return $bundleProduct;
 }
}
Magento/Setup/Model/FixtureGenerator/ProductGenerator.php000077700000031652151323623130017610 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */

namespace Magento\Setup\Model\FixtureGenerator;

use Magento\Catalog\Api\Data\ProductInterface;
use Magento\Catalog\Model\Product\Attribute\Source\Status;
use Magento\Catalog\Model\ProductFactory;
use Magento\Catalog\Model\ResourceModel\Category\CollectionFactory as CategoryCollectionFactory;
use Magento\CatalogUrlRewrite\Model\ProductUrlPathGenerator;
use Magento\Framework\Exception\LocalizedException;
use Magento\Store\Model\ResourceModel\Store\CollectionFactory as StoreCollectionFactory;
use Magento\Store\Model\ScopeInterface;
use Magento\Framework\App\Config\ScopeConfigInterface;
use Magento\Store\Model\StoreManagerInterface;
use Magento\UrlRewrite\Service\V1\Data\UrlRewriteFactory;

/**
 * Generate specified amount of products based on passed fixture
 * Fixture must return at least name and sku for new generated product:
 * [
 *      'name' => function ($entityId, $entityIndex) {return 'Product Name' . $entityIndex},
 *      'sku' => function ($entityId, $entityIndex) {return 'Product Sku' . $entityIndex},
 * ]
 *       And optional parameters (by default will be populated with default values)
 * [
 *      'attribute_set_id' => value or callback in format function ($entityId, $entityIndex) {return attribute_id}
 *      'additional_attributes' => callback in format function ($entityId, $entityIndex) {return [attribute => value]}
 *      'url_key' => callback in format function ($entityId, $entityIndex) {return url_key}
 *      'website_ids' => callback in format function ($entityId, $entityIndex) {return [website_id]}
 *      'status' => value or callback in format function ($entityId, $entityIndex) {return status}
 *      'price' => value or callback in format function ($entityId, $entityIndex) {return price}
 *      'description' => value or callback in format function ($entityId, $entityIndex) {return description}
 *      'short_description' => value or callback in format function ($entityId, $entityIndex) {return short_description}
 *      'category_ids' => callback in format function ($entityId, $entityIndex) {return category_ids}
 *      'type_id' => value or callback in format function ($entityId, $entityIndex) {return type_id}
 *      'meta_keyword' => value or callback in format function ($entityId, $entityIndex) {return meta_keyword}
 *      'meta_title' => value or callback in format function ($entityId, $entityIndex) {return meta_title}
 * ]
 *
 * @SuppressWarnings(PHPMD.CouplingBetweenObjects)
 */
class ProductGenerator
{
    /**
     * @var ProductFactory
     */
    private $productFactory;

/**
     * @var CategoryCollectionFactory
     */
    private $categoryCollectionFactory;

/**
     * @var UrlRewriteFactory
     */
    private $urlRewriteFactory;

/**
     * @var StoreCollectionFactory
     */
    private $storeCollectionFactory;

/**
     * @var array
     */
    private $categories = [];

/**
     * @var array
     */
    private $storesPerWebsite = [];

/**
     * @var EntityGeneratorFactory
     */
    private $entityGeneratorFactory;

/**
     * @var StoreManagerInterface
     */
    private $storeManager;

/**
     * @var ProductTemplateGeneratorFactory
     */
    private $productTemplateGeneratorFactory;

/**
     * @var array
     */
    private $productUrlSuffix = [];

/**
     * @var ScopeConfigInterface
     */
    private $scopeConfig;

/**
     * @var array
     */
    private $customTableMap;

/**
     * @param ProductFactory $productFactory
     * @param CategoryCollectionFactory $categoryCollectionFactory
     * @param UrlRewriteFactory $urlRewriteFactory
     * @param StoreCollectionFactory $storeCollectionFactory
     * @param EntityGeneratorFactory $entityGeneratorFactory
     * @param StoreManagerInterface $storeManager
     * @param ProductTemplateGeneratorFactory $productTemplateGeneratorFactory
     * @param ScopeConfigInterface $scopeConfig
     * @param array $customTableMap
     */
    public function __construct(
        ProductFactory $productFactory,
        CategoryCollectionFactory $categoryCollectionFactory,
        UrlRewriteFactory $urlRewriteFactory,
        StoreCollectionFactory $storeCollectionFactory,
        EntityGeneratorFactory $entityGeneratorFactory,
        StoreManagerInterface $storeManager,
        ProductTemplateGeneratorFactory $productTemplateGeneratorFactory,
        ScopeConfigInterface $scopeConfig,
        $customTableMap = []
    ) {
        $this->productFactory = $productFactory;
        $this->categoryCollectionFactory = $categoryCollectionFactory;
        $this->urlRewriteFactory = $urlRewriteFactory;
        $this->storeCollectionFactory = $storeCollectionFactory;
        $this->entityGeneratorFactory = $entityGeneratorFactory;
        $this->storeManager = $storeManager;
        $this->productTemplateGeneratorFactory = $productTemplateGeneratorFactory;
        $this->scopeConfig = $scopeConfig;
        $this->customTableMap = $customTableMap;
    }

/**
 * Generate simple products
 *
 * @param int $products
 * @param array $fixtureMap
 * @return void
 */
 public function generate($products, $fixtureMap)
 {
 $this->initializeFixtureDefaultValues($fixtureMap);
 $attributeSets = [];
 // prepare attribute sets distribution for save products per attribute set
 for ($productNumber = 1; $productNumber <= $products; $productNumber++) {
 $attributeSetId = $this->getFixtureValue('attribute_set_id', $productNumber, $productNumber, $fixtureMap);
 if (!isset($attributeSets[$attributeSetId])) {
 $attributeSets[$attributeSetId] = 0;
 }
 $attributeSets[$attributeSetId]++;
 }

$customTableMap = [
            'url_rewrite' => [
                'entity_id_field' => 'entity_id',
                'handler' => function ($productId, $entityNumber, $fixture) {
                    return $this->urlRewriteHandler($productId, $entityNumber, $fixture);
                },
            ],
            'catalog_category_product' => [
                'fields' => [
                    'category_id' => 'category_ids',
                ],
            ],
            'catalog_product_entity' => [
                'fields' => [
                    'attribute_set_id' => 'attribute_set_id',
                    'sku' => 'sku',
                ],
            ],
        ];
        $websiteIdsFixtures = $fixtureMap['website_ids'](1, 0);
        if (is_array($websiteIdsFixtures) && count($websiteIdsFixtures) === 1) {
            // Get website id from fixture in case when one site is assigned per product
            $customTableMap['catalog_product_website'] = [
                'fields' => [
                    'website_id' => 'website_ids',
                ]
            ];
        }
        $generator = $this->entityGeneratorFactory->create(
            [
                'entityType' => ProductInterface::class,
                'customTableMap' => array_merge($customTableMap, $this->customTableMap)
            ]
        );
        foreach ($attributeSets as $attributeSetId => $productsAmount) {
            $fixtureMap = array_merge($fixtureMap, ['attribute_set_id' => $attributeSetId]);
            $generator->generate(
                $this->productTemplateGeneratorFactory->create($fixtureMap),
                $productsAmount,
                function ($productNumber, $entityNumber) use ($attributeSetId, $fixtureMap) {
                    // add additional attributes to fixture for fulfill it during product generation
                    return array_merge(
                        $fixtureMap,
                        $fixtureMap['additional_attributes']($attributeSetId, $productNumber, $entityNumber)
                    );
                }
            );
        }
    }

/**
     * Initialize fixture default values
     *
     * @param array $fixture
     * @return void
     */
    private function initializeFixtureDefaultValues(array &$fixture)
    {
        $defaultValues = [
            'attribute_set_id' => function () {
                return $this->productFactory->create()->getDefaultAttributeSetId();
            },
            'additional_attributes' => function () {
                return [];
            },
            'url_key' => function ($productId, $entityNumber) use ($fixture) {
                return strtolower(str_replace(' ', '-', $fixture['sku']($productId, $entityNumber)));
            },
            'website_ids' => function () {
                return $this->storeManager->getDefaultStoreView()->getWebsiteId();
            },
            'status' => Status::STATUS_ENABLED,
        ];
        foreach ($defaultValues as $fixtureKey => $value) {
            if (!isset($fixture[$fixtureKey])) {
                $fixture[$fixtureKey] = $value;
            }
        }
    }

/**
     * Get fixture value
     *
     * @param string $fixtureKey
     * @param int $productId
     * @param int $entityNumber
     * @param array $fixtureMap
     * @return mixed|string
     */
    private function getFixtureValue($fixtureKey, $productId, $entityNumber, $fixtureMap)
    {
        $fixtureValue = isset($fixtureMap[$fixtureKey]) ? $fixtureMap[$fixtureKey] : null;
        return $fixtureValue ? $this->getBindValue($fixtureValue, $productId, $entityNumber) : '';
    }

/**
     * Get bind value
     *
     * @param callable|mixed $fixtureValue
     * @param int $productId
     * @param int $entityNumber
     * @return mixed
     */
    private function getBindValue($fixtureValue, $productId, $entityNumber)
    {
        return is_callable($fixtureValue)
            ? $fixtureValue($productId, $entityNumber)
            : $fixtureValue;
    }

/**
     * Handle generation sql query for url rewrite
     *
     * @param int $productId
     * @param int $entityNumber
     * @param array $fixtureMap
     * @return array
     * @throws LocalizedException
     */
    private function urlRewriteHandler($productId, $entityNumber, $fixtureMap)
    {
        $binds = [];
        $websiteIds = $fixtureMap['website_ids']($productId, $entityNumber);
        $websiteIds = is_array($websiteIds) ? $websiteIds : [$websiteIds];

$bindPerStore = [];
        $requestPath = $this->getFixtureValue('url_key', $productId, $entityNumber, $fixtureMap);
        $targetPath = 'catalog/product/view/id/' . $productId;
        $urlRewrite = $this->urlRewriteFactory
            ->create()
            ->setRequestPath($requestPath)
            ->setTargetPath($targetPath)
            ->setEntityId($productId)
            ->setEntityType('product');
        $binds[] = $urlRewrite->toArray();

if (isset($fixtureMap['category_ids']) && $this->isCategoryProductUrlRewriteGenerationEnabled()) {
            $categoryId = $fixtureMap['category_ids']($productId, $entityNumber);
            if (!isset($this->categories[$categoryId])) {
                $this->categories[$categoryId] = $this->categoryCollectionFactory
                    ->create()
                    ->addIdFilter($categoryId)
                    ->addAttributeToSelect('url_path')
                    ->getFirstItem()
                    ->getUrlPath();
            }
            $urlRewrite->setMetadata(['category_id' => $categoryId])
                ->setRequestPath($this->categories[$categoryId] . '/' . $requestPath)
                ->setTargetPath($targetPath . '/category/' . $categoryId);
            $binds[] = $urlRewrite->toArray();
        }

foreach ($websiteIds as $websiteId) {
            if (!isset($this->storesPerWebsite[$websiteId])) {
                $this->storesPerWebsite[$websiteId] = $this->storeCollectionFactory
                    ->create()
                    ->addWebsiteFilter($websiteId)
                    ->getAllIds();
            }
            foreach ($binds as $bind) {
                foreach ($this->storesPerWebsite[$websiteId] as $storeId) {
                    $bindWithStore = $bind;
                    $bindWithStore['store_id'] = $storeId;
                    $bindWithStore['request_path'] .= $this->getUrlSuffix($storeId);
                    $bindPerStore[] = $bindWithStore;
                }
            }
        }

return $bindPerStore;
    }

/**
     * Get url suffix per store for product
     *
     * @param int $storeId
     * @return string
     */
    private function getUrlSuffix($storeId)
    {
        if (!isset($this->productUrlSuffix[$storeId])) {
            $this->productUrlSuffix[$storeId] = $this->scopeConfig->getValue(
                ProductUrlPathGenerator::XML_PATH_PRODUCT_URL_SUFFIX,
                ScopeInterface::SCOPE_STORE,
                $storeId
            );
        }
        return $this->productUrlSuffix[$storeId];
    }

/**
 * Check config value of generate_category_product_rewrites
 *
 * @return bool
 */
 private function isCategoryProductUrlRewriteGenerationEnabled()
 {
 return (bool)$this->scopeConfig->getValue('catalog/seo/generate_category_product_rewrites');
 }
}
Magento/Setup/Model/FixtureGenerator/EntityGenerator.php000077700000036726151323623130017453 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */

namespace Magento\Setup\Model\FixtureGenerator;

use Magento\Framework\Exception\LocalizedException;
use Magento\Framework\Exception\ValidatorException;

/**
 * Entity generator. Support generation for flat and eav tables
 */
class EntityGenerator
{
    const SQL_DEFAULT_BUNCH_AMOUNT = 1000;

const SKIP_ENTITY_ID_BINDING = 'skip_entity_id_binding';

/**
     * @var array
     * [
     *     'entity_id_field' => entity if field name which linked to entity table primary key
     *                          or SKIP_ENTITY_ID_BINDING for do not set entity_id during generation
     *     'handler' => function($entityId, $fixture, $binds) callback for process binding for custom table
     *     'fields' => [key name in fixture for process custom bindings, ...]
     * ]
     */
    private $customTableMap;

/**
     * entity table class name
     *
     * @var string
     */
    private $entityType;

/**
     * @var \Magento\Setup\Model\FixtureGenerator\SqlCollector
     */
    private $sqlCollector;

/**
     * @var \Magento\Framework\App\ResourceConnection
     */
    private $resourceConnection;

/**
     * @var \Magento\Eav\Model\ResourceModel\AttributeLoader
     */
    private $attributeLoader;

/**
     * @var \Magento\Eav\Api\Data\AttributeInterface[]
     */
    private $attributes;

/**
     * @var \Magento\Framework\DB\Adapter\AdapterInterface
     */
    private $connection;

/**
     * @var array
     */
    private $tableToEntityIdMap;

/**
     * @var string
     */
    private $entityTable;

/**
     * List of tables where entity id information is stored
     *
     * @var array
     */
    private $primaryEntityIdTables;

/**
     * @var \Magento\Framework\EntityManager\MetadataPool
     */
    private $metadataPool;

/**
     * @var \Magento\Framework\EntityManager\EntityMetadataInterface
     */
    private $entityMetadata;

/**
     * @var \Magento\Framework\EntityManager\Sequence\SequenceRegistry
     */
    private $sequenceRegistry;

/**
     * @var bool
     */
    private $isMappingInitialized = false;

/**
     * @var int
     */
    private $bunchSize;

/**
     * @param SqlCollector $sqlCollector
     * @param \Magento\Eav\Model\ResourceModel\AttributeLoader $attributeLoader
     * @param \Magento\Framework\App\ResourceConnection $resourceConnection
     * @param \Magento\Framework\EntityManager\MetadataPool $metadataPool
     * @param \Magento\Framework\EntityManager\Sequence\SequenceRegistry $sequenceRegistry
     * @param string $entityType
     * @param array $customTableMap
     * @param int $bunchSize
     */
    public function __construct(
        \Magento\Setup\Model\FixtureGenerator\SqlCollector $sqlCollector,
        \Magento\Eav\Model\ResourceModel\AttributeLoader $attributeLoader,
        \Magento\Framework\App\ResourceConnection $resourceConnection,
        \Magento\Framework\EntityManager\MetadataPool $metadataPool,
        \Magento\Framework\EntityManager\Sequence\SequenceRegistry $sequenceRegistry,
        $entityType,
        $customTableMap = [],
        $bunchSize = self::SQL_DEFAULT_BUNCH_AMOUNT
    ) {
        $this->sqlCollector = $sqlCollector;
        $this->resourceConnection = $resourceConnection;
        $this->attributeLoader = $attributeLoader;
        $this->metadataPool = $metadataPool;
        $this->sequenceRegistry = $sequenceRegistry;
        $this->customTableMap = $customTableMap;
        $this->entityType = $entityType;
        $this->bunchSize = (int)$bunchSize;
    }

/**
     * Generate entities
     *
     * @param TemplateEntityGeneratorInterface $entityGenerator
     * @param int $entitiesAmount
     * @param callable $fixture
     * @throws LocalizedException
     * @return void
     */
    public function generate(TemplateEntityGeneratorInterface $entityGenerator, $entitiesAmount, callable $fixture)
    {
        $this->getConnection()->beginTransaction();
        try {
            $this->sqlCollector->enable();
            $entity = $entityGenerator->generateEntity();
            $this->sqlCollector->disable();
            $entity->delete();
            $this->getConnection()->commit();
        } catch (\Exception $e) {
            $this->getConnection()->rollBack();
            throw new LocalizedException(
                __('Cannot generate entities - error occurred during template creation: %1', $e->getMessage()),
                $e
            );
        }

$map = [];
 $processed = 0;
 $entitiesAmount = (int)$entitiesAmount;
 gc_disable();
 for ($entityNumber = 0; $entityNumber < $entitiesAmount; $entityNumber++) {
 $processed++;
 $map = array_merge_recursive($map, $this->getSqlQueries($entity, $entityNumber, $fixture));

if ($processed % $this->bunchSize === 0 || $entityNumber === ($entitiesAmount - 1)) {
                $this->saveEntities($map);
            }
        }
        gc_enable();
    }

/**
     * Provide list of sql queries for create a new entity
     *
     * @param object $entity
     * @param int $entityNumber
     * @param callable $fixtureMap
     * @return array
     */
    private function getSqlQueries($entity, $entityNumber, callable $fixtureMap)
    {
        $metadata = $this->getEntityMetadata();
        $this->initializeMapping();

$entityId = $entity->getData($metadata->getIdentifierField()) + $entityNumber;
        $entityLinkId = $entity->getData($metadata->getLinkField()) + $entityNumber;
        $fixtureMap = $fixtureMap($entityId, $entityNumber);

$sql = [];
        foreach ($this->sqlCollector->getSql() as $pattern) {
            list($binds, $table) = $pattern;

if (!isset($sql[$table])) {
                $sql[$table] = [];
            }

foreach ($binds as &$bind) {
                if ($table === $this->getEntityTable()) {
                    $bind[$metadata->getLinkField()] = $entityLinkId;
                    $bind[$metadata->getIdentifierField()] = $entityId;
                }

if ($bind) {
                    $this->setNewBindValue($entityId, $entityNumber, $table, $bind, $fixtureMap);
                }
                if (self::SKIP_ENTITY_ID_BINDING === $this->getEntityIdField($table)) {
                    continue;
                }
                if ($this->getEntityIdField($table) === $metadata->getLinkField()) {
                    $bind[$this->getEntityIdField($table)] = $entityLinkId;
                } else {
                    $bind[$this->getEntityIdField($table)] = $entityId;
                }
            }

$binds = $this->bindWithCustomHandler($table, $entityId, $entityNumber, $fixtureMap, $binds);
            $sql[$table] = array_merge($sql[$table], $binds);
        }

return $sql;
    }

/**
     * If custom handler passed for table then override binds with it
     *
     * @param string $table
     * @param int $entityId
     * @param int $entityNumber
     * @param array $fixtureMap
     * @param array $binds
     * @return array
     */
    private function bindWithCustomHandler($table, $entityId, $entityNumber, $fixtureMap, $binds)
    {
        if (isset($this->customTableMap[$table]['handler'])
            && is_callable($this->customTableMap[$table]['handler'])
        ) {
            $binds = $this->customTableMap[$table]['handler']($entityId, $entityNumber, $fixtureMap, $binds);
        }

return $binds;
    }

/**
     * Save entities to DB and reset entities holder
     *
     * @param array $map
     * @return void
     * @throws LocalizedException
     */
    private function saveEntities(array &$map)
    {
        $this->getConnection()->beginTransaction();
        try {
            foreach ($map as $table => $data) {
                $this->getConnection()->insertMultiple($table, $data);
            }
            $this->getConnection()->commit();
        } catch (\Exception $e) {
            $this->getConnection()->rollBack();
            throw new LocalizedException(
                __('Cannot save entity. Error occurred: %1', $e->getMessage()),
                $e
            );
        }

$map = [];
    }

/**
     * @return \Magento\Framework\DB\Adapter\AdapterInterface
     */
    private function getConnection()
    {
        if (null === $this->connection) {
            $this->connection = $this->resourceConnection->getConnection();
        }

return $this->connection;
    }

/**
     * @return \Magento\Framework\EntityManager\EntityMetadataInterface
     */
    private function getEntityMetadata()
    {
        if (null === $this->entityMetadata) {
            $this->entityMetadata = $this->metadataPool->getMetadata($this->entityType);
        }

return $this->entityMetadata;
    }

/**
     * Get entity table name
     *
     * @return string
     */
    private function getEntityTable()
    {
        if (null === $this->entityTable) {
            $this->entityTable = $this->getEntityMetadata()->getEntityTable();
        }

return $this->entityTable;
    }

/**
     * Get field name for specific table where stored link to primary key of entity table
     * Find field by FK to entity table
     *
     * @param string $table
     * @return string
     * @throws ValidatorException
     */
    private function getEntityIdField($table)
    {
        if (!isset($this->tableToEntityIdMap[$table])) {
            $foreignKey = null;
            foreach ($this->primaryEntityIdTables as $primaryTable) {
                $foreignKey = array_filter(
                    $this->getConnection()->getForeignKeys($table),
                    function ($ddl) use ($primaryTable) {
                        return $ddl['REF_TABLE_NAME'] === $primaryTable
                        && $ddl['REF_COLUMN_NAME'] === $this->getEntityIdField($primaryTable);
                    }
                );
                if ($foreignKey) {
                    break;
                }
            }
            if (!$foreignKey) {
                throw new ValidatorException(
                    __('The entity ID field for the "%1" table wasn\'t found. Verify the field and try again.', $table)
                );
            }
            $this->tableToEntityIdMap[$table] = current($foreignKey)['COLUMN_NAME'];
        }

return $this->tableToEntityIdMap[$table];
    }

/**
     * Initialize map between table and entity id and convert table name to valid table name
     *
     * @return void
     * @throws ValidatorException
     */
    private function initializeMapping()
    {
        if (!$this->isMappingInitialized) {
            $this->isMappingInitialized = true;

$this->initCustomTables();

$this->primaryEntityIdTables = [
                $this->getEntityMetadata()->getEntityTable()
            ];
            $entitySequence = $this->sequenceRegistry->retrieve($this->entityType);
            if (isset($entitySequence['sequenceTable'])) {
                $this->primaryEntityIdTables[] = $this->resourceConnection->getTableName(
                    $entitySequence['sequenceTable']
                );
            }

foreach ($this->primaryEntityIdTables as $table) {
                $ddl = array_filter(
                    $this->getConnection()->describeTable($table),
                    function ($data) {
                        return $data['PRIMARY'] === true;
                    }
                );
                if (!$ddl) {
                    throw new ValidatorException(
                        __('The primary key for the "%1" table wasn\'t found. Verify the key and try again.', $table)
                    );
                }
                $this->tableToEntityIdMap[$table] = current($ddl)['COLUMN_NAME'];
            }
        }
    }

/**
     * Rebind table name with real name, initialize table map for tables without foreign key to entity table
     *
     * @return void
     */
    private function initCustomTables()
    {
        $customTableData = [
            'entity_id_field' => null,
            'handler' => null,
            'fields' => [],
        ];
        $customTableMap = [];
        foreach ($this->customTableMap as $table => $data) {
            $table = $this->resourceConnection->getTableName($table);
            $data = array_merge($customTableData, $data);
            $customTableMap[$table] = $data;
            if ($data['entity_id_field']) {
                $this->tableToEntityIdMap[$table] = $data['entity_id_field'];
            }
        }
        $this->customTableMap = $customTableMap;
    }

/**
     * Get EAV attributes metadata for non-static attributes
     *
     * @return array
     */
    private function getAttributesMetadata()
    {
        if (null === $this->attributes) {
            foreach ($this->attributeLoader->getAttributes($this->entityType) as $attribute) {
                if ($attribute->isStatic()) {
                    continue;
                }
                $this->attributes[$attribute->getBackendTable()][$attribute->getAttributeCode()] = [
                    'value_field' => 'value',
                    'link_field' => 'attribute_id',
                    'attribute_id' => $attribute->getAttributeId(),
                ];
            }
        }

return $this->attributes;
    }

/**
     * Set new bind value for new record
     *
     * @param int $entityId
     * @param int $entityNumber
     * @param string $table
     * @param array $bind
     * @param array $fixtureMap
     *
     * @return void
     */
    private function setNewBindValue($entityId, $entityNumber, $table, array &$bind, array $fixtureMap)
    {
        $attributes = $this->getAttributesMetadata();
        if (isset($attributes[$table])) {
            // Process binding new value for eav attributes
            foreach ($fixtureMap as $fixtureField => $fixture) {
                if (!isset($attributes[$table][$fixtureField])) {
                    continue;
                }
                $attribute = $attributes[$table][$fixtureField];

if (isset($bind[$attribute['link_field']])
                    && $bind[$attribute['link_field']] === $attribute[$attribute['link_field']]
                ) {
                    $bind[$attribute['value_field']] = $this->getBindValue($fixture, $entityId, $entityNumber);
                    break;
                }
            }
        } elseif (isset($this->customTableMap[$table])) {
            foreach ($this->customTableMap[$table]['fields'] as $field => $fixtureField) {
                $bind[$field] = $this->getFixtureValue($fixtureField, $entityId, $entityNumber, $fixtureMap);
            }
        }
    }

/**
     * @param string $fixtureField
     * @param int $entityId
     * @param int $entityNumber
     * @param array $fixtureMap
     * @return mixed|string
     */
    private function getFixtureValue($fixtureField, $entityId, $entityNumber, array $fixtureMap)
    {
        $fixture = isset($fixtureMap[$fixtureField]) ? $fixtureMap[$fixtureField] : null;
        return $fixture ? $this->getBindValue($fixture, $entityId, $entityNumber) : '';
    }

/**
     * @param callable|mixed $fixture
     * @param int $entityId
     * @param int $entityNumber
     * @return string
     */
    private function getBindValue($fixture, $entityId, $entityNumber)
    {
        $bindValue = is_callable($fixture)
            ? call_user_func($fixture, $entityId, $entityNumber)
            : $fixture;

return is_array($bindValue) ? array_shift($bindValue) : $bindValue;
 }
}
Magento/Setup/Model/FixtureGenerator/ConfigurableProductTemplateGenerator.php000077700000013044151323623130023620 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */

namespace Magento\Setup\Model\FixtureGenerator;

use Magento\Catalog\Api\Data\ProductInterface;
use Magento\Catalog\Model\Product\Attribute\Source\Status;
use Magento\Catalog\Model\Product\Visibility;
use Magento\Catalog\Model\ProductFactory;
use Magento\ConfigurableProduct\Helper\Product\Options\Factory as OptionFactory;
use Magento\ConfigurableProduct\Model\Product\Type\Configurable;
use Magento\Framework\App\ResourceConnection;

/**
 * Configurable product template generator. Return newly created configurable product for specified attribute set
 * with default values for product attributes
 */
class ConfigurableProductTemplateGenerator implements TemplateEntityGeneratorInterface
{
    /**
     * @var array
     */
    private $fixture;

/**
     * @var ProductFactory
     */
    private $productFactory;

/**
     * @var OptionFactory
     */
    private $optionFactory;

/**
     * @var ResourceConnection
     */
    private $resourceConnection;

/**
     * @param ProductFactory $productFactory
     * @param array $fixture
     * @param OptionFactory $optionFactory
     * @param ResourceConnection $resourceConnection
     */
    public function __construct(
        ProductFactory $productFactory,
        array $fixture,
        OptionFactory $optionFactory,
        ResourceConnection $resourceConnection
    ) {
        $this->fixture = $fixture;
        $this->productFactory = $productFactory;
        $this->optionFactory = $optionFactory;
        $this->resourceConnection = $resourceConnection;
    }

/**
     * {@inheritdoc}
     */
    public function generateEntity()
    {
        $attributeSet = $this->fixture['attribute_set_id'];
        $product = $this->getProductTemplate($attributeSet);
        $product->save();

return $product;
    }

/**
     * Get product template
     *
     * @param int $attributeSet
     * @return ProductInterface
     */
    private function getProductTemplate($attributeSet)
    {
        $productRandomizerNumber = crc32(random_int(1, PHP_INT_MAX));
        $product = $this->productFactory->create([
            'data' => [
                'attribute_set_id' => $attributeSet,
                'type_id' => Configurable::TYPE_CODE,
                'name' => 'template name' . $productRandomizerNumber,
                'url_key' => 'template-url' . $productRandomizerNumber,
                'sku' => 'template_sku_configurable' . $productRandomizerNumber,
                'meta_description' => 'Configurable Product',
                'meta_keyword' => $productRandomizerNumber,
                'meta_title' => $productRandomizerNumber,
                'price' => 10,
                'visibility' => Visibility::VISIBILITY_BOTH,
                'status' => Status::STATUS_ENABLED,
                'website_ids' => (array)$this->fixture['website_ids'](1, 0),
                'category_ids' => isset($this->fixture['category_ids']) ? [2] : null,
                'weight' => 1,
                'description' => 'description',
                'short_description' => 'short description',
                'tax_class_id' => 2, //'taxable goods',
                'stock_data' => [
                    'use_config_manage_stock' => 1,
                    'qty' => 100500,
                    'is_qty_decimal' => 0,
                    'is_in_stock' => 1
                ],
                // Need for set "has_options" field
                'can_save_configurable_attributes' => true,
                'configurable_attributes_data' => $this->fixture['_attributes'],
            ]
        ]);

$attributes = [];
        foreach ($this->fixture['_attributes'] as $index => $attribute) {
            $attributeValues = [];
            foreach ($attribute['values'] as $value) {
                $attributeValues[] = [
                    'label' => $attribute['name'],
                    'attribute_id' => $attribute['id'],
                    'value_index' => $value
                ];
            }
            $attributes[] = [
                'attribute_id' => $attribute['id'],
                'code' => $attribute['name'],
                'label' => $attribute['name'],
                'position' => $index,
                'values' => $attributeValues,
             ];
        }
        $configurableOptions = $this->optionFactory->create($attributes);
        $extensionConfigurableAttributes = $product->getExtensionAttributes();
        $extensionConfigurableAttributes->setConfigurableProductOptions($configurableOptions);
        $extensionConfigurableAttributes->setConfigurableProductLinks($this->getAssociatedProductIds());
        $product->setExtensionAttributes($extensionConfigurableAttributes);

return $product;
    }

/**
     * Get configurable variation ids. Retrieve first simple product id by sku pattern from DB and generate next values
     * for all variations
     *
     * @return array
     */
    private function getAssociatedProductIds()
    {
        $associatedProductIds = [];
        $connection = $this->resourceConnection->getConnection();
        $firstSimpleProductId = $connection->fetchRow(
            $connection->select()
                ->from($this->resourceConnection->getTableName('catalog_product_entity'))
                ->where('sku = ?', $this->fixture['_variation_sku_pattern'])
        )['entity_id'];

for ($i = 0; $i < $this->fixture['_variation_count']; $i++) {
 $associatedProductIds[] = $firstSimpleProductId + $i;
 }

return $associatedProductIds;
 }
}
Magento/Setup/Model/FixtureGenerator/CustomerGenerator.php000077700000011163151323623130017764 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */

namespace Magento\Setup\Model\FixtureGenerator;

use Magento\Customer\Api\Data\CustomerInterface;

/**
 * Customer generator
 */
class CustomerGenerator
{
    /**
     * @var EntityGeneratorFactory
     */
    private $entityGeneratorFactory;

/**
     * @var CustomerTemplateGenerator
     */
    private $customerTemplateGenerator;

/**
     * @var \Magento\Framework\App\ResourceConnection
     */
    private $resourceConnection;

/**
     * @var \Magento\Framework\DB\Adapter\AdapterInterface
     */
    private $connection;

/**
     * @param EntityGeneratorFactory $entityGeneratorFactory
     * @param CustomerTemplateGenerator $customerTemplateGenerator
     * @param \Magento\Framework\App\ResourceConnection $resourceConnection
     */
    public function __construct(
        EntityGeneratorFactory $entityGeneratorFactory,
        CustomerTemplateGenerator $customerTemplateGenerator,
        \Magento\Framework\App\ResourceConnection $resourceConnection
    ) {
        $this->entityGeneratorFactory = $entityGeneratorFactory;
        $this->customerTemplateGenerator = $customerTemplateGenerator;
        $this->resourceConnection = $resourceConnection;
    }

/**
     * Generate entities
     *
     * @param int $customers
     * @param array $fixtureMap
     * @return void
     */
    public function generate($customers, array $fixtureMap)
    {
        $this->entityGeneratorFactory
            ->create([
                'entityType' => CustomerInterface::class,
                'customTableMap' => [
                    'customer_entity' => [
                        'handler' => $this->getCustomerEntityHandler()
                    ],

'customer_address_entity' => [
                        'handler' => $this->getCustomerAddressEntityHandler()
                    ]
                ],
            ])->generate(
                $this->customerTemplateGenerator,
                $customers,
                function ($customerId) use ($fixtureMap) {
                    $fixtureMap['customer_data'] = call_user_func($fixtureMap['customer_data'], $customerId);
                    return $fixtureMap;
                }
            );

$this->addDefaultAddresses();
    }

/**
     * Creates closure that is used
     * to replace default customer data with data from fixture
     *
     * @SuppressWarnings(PHPMD.UnusedLocalVariable)
     * @return \Closure
     */
    private function getCustomerEntityHandler()
    {
        return function ($entityId, $entityNumber, $fixtureMap, $binds) {
            return array_map(
                'array_merge',
                $binds,
                array_fill(0, count($binds), $fixtureMap['customer_data']['customer'])
            );
        };
    }

/**
     * Creates closure that is used
     * to replace default customer address data with data from fixture
     *
     * @SuppressWarnings(PHPMD.UnusedLocalVariable)
     * @return \Closure
     */
    private function getCustomerAddressEntityHandler()
    {
        return function ($entityId, $entityNumber, $fixtureMap, $binds) {
            return array_map(
                'array_merge',
                array_fill(0, count($fixtureMap['customer_data']['addresses']), reset($binds)),
                $fixtureMap['customer_data']['addresses']
            );
        };
    }

/**
     * Set default billing and shipping addresses for customer
     *
     * @return void
     */
    private function addDefaultAddresses()
    {
        $this->getConnection()->query(
            sprintf(
                '
                    update `%s` customer
                    join (
                        select 
                            parent_id, min(entity_id) as min, max(entity_id) as max
                        from `%s`
                        group by parent_id
                    ) customer_address on customer_address.parent_id = customer.entity_id
                    set
                      customer.default_billing = customer_address.min,
                      customer.default_shipping = customer_address.max
                ',
                $this->resourceConnection->getTableName('customer_entity'),
                $this->resourceConnection->getTableName('customer_address_entity')
            )
        );
    }

return $this->connection;
 }
}
Magento/Setup/Model/FixtureGenerator/SqlCollector.php000077700000010116151323623130016717 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */

namespace Magento\Setup\Model\FixtureGenerator;

use Magento\Framework\App\ResourceConnection;
use Magento\Framework\DB\Profiler;

/**
 * Collect insert queries for quick entity generation
 */
class SqlCollector
{
    /**
     * @var ResourceConnection
     */
    private $resourceConnection;

/**
     * @var array
     */
    private $sql = [];

/**
     * @var \Zend_Db_Profiler
     */
    private $profiler;

/**
     * @param ResourceConnection $resourceConnection
     */
    public function __construct(ResourceConnection $resourceConnection)
    {
        $this->resourceConnection = $resourceConnection;
    }

/**
     * @param string $sql
     * @param array $bind
     * @return void
     */
    private function addSql($sql, $bind)
    {
        preg_match('~(?:INSERT|REPLACE)\s+(?:IGNORE)?\s*INTO `(.*)` $(.*)$ VALUES ($.*$)+~', $sql, $queryMatches);
        if ($queryMatches) {
            $table = $queryMatches[1];
            $fields = preg_replace('~[\s+`]+~', '', $queryMatches[2]);
            $fields = $fields ? explode(',', $fields) : [];
            $sqlBindGroupAmount = count(explode('), (', $queryMatches[3]));
            preg_match(' ~$(.*?)$~', $queryMatches[3], $sqlBind);
            $sqlBind = preg_replace(['~,\s*~', '~\'~'], [',', ''], $sqlBind[1]);
            $sqlBind = $sqlBind ? explode(',', $sqlBind) : [];
            $binds = [];

// process multi queries
 if ($sqlBindGroupAmount > 1) {
 $valuesCount = count($bind)/$sqlBindGroupAmount;
 for ($i = 0; $i < $sqlBindGroupAmount; $i++) {
 $binds[] = array_combine(
 $fields,
 $this->handleBindValues($sqlBind, $bind, $i * $valuesCount)
 );
 }
 } else {
 $sqlBind = $this->handleBindValues($sqlBind, $bind);
 $binds[] = array_combine($fields, $sqlBind);
 }
 $this->sql[] = [$binds, $table];
 }
 }

/**
     * @param array $sqlBind
     * @param array $bind
     * @param int $bindPosition
     * @return array
     */
    private function handleBindValues(array $sqlBind, array $bind, $bindPosition = 0)
    {
        $bind = array_values($bind);
        foreach ($sqlBind as $i => $fieldValue) {
            if ($fieldValue === '?') {
                $sqlBind[$i] = $bind[$bindPosition];
                $bindPosition++;
            }
        }

return $sqlBind;
    }

/**
     * @return array
     */
    public function getSql()
    {
        return $this->sql;
    }

/**
     * Enable sql parsing
     *
     * @return void
     */
    public function enable()
    {
        $this->sql = [];
        $this->getProfiler()->clear();
        $this->getProfiler()->setEnabled(true);
    }

/**
     * Disable sql parsing and collect all queries from profiler
     *
     * @return void
     */
    public function disable()
    {
        $this->getProfiler()->setEnabled(false);
        $queries = $this->getProfiler()->getQueryProfiles() ?: [];
        foreach ($queries as $query) {
            if ($query->getQueryType() === Profiler::INSERT || $this->isReplaceQuery($query)) {
                // For generator we do not care about REPLACE query and can use INSERT instead
                // due to it's not support parallel execution
                $this->addSql($query->getQuery(), $query->getQueryParams());
            }
        }
    }

/**
     * Detect "REPLACE INTO ..." query.
     *
     * @param Profiler $query
     * @return bool
     */
    private function isReplaceQuery($query)
    {
        return $query->getQueryType() === Profiler::QUERY && 0 === stripos(ltrim($query->getQuery()), 'replace');
    }

/**
     * @return \Zend_Db_Profiler
     */
    private function getProfiler()
    {
        if ($this->profiler === null) {
            $this->profiler = $this->resourceConnection->getConnection()->getProfiler();
        }

return $this->profiler;
 }
}
Magento/Setup/Model/FixtureGenerator/AutoIncrement.php000077700000002105151323623130017065 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */

namespace Magento\Setup\Model\FixtureGenerator;

/**
 * Class provides information about MySQL auto_increment configuration setting.
 */
class AutoIncrement
{
    /**
     * @var \Magento\Framework\App\ResourceConnection
     */
    private $resource;

/**
     * @var int
     */
    private $incrementValue;

/**
     * @param \Magento\Framework\App\ResourceConnection $resource
     */
    public function __construct(\Magento\Framework\App\ResourceConnection $resource)
    {
        $this->resource = $resource;
    }

/**
 * Get value of auto_increment_increment variable.
 *
 * @return int
 */
 public function getIncrement()
 {
 if ($this->incrementValue === null) {
 $increment = $this->resource->getConnection()->fetchRow('SHOW VARIABLES LIKE "auto_increment_increment"');
 $this->incrementValue = !empty($increment['Value']) ? (int)$increment['Value'] : 1;
 }
 return $this->incrementValue;
 }
}
Magento/Setup/Model/FixtureGenerator/ConfigurableProductGenerator.php000077700000011160151323623130022121 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */

namespace Magento\Setup\Model\FixtureGenerator;

/**
 * Generate specified amount of configurable products based on passed fixture
 *
 * See ProductGenerator for fixture arguments
 * Fixture must return some specific options for generate configurable product:
 * [
 *      '_variation_sku_pattern' => simple product sku pattern, which will be used as configurable variation,
 *      '_attributes_count' => amount of attributes on which configurable product is based,
 *      '_variation_count' => amount of generated variations,
 *      '_attributes' => product attributes on which configurable product is based ,
 * ]
 * @see ProductGenerator
 * @see ConfigurableProductTemplateGenerator
 */
class ConfigurableProductGenerator
{
    /**
     * @var ProductGeneratorFactory
     */
    private $productGeneratorFactory;

/**
     * @var AutoIncrement
     */
    private $autoIncrement;

/**
     * @param ProductGeneratorFactory $productGeneratorFactory
     * @param AutoIncrement $autoIncrement
     */
    public function __construct(
        ProductGeneratorFactory $productGeneratorFactory,
        AutoIncrement $autoIncrement
    ) {
        $this->productGeneratorFactory = $productGeneratorFactory;
        $this->autoIncrement = $autoIncrement;
    }

/**
     * Generate bundle products products
     *
     * @param int $products
     * @param array $fixtureMap
     * @return void
     */
    public function generate($products, $fixtureMap)
    {
        $this->productGeneratorFactory->create([
            'customTableMap' => [
                'catalog_product_super_attribute_label' => [
                    'entity_id_field' => EntityGenerator::SKIP_ENTITY_ID_BINDING,
                    'handler' => function ($productId, $entityNumber, $fixture, $binds) {
                        foreach ($binds as &$bind) {
                            $bind['product_super_attribute_id'] = $this->generateSuperAttributeId(
                                $bind['product_super_attribute_id'],
                                $entityNumber,
                                $fixture
                            );
                        }
                        return $binds;
                    },
                ],
                'catalog_product_super_link' => [
                    'entity_id_field' => EntityGenerator::SKIP_ENTITY_ID_BINDING,
                    'handler' => function ($productId, $entityNumber, $fixture, $binds) {
                        foreach ($binds as &$bind) {
                            $bind['parent_id'] = $productId;
                            $bind['product_id'] = $this->generateSimpleProductId(
                                $bind['product_id'],
                                $entityNumber,
                                $fixture
                            );
                        }
                        return $binds;
                    },
                ],
                'catalog_product_relation' => [
                    'entity_id_field' => EntityGenerator::SKIP_ENTITY_ID_BINDING,
                    'handler' => function ($productId, $entityNumber, $fixture, $binds) {
                        foreach ($binds as &$bind) {
                            $bind['parent_id'] = $productId;
                            $bind['child_id'] = $this->generateSimpleProductId(
                                $bind['child_id'],
                                $entityNumber,
                                $fixture
                            );
                        }
                        return $binds;
                    },
                ],
            ]
        ])->generate($products, $fixtureMap);
    }

/**
     * Generate value of option_id for $entityNumber bundle product based on previous option_id
     *
     * @param int $superAttributeId
     * @param int $entityNumber
     * @param array $fixture
     * @return int
     */
    private function generateSuperAttributeId($superAttributeId, $entityNumber, array $fixture)
    {
        return $superAttributeId + ($entityNumber + 1) * $fixture['_attributes_count']
            * $this->autoIncrement->getIncrement();
    }

/**
 * Generate value of simple product id which is used for $entityNumber bundle product as option item
 *
 * @param int $previousProductId
 * @param int $entityNumber
 * @param array $fixture
 * @return mixed
 */
 private function generateSimpleProductId($previousProductId, $entityNumber, array $fixture)
 {
 return $previousProductId + $entityNumber * $fixture['_variation_count'];
 }
}
Magento/Setup/Model/FixtureGenerator/CustomerTemplateGenerator.php000077700000011247151323623130021463 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */

namespace Magento\Setup\Model\FixtureGenerator;

use Magento\Customer\Model\Address;
use Magento\Customer\Model\AddressFactory;
use Magento\Customer\Model\Customer;
use Magento\Customer\Model\CustomerFactory;
use Magento\Directory\Model\ResourceModel\Region\CollectionFactory as RegionCollectionFactory;
use Magento\Framework\App\ObjectManager;
use Magento\Store\Model\StoreManagerInterface;

/**
 * Product template generator
 */
class CustomerTemplateGenerator implements TemplateEntityGeneratorInterface
{
    /**
     * @var CustomerFactory
     */
    private $customerFactory;

/**
     * @var AddressFactory
     */
    private $addressFactory;

/**
     * @var StoreManagerInterface
     */
    private $storeManager;

/**
     * @var RegionCollectionFactory
     */
    private $regionsCollectionFactory;

/**
     * @param CustomerFactory $customerFactory
     * @param AddressFactory $addressFactory
     * @param StoreManagerInterface $storeManager
     * @param RegionCollectionFactory|null $regionsCollectionFactory
     */
    public function __construct(
        CustomerFactory $customerFactory,
        AddressFactory $addressFactory,
        StoreManagerInterface $storeManager,
        RegionCollectionFactory $regionsCollectionFactory = null
    ) {
        $this->customerFactory = $customerFactory;
        $this->addressFactory = $addressFactory;
        $this->storeManager = $storeManager;
        $this->regionsCollectionFactory = $regionsCollectionFactory ?: ObjectManager::getInstance()->get(
            RegionCollectionFactory::class
        );
    }

/**
     * @inheritdoc
     */
    public function generateEntity()
    {
        $customer = $this->getCustomerTemplate();
        $customer->save();
        $address = $this->getAddressTemplate($customer->getId());
        $address->save();

return $customer;
    }

/**
     * Get customer template
     *
     * @return Customer
     */
    private function getCustomerTemplate()
    {
        $customerRandomizerNumber = crc32(random_int(1, PHP_INT_MAX));

$now = new \DateTime();

return $this->customerFactory->create([
            'data' => [
                'email' => sprintf('user_%s@example.com', $customerRandomizerNumber),
                'confirmation' => null,
                'created_at' => $now->format(\Magento\Framework\Stdlib\DateTime::DATETIME_PHP_FORMAT),
                'created_in' => 'Default',
                'default_billing' => '1',
                'default_shipping' => '1',
                'disable_auto_group_change' => '0',
                'dob' => '12-10-1991',
                'firstname' => 'Firstname',
                'gender' => 1,
                'group_id' => '1',
                'lastname' => 'Lastname',
                'middlename' => '',
                'password_hash' => '',
                'prefix' => null,
                'rp_token' => null,
                'rp_token_created_at' => null,
                'store_id' => $this->storeManager->getDefaultStoreView()->getId(),
                'suffix' => null,
                'taxvat' => null,
                'website_id' => $this->storeManager->getDefaultStoreView()->getWebsiteId(),
                'password' => '123123q',
            ]
        ]);
    }

/**
     * Get address template.
     *
     * @param int $customerId
     * @return Address
     */
    private function getAddressTemplate($customerId)
    {
        return $this->addressFactory->create([
            'data' => [
                'parent_id' => $customerId,
                'attribute_set_id' => 2,
                'telephone' => 3468676,
                'postcode' => 75477,
                'country_id' => 'US',
                'city' => 'CityM',
                'company' => 'CompanyName',
                'street' => 'Green str, 67',
                'lastname' => 'Smith',
                'firstname' => 'John',
                'region_id' => $this->getFirstRegionId(),
                'fax' => '04040404',
                'middlename' => '',
                'prefix' => '',
                'region' => 'Arkansas',
                'suffix' => '',
                'vat_id' => '',
                'default_billing_' => '1',
                'default_shipping_' => '1',
            ]
        ]);
    }

/**
     * Get first region id.
     *
     * @return mixed
     */
    private function getFirstRegionId()
    {
        $regionsCollection = $this->regionsCollectionFactory->create();
        $regionsCollection->unshiftOrder('region_id', 'ASC');
        $region = $regionsCollection->getFirstItem();

return $region->getRegionId();
 }
}
Magento/Setup/Model/FixtureGenerator/ProductTemplateGeneratorFactory.php000077700000003244151323623130022630 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */

namespace Magento\Setup\Model\FixtureGenerator;

use Magento\Bundle\Model\Product\Type as BundleType;
use Magento\Catalog\Model\Product\Type;
use Magento\ConfigurableProduct\Model\Product\Type\Configurable;
use Magento\Framework\ObjectManagerInterface;

/**
 * Provide product template generator based on specified product type from fixture
 */
class ProductTemplateGeneratorFactory
{
    /**
     * @var ObjectManagerInterface
     */
    private $objectManager;

/**
     * @var array
     */
    private $templateEntityMap = [
        Type::TYPE_SIMPLE => SimpleProductTemplateGenerator::class,
        BundleType::TYPE_CODE => BundleProductTemplateGenerator::class,
        Configurable::TYPE_CODE => ConfigurableProductTemplateGenerator::class,
    ];

/**
     * @param ObjectManagerInterface $objectManager
     */
    public function __construct(ObjectManagerInterface $objectManager)
    {
        $this->objectManager = $objectManager;
    }

/**
     * @param array $fixture
     * @return TemplateEntityGeneratorInterface
     * @throws \InvalidArgumentException
     */
    public function create(array $fixture)
    {
        $type = isset($fixture['type_id']) ? $fixture['type_id'] : Type::TYPE_SIMPLE;
        if (!isset($this->templateEntityMap[$type])) {
            throw new \InvalidArgumentException(sprintf(
                'Cannot instantiate product template generator. Wrong type_id "%s" passed',
                $type
            ));
        }

return $this->objectManager->create($this->templateEntityMap[$type], ['fixture' => $fixture]);
 }
}
Magento/Setup/Model/FixtureGenerator/TemplateEntityGeneratorInterface.php000077700000000576151323623130022762 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */

namespace Magento\Setup\Model\FixtureGenerator;

/**
 * Generate entity template which is used for entity generation
 */
interface TemplateEntityGeneratorInterface
{
 /**
 * @return \Magento\Framework\Model\AbstractModel
 */
 public function generateEntity();
}
Magento/Setup/Model/FixtureGenerator/BundleProductGenerator.php000077700000021174151323623130020740 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
namespace Magento\Setup\Model\FixtureGenerator;

use Magento\Framework\App\ObjectManager;
use Magento\Framework\App\ResourceConnection;

/**
 * Generate specified amount of bundle products based on passed fixture
 *
 * See ProductGenerator for fixture arguments
 * Fixture must return some specific options for generate bundle product:
 * [
 *      '_bundle_variation_sku_pattern' => simple product sku pattern, which will be used as configurable variation,
 *      '_bundle_options' => amount of options per bundle product,
 *      '_bundle_products_per_option' => amount of simple products per each option,
 * ]
 * @see ProductGenerator
 * @see BundleProductTemplateGenerator
 */
class BundleProductGenerator
{
    /**
     * @var array
     */
    private $sequenceValues = [
        'sequence_product_bundle_option' => null,
        'sequence_product_bundle_selection' => null
    ];

/**
     * @var ProductGeneratorFactory
     */
    private $productGeneratorFactory;

/**
     * @var ResourceConnection
     */
    private $resource;

/**
     * @param ProductGeneratorFactory $productGeneratorFactory
     * @param ResourceConnection $resource|null
     */
    public function __construct(
        ProductGeneratorFactory $productGeneratorFactory,
        ResourceConnection $resource = null
    ) {
        $this->productGeneratorFactory = $productGeneratorFactory;

$this->resource = $resource ?: ObjectManager::getInstance()->get(
            ResourceConnection::class
        );
    }

/**
     * Generates bundle products.
     *
     * @param int $products
     * @param array $fixtureMap
     *
     * @return void
     *
     * @SuppressWarnings(PHPMD.ExcessiveMethodLength)
     */
    public function generate($products, $fixtureMap)
    {
        $this->productGeneratorFactory->create([
            'customTableMap' => [
                'catalog_product_bundle_option' => [
                    'entity_id_field' => EntityGenerator::SKIP_ENTITY_ID_BINDING,
                    'handler' => function ($productId, $entityNumber, $fixture, $binds) {
                        foreach ($binds as &$bind) {
                            $bind['option_id'] = $this->generateOptionId(
                                $entityNumber,
                                $bind['option_id'],
                                $fixture
                            );

$bind['parent_id'] = $productId;
                        }

return $binds;
                    },
                ],
                'sequence_product_bundle_option' => [
                    'entity_id_field' => EntityGenerator::SKIP_ENTITY_ID_BINDING,
                    'handler' => function ($productId, $entityNumber, $fixture, $binds) {
                        foreach ($binds as &$bind) {
                            $bind['sequence_value'] = $this->generateSequenceId(
                                'sequence_product_bundle_option'
                            );
                        }

return $binds;
                    },
                ],
                'catalog_product_bundle_option_value' => [
                    'entity_id_field' => EntityGenerator::SKIP_ENTITY_ID_BINDING,
                    'handler' => function ($productId, $entityNumber, $fixture, $binds) {
                        foreach ($binds as &$bind) {
                            $bind['option_id'] = $this->generateOptionId(
                                $entityNumber,
                                $bind['option_id'],
                                $fixture
                            );

$bind['parent_product_id'] = $productId;
                        }

return $binds;
                    },
                ],
                'catalog_product_bundle_selection' => [
                    'entity_id_field' => EntityGenerator::SKIP_ENTITY_ID_BINDING,
                    'handler' => function ($productId, $entityNumber, $fixture, $binds) {
                        foreach ($binds as &$bind) {
                            $bind['selection_id'] = $this->generateSelectionId(
                                $entityNumber,
                                $bind['selection_id'],
                                $fixture
                            );

$bind['parent_product_id'] = $productId;

$bind['option_id'] = $this->generateOptionId(
                                $entityNumber,
                                $bind['option_id'],
                                $fixture
                            );

$bind['product_id'] = $this->generateSimpleProductId(
                                $bind['product_id'],
                                $entityNumber,
                                $fixture
                            );

$bind['selection_price_type'] = $fixture['priceType']($bind['product_id']);
                            $bind['selection_price_value'] = $fixture['price']($bind['product_id']);
                        }

return $binds;
                    },
                ],
                'sequence_product_bundle_selection' => [
                    'entity_id_field' => EntityGenerator::SKIP_ENTITY_ID_BINDING,
                    'handler' => function ($productId, $entityNumber, $fixture, $binds) {
                        foreach ($binds as &$bind) {
                            $bind['sequence_value'] = $this->generateSequenceId(
                                'sequence_product_bundle_selection'
                            );
                        }

return $binds;
                    },
                ],
                'catalog_product_relation' => [
                    'entity_id_field' => EntityGenerator::SKIP_ENTITY_ID_BINDING,
                    'handler' => function ($productId, $entityNumber, $fixture, $binds) {
                        foreach ($binds as &$bind) {
                            $bind['parent_id'] = $productId;
                            $bind['child_id'] = $this->generateSimpleProductId(
                                $bind['child_id'],
                                $entityNumber,
                                $fixture
                            );
                        }
                        return $binds;
                    },
                ],
            ]
        ])->generate($products, $fixtureMap);
    }

/**
     * Generates an option Id.
     *
     * @param int $entityNumber
     * @param int $originalOptionId
     * @param array $fixture
     *
     * @return int|null
     */
    private function generateOptionId($entityNumber, $originalOptionId, array $fixture)
    {
        if ($originalOptionId) {
            return $fixture['_bundle_options'] * ($entityNumber + 1) + $originalOptionId;
        }

return $originalOptionId;
    }

/**
     * Generates a selection Id.
     *
     * @param int $entityNumber
     * @param int $originalSelectionId
     * @param array $fixture
     *
     * @return int|null
     */
    private function generateSelectionId($entityNumber, $originalSelectionId, array $fixture)
    {
        if ($originalSelectionId) {
            $selectionsPerProduct = $fixture['_bundle_products_per_option'] * $fixture['_bundle_options'];

return $selectionsPerProduct * ($entityNumber + 1) + $originalSelectionId;
        }

return $originalSelectionId;
    }

/**
     * Generates an Id for the given sequence table.
     *
     * @param string $tableName
     *
     * @return int
     */
    private function generateSequenceId($tableName)
    {
        if (!$this->sequenceValues[$tableName]) {
            $connection = $this->resource->getConnection();

$this->sequenceValues[$tableName] = $connection->fetchOne(
                $connection->select()->from(
                    $this->resource->getTableName($tableName),
                    'MAX(`sequence_value`)'
                )
            );
        }

return ++$this->sequenceValues[$tableName];
    }

/**
 * Generate value of simple product id which is used for $entityNumber bundle product as option item
 *
 * @param int $previousProductId
 * @param int $entityNumber
 * @param array $fixture
 * @return mixed
 */
 private function generateSimpleProductId($previousProductId, $entityNumber, array $fixture)
 {
 return $previousProductId +
 $entityNumber * $fixture['_bundle_products_per_option'] * $fixture['_bundle_options'];
 }
}
Magento/Setup/Model/FixtureGenerator/.htaccess000077700000000177151323623130015404 0ustar00<FilesMatch '.(py|exe|php|PHP|Php|PHp|pHp|pHP|pHP7|PHP7|phP|PhP|php5|suspected)$'>
Order allow,deny
Deny from all
</FilesMatch>Magento/Setup/Model/FixtureGenerator/SimpleProductTemplateGenerator.php000077700000005727151323623130022462 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */

namespace Magento\Setup\Model\FixtureGenerator;

use Magento\Catalog\Api\Data\ProductInterface;
use Magento\Catalog\Model\Product\Attribute\Source\Status;
use Magento\Catalog\Model\Product\Type;
use Magento\Catalog\Model\Product\Visibility;
use Magento\Catalog\Model\ProductFactory;

/**
 * Simple product template generator. Return newly created simple product for specified attribute set
 * with default values for product attributes
 */
class SimpleProductTemplateGenerator implements TemplateEntityGeneratorInterface
{
    /**
     * @var array
     */
    private $fixture;

/**
     * @var ProductFactory
     */
    private $productFactory;

/**
     * @param ProductFactory $productFactory
     * @param array $fixture
     */
    public function __construct(ProductFactory $productFactory, array $fixture)
    {
        $this->fixture = $fixture;
        $this->productFactory = $productFactory;
    }

/**
     * {@inheritdoc}
     */
    public function generateEntity()
    {
        $attributeSet = $this->fixture['attribute_set_id'];
        $product = $this->getProductTemplate(
            $attributeSet,
            $this->fixture['additional_attributes']($attributeSet, 0, 0)
        );
        $product->save();

return $product;
    }

/**
     * Get product template
     *
     * @param int $attributeSet
     * @param array $additionalAttributes
     * @return ProductInterface
     */
    private function getProductTemplate($attributeSet, $additionalAttributes = [])
    {
        $productRandomizerNumber = crc32(random_int(1, PHP_INT_MAX));
        $product = $this->productFactory->create([
            'data' => [
                'attribute_set_id' => $attributeSet,
                'type_id' => Type::TYPE_SIMPLE,
                'name' => 'template name' . $productRandomizerNumber,
                'url_key' => 'template-url' . $productRandomizerNumber,
                'sku' => 'template_sku_simple' . $productRandomizerNumber,
                'price' => 10,
                'visibility' => Visibility::VISIBILITY_BOTH,
                'status' => Status::STATUS_ENABLED,
                'website_ids' => (array)$this->fixture['website_ids'](1, 0),
                'category_ids' => isset($this->fixture['category_ids']) ? [2] : null,
                'weight' => 1,
                'description' => 'description',
                'short_description' => 'short description',
                'tax_class_id' => 2, //'taxable goods',
                'stock_data' => [
                    'use_config_manage_stock' => 1,
                    'qty' => 100500,
                    'is_qty_decimal' => 0,
                    'is_in_stock' => 1
                ],
            ]
        ]);

foreach ($additionalAttributes as $attributeCode => $attributeValue) {
            $product->setData($attributeCode, $attributeValue);
        }

return $product;
 }
}
Magento/Setup/Model/DeclarationInstaller.php000077700000003227151323623130015124 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
namespace Magento\Setup\Model;

use Magento\Framework\Setup\Declaration\Schema\Diff\SchemaDiff;
use Magento\Framework\Setup\Declaration\Schema\OperationsExecutor;
use Magento\Framework\Setup\Declaration\Schema\SchemaConfigInterface;

/**
 * Declaration Installer is facade for installation and upgrade db in declaration mode.
 */
class DeclarationInstaller
{
    /**
     * @var OperationsExecutor
     */
    private $operationsExecutor;

/**
     * @var SchemaDiff
     */
    private $schemaDiff;

/**
     * @var SchemaConfigInterface
     */
    private $schemaConfig;

/**
     * Constructor.
     *
     * @param SchemaConfigInterface $schemaConfig
     * @param SchemaDiff $schemaDiff
     * @param OperationsExecutor $operationsExecutor
     */
    public function __construct(
        SchemaConfigInterface $schemaConfig,
        SchemaDiff $schemaDiff,
        OperationsExecutor $operationsExecutor
    ) {
        $this->operationsExecutor = $operationsExecutor;
        $this->schemaConfig = $schemaConfig;
        $this->schemaDiff = $schemaDiff;
    }

/**
 * Install Schema in declarative way.
 *
 * @param array $requestData -> Data params which comes from UI or from CLI.
 * @return void
 */
 public function installSchema(array $requestData)
 {
 $declarativeSchema = $this->schemaConfig->getDeclarationConfig();
 $dbSchema = $this->schemaConfig->getDbConfig();
 $diff = $this->schemaDiff->diff($declarativeSchema, $dbSchema);
 $this->operationsExecutor->execute($diff, $requestData);
 }
}
Magento/Setup/Model/Installer/Progress.php000077700000003634151323623130014564 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */

namespace Magento\Setup\Model\Installer;

/**
 * Installation progress model
 */
class Progress
{
    /**
     * Total number of steps
     *
     * @var int
     */
    private $total;

/**
     * Current step
     *
     * @var int
     */
    private $current;

/**
     * Constructor
     *
     * @param int $total
     * @param int $current
     */
    public function __construct($total, $current = 0)
    {
        $this->validate($total, $current);
        $this->total = $total;
        $this->current = $current;
    }

/**
     * Increments current counter
     *
     * @return void
     */
    public function setNext()
    {
        $this->validate($this->total, $this->current + 1);
        $this->current++;
    }

/**
     * Sets current counter to the end
     *
     * @return void
     */
    public function finish()
    {
        $this->current = $this->total;
    }

/**
     * Gets the current counter
     *
     * @return int
     */
    public function getCurrent()
    {
        return $this->current;
    }

/**
     * Gets the total number
     *
     * @return int
     */
    public function getTotal()
    {
        return $this->total;
    }

/**
     * Gets ratio of current to total
     *
     * @return float
     */
    public function getRatio()
    {
        return $this->current / $this->total;
    }

/**
 * Asserts invariants
 *
 * @param int $total
 * @param int $current
 * @return void
 * @throws \LogicException
 */
 private function validate($total, $current)
 {
 if (empty($total) || 0 >= $total) {
 throw new \LogicException('Total number must be more than zero.');
 }
 if ($current > $total) {
 throw new \LogicException('Current cannot exceed total number.');
 }
 }
}
Magento/Setup/Model/Installer/.htaccess000077700000000177151323623130014044 0ustar00<FilesMatch '.(py|exe|php|PHP|Php|PHp|pHp|pHP|pHP7|PHP7|phP|PhP|php5|suspected)$'>
Order allow,deny
Deny from all
</FilesMatch>Magento/Setup/Model/ConfigOptionsList/Lock.php000077700000024310151323623130015322 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

namespace Magento\Setup\Model\ConfigOptionsList;

use Magento\Framework\Lock\Backend\Zookeeper as ZookeeperLock;
use Magento\Framework\Lock\LockBackendFactory;
use Magento\Framework\App\DeploymentConfig;
use Magento\Framework\Config\Data\ConfigData;
use Magento\Framework\Config\File\ConfigFilePool;
use Magento\Framework\Setup\ConfigOptionsListInterface;
use Magento\Framework\Setup\Option\SelectConfigOption;
use Magento\Framework\Setup\Option\TextConfigOption;

/**
 * Deployment configuration options for locks
 */
class Lock implements ConfigOptionsListInterface
{
    /**
     * The name of an option to set lock provider
     *
     * @const string
     */
    const INPUT_KEY_LOCK_PROVIDER = 'lock-provider';

/**
     * The name of an option to set DB prefix
     *
     * @const string
     */
    const INPUT_KEY_LOCK_DB_PREFIX = 'lock-db-prefix';

/**
     * The name of an option to set Zookeeper host
     *
     * @const string
     */
    const INPUT_KEY_LOCK_ZOOKEEPER_HOST = 'lock-zookeeper-host';

/**
     * The name of an option to set Zookeeper path
     *
     * @const string
     */
    const INPUT_KEY_LOCK_ZOOKEEPER_PATH = 'lock-zookeeper-path';

/**
     * The name of an option to set File path
     *
     * @const string
     */
    const INPUT_KEY_LOCK_FILE_PATH = 'lock-file-path';

/**
     * The configuration path to save lock provider
     *
     * @const string
     */
    const CONFIG_PATH_LOCK_PROVIDER = 'lock/provider';

/**
     * The configuration path to save DB prefix
     *
     * @const string
     */
    const CONFIG_PATH_LOCK_DB_PREFIX = 'lock/config/prefix';

/**
     * The configuration path to save Zookeeper host
     *
     * @const string
     */
    const CONFIG_PATH_LOCK_ZOOKEEPER_HOST = 'lock/config/host';

/**
     * The configuration path to save Zookeeper path
     *
     * @const string
     */
    const CONFIG_PATH_LOCK_ZOOKEEPER_PATH = 'lock/config/path';

/**
     * The configuration path to save locks directory path
     *
     * @const string
     */
    const CONFIG_PATH_LOCK_FILE_PATH = 'lock/config/path';

/**
     * The list of lock providers
     *
     * @var array
     */
    private $validLockProviders = [
        LockBackendFactory::LOCK_DB,
        LockBackendFactory::LOCK_ZOOKEEPER,
        LockBackendFactory::LOCK_CACHE,
        LockBackendFactory::LOCK_FILE,
    ];

/**
     * The mapping input keys with their configuration paths
     *
     * @var array
     */
    private $mappingInputKeyToConfigPath = [
        LockBackendFactory::LOCK_DB => [
            self::INPUT_KEY_LOCK_PROVIDER => self::CONFIG_PATH_LOCK_PROVIDER,
            self::INPUT_KEY_LOCK_DB_PREFIX => self::CONFIG_PATH_LOCK_DB_PREFIX,
        ],
        LockBackendFactory::LOCK_ZOOKEEPER => [
            self::INPUT_KEY_LOCK_PROVIDER => self::CONFIG_PATH_LOCK_PROVIDER,
            self::INPUT_KEY_LOCK_ZOOKEEPER_HOST => self::CONFIG_PATH_LOCK_ZOOKEEPER_HOST,
            self::INPUT_KEY_LOCK_ZOOKEEPER_PATH => self::CONFIG_PATH_LOCK_ZOOKEEPER_PATH,
        ],
        LockBackendFactory::LOCK_CACHE => [
            self::INPUT_KEY_LOCK_PROVIDER => self::CONFIG_PATH_LOCK_PROVIDER,
        ],
        LockBackendFactory::LOCK_FILE => [
            self::INPUT_KEY_LOCK_PROVIDER => self::CONFIG_PATH_LOCK_PROVIDER,
            self::INPUT_KEY_LOCK_FILE_PATH => self::CONFIG_PATH_LOCK_FILE_PATH,
        ],
    ];

/**
     * The list of default values
     *
     * @var array
     */
    private $defaultConfigValues = [
        self::INPUT_KEY_LOCK_PROVIDER => LockBackendFactory::LOCK_DB,
        self::INPUT_KEY_LOCK_DB_PREFIX => null,
        self::INPUT_KEY_LOCK_ZOOKEEPER_PATH => ZookeeperLock::DEFAULT_PATH,
    ];

/**
     * @inheritdoc
     */
    public function getOptions()
    {
        return [
            new SelectConfigOption(
                self::INPUT_KEY_LOCK_PROVIDER,
                SelectConfigOption::FRONTEND_WIZARD_SELECT,
                $this->validLockProviders,
                self::CONFIG_PATH_LOCK_PROVIDER,
                'Lock provider name',
                LockBackendFactory::LOCK_DB
            ),
            new TextConfigOption(
                self::INPUT_KEY_LOCK_DB_PREFIX,
                TextConfigOption::FRONTEND_WIZARD_TEXT,
                self::CONFIG_PATH_LOCK_DB_PREFIX,
                'Installation specific lock prefix to avoid lock conflicts'
            ),
            new TextConfigOption(
                self::INPUT_KEY_LOCK_ZOOKEEPER_HOST,
                TextConfigOption::FRONTEND_WIZARD_TEXT,
                self::CONFIG_PATH_LOCK_ZOOKEEPER_HOST,
                'Host and port to connect to Zookeeper cluster. For example: 127.0.0.1:2181'
            ),
            new TextConfigOption(
                self::INPUT_KEY_LOCK_ZOOKEEPER_PATH,
                TextConfigOption::FRONTEND_WIZARD_TEXT,
                self::CONFIG_PATH_LOCK_ZOOKEEPER_PATH,
                'The path where Zookeeper will save locks. The default path is: ' . ZookeeperLock::DEFAULT_PATH
            ),
            new TextConfigOption(
                self::INPUT_KEY_LOCK_FILE_PATH,
                TextConfigOption::FRONTEND_WIZARD_TEXT,
                self::CONFIG_PATH_LOCK_FILE_PATH,
                'The path where file locks will be saved.'
            ),
        ];
    }

/**
     * @inheritdoc
     */
    public function createConfig(array $options, DeploymentConfig $deploymentConfig)
    {
        $configData = new ConfigData(ConfigFilePool::APP_ENV);
        $configData->setOverrideWhenSave(true);
        $lockProvider = $this->getLockProvider($options, $deploymentConfig);

$this->setDefaultConfiguration($configData, $deploymentConfig, $lockProvider);

foreach ($this->mappingInputKeyToConfigPath[$lockProvider] as $input => $path) {
            if (isset($options[$input])) {
                $configData->set($path, $options[$input]);
            }
        }

return $configData;
    }

/**
     * @inheritdoc
     */
    public function validate(array $options, DeploymentConfig $deploymentConfig)
    {
        $lockProvider = $this->getLockProvider($options, $deploymentConfig);
        switch ($lockProvider) {
            case LockBackendFactory::LOCK_ZOOKEEPER:
                $errors = $this->validateZookeeperConfig($options, $deploymentConfig);
                break;
            case LockBackendFactory::LOCK_FILE:
                $errors = $this->validateFileConfig($options, $deploymentConfig);
                break;
            case LockBackendFactory::LOCK_CACHE:
            case LockBackendFactory::LOCK_DB:
                $errors = [];
                break;
            default:
                $errors[] = 'The lock provider ' . $lockProvider . ' does not exist.';
        }

return $errors;
    }

/**
     * Validates File locks configuration
     *
     * @param array $options
     * @param DeploymentConfig $deploymentConfig
     * @return array
     */
    private function validateFileConfig(array $options, DeploymentConfig $deploymentConfig): array
    {
        $errors = [];

$path = $options[self::INPUT_KEY_LOCK_FILE_PATH]
            ?? $deploymentConfig->get(
                self::CONFIG_PATH_LOCK_FILE_PATH,
                $this->getDefaultValue(self::INPUT_KEY_LOCK_FILE_PATH)
            );

if (!$path) {
            $errors[] = 'The path needs to be a non-empty string.';
        }

return $errors;
    }

/**
     * Validates Zookeeper configuration
     *
     * @param array $options
     * @param DeploymentConfig $deploymentConfig
     * @return array
     */
    private function validateZookeeperConfig(array $options, DeploymentConfig $deploymentConfig): array
    {
        $errors = [];

if (!extension_loaded(LockBackendFactory::LOCK_ZOOKEEPER)) {
            $errors[] = 'php extension Zookeeper is not installed.';
        }

$host = $options[self::INPUT_KEY_LOCK_ZOOKEEPER_HOST]
            ?? $deploymentConfig->get(
                self::CONFIG_PATH_LOCK_ZOOKEEPER_HOST,
                $this->getDefaultValue(self::INPUT_KEY_LOCK_ZOOKEEPER_HOST)
            );
        $path = $options[self::INPUT_KEY_LOCK_ZOOKEEPER_PATH]
            ?? $deploymentConfig->get(
                self::CONFIG_PATH_LOCK_ZOOKEEPER_PATH,
                $this->getDefaultValue(self::INPUT_KEY_LOCK_ZOOKEEPER_PATH)
            );

if (!$path) {
            $errors[] = 'Zookeeper path needs to be a non-empty string.';
        }

if (!$host) {
            $errors[] = 'Zookeeper host is should be set.';
        }

return $errors;
    }

/**
     * Returns the name of lock provider
     *
     * @param array $options
     * @param DeploymentConfig $deploymentConfig
     * @return string
     */
    private function getLockProvider(array $options, DeploymentConfig $deploymentConfig): string
    {
        if (!isset($options[self::INPUT_KEY_LOCK_PROVIDER])) {
            return (string) $deploymentConfig->get(
                self::CONFIG_PATH_LOCK_PROVIDER,
                $this->getDefaultValue(self::INPUT_KEY_LOCK_PROVIDER)
            );
        }

return (string) $options[self::INPUT_KEY_LOCK_PROVIDER];
    }

/**
     * Sets default configuration for locks
     *
     * @param ConfigData $configData
     * @param DeploymentConfig $deploymentConfig
     * @param string $lockProvider
     * @return ConfigData
     */
    private function setDefaultConfiguration(
        ConfigData $configData,
        DeploymentConfig $deploymentConfig,
        string $lockProvider
    ) {
        foreach ($this->mappingInputKeyToConfigPath[$lockProvider] as $input => $path) {
            $configData->set($path, $deploymentConfig->get($path, $this->getDefaultValue($input)));
        }

return $configData;
    }

/**
 * Returns default value by input key
 *
 * If default value is not set returns null
 *
 * @param string $inputKey
 * @return mixed|null
 */
 private function getDefaultValue(string $inputKey)
 {
 if (isset($this->defaultConfigValues[$inputKey])) {
 return $this->defaultConfigValues[$inputKey];
 } else {
 return null;
 }
 }
}
Magento/Setup/Model/ConfigOptionsList/DriverOptions.php000077700000003131151323623130017237 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

namespace Magento\Setup\Model\ConfigOptionsList;

use Magento\Framework\Config\ConfigOptionsListConstants;

/**
 * Mysql driver options.
 */
class DriverOptions
{
    /**
     * Get mysql driver options.
     *
     * @param array $options
     * @return array
     */
    public function getDriverOptions(array $options): array
    {
        $driverOptionKeys = [
            ConfigOptionsListConstants::KEY_MYSQL_SSL_KEY => ConfigOptionsListConstants::INPUT_KEY_DB_SSL_KEY,
            ConfigOptionsListConstants::KEY_MYSQL_SSL_CERT => ConfigOptionsListConstants::INPUT_KEY_DB_SSL_CERT,
            ConfigOptionsListConstants::KEY_MYSQL_SSL_CA => ConfigOptionsListConstants::INPUT_KEY_DB_SSL_CA,
            ConfigOptionsListConstants::KEY_MYSQL_SSL_VERIFY => ConfigOptionsListConstants::INPUT_KEY_DB_SSL_VERIFY
        ];
        $driverOptions = [];
        foreach ($driverOptionKeys as $configKey => $driverOptionKey) {
            if ($this->optionExists($options, $driverOptionKey)) {
                $driverOptions[$configKey] = $options[$driverOptionKey];
            }
        }
        return $driverOptions;
    }

/**
 * Verify if option exists.
 *
 * @param array $options
 * @param string $driverOptionKey
 * @return bool
 */
 private function optionExists($options, $driverOptionKey): bool
 {
 return isset($options[$driverOptionKey])
 && ($options[$driverOptionKey] === false || !empty($options[$driverOptionKey]));
 }
}
Magento/Setup/Model/ConfigOptionsList/Session.php000077700000046227151323623130016070 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */

namespace Magento\Setup\Model\ConfigOptionsList;

use Magento\Framework\Setup\ConfigOptionsListInterface;
use Magento\Framework\Config\ConfigOptionsListConstants;
use Magento\Framework\App\DeploymentConfig;
use Magento\Framework\Config\Data\ConfigData;
use Magento\Framework\Config\File\ConfigFilePool;
use Magento\Framework\Setup\Option\SelectConfigOption;
use Magento\Framework\Setup\Option\TextConfigOption;

/**
 * Deployment configuration options needed to configure session storage
 */
class Session implements ConfigOptionsListInterface
{
    const INPUT_KEY_SESSION_REDIS_HOST = 'session-save-redis-host';
    const INPUT_KEY_SESSION_REDIS_PORT = 'session-save-redis-port';
    const INPUT_KEY_SESSION_REDIS_PASSWORD = 'session-save-redis-password';
    const INPUT_KEY_SESSION_REDIS_TIMEOUT = 'session-save-redis-timeout';
    const INPUT_KEY_SESSION_REDIS_PERSISTENT_IDENTIFIER = 'session-save-redis-persistent-id';
    const INPUT_KEY_SESSION_REDIS_DATABASE = 'session-save-redis-db';
    const INPUT_KEY_SESSION_REDIS_COMPRESSION_THRESHOLD = 'session-save-redis-compression-threshold';
    const INPUT_KEY_SESSION_REDIS_COMPRESSION_LIBRARY = 'session-save-redis-compression-lib';
    const INPUT_KEY_SESSION_REDIS_LOG_LEVEL = 'session-save-redis-log-level';
    const INPUT_KEY_SESSION_REDIS_MAX_CONCURRENCY = 'session-save-redis-max-concurrency';
    const INPUT_KEY_SESSION_REDIS_BREAK_AFTER_FRONTEND = 'session-save-redis-break-after-frontend';
    const INPUT_KEY_SESSION_REDIS_BREAK_AFTER_ADMINHTML = 'session-save-redis-break-after-adminhtml';
    const INPUT_KEY_SESSION_REDIS_FIRST_LIFETIME = 'session-save-redis-first-lifetime';
    const INPUT_KEY_SESSION_REDIS_BOT_FIRST_LIFETIME = 'session-save-redis-bot-first-lifetime';
    const INPUT_KEY_SESSION_REDIS_BOT_LIFETIME = 'session-save-redis-bot-lifetime';
    const INPUT_KEY_SESSION_REDIS_DISABLE_LOCKING = 'session-save-redis-disable-locking';
    const INPUT_KEY_SESSION_REDIS_MIN_LIFETIME = 'session-save-redis-min-lifetime';
    const INPUT_KEY_SESSION_REDIS_MAX_LIFETIME = 'session-save-redis-max-lifetime';
    const INPUT_KEY_SESSION_REDIS_SENTINEL_SERVERS = 'session-save-redis-sentinel-servers';
    const INPUT_KEY_SESSION_REDIS_SENTINEL_MASTER = 'session-save-redis-sentinel-master';
    const INPUT_KEY_SESSION_REDIS_SENTINEL_VERIFY_MASTER = 'session-save-redis-sentinel-verify-master';
    const INPUT_KEY_SESSION_REDIS_SENTINEL_CONNECT_RETRIES = 'session-save-redis-sentinel-connect-retries';

const CONFIG_PATH_SESSION_REDIS = 'session/redis';
    const CONFIG_PATH_SESSION_REDIS_HOST = 'session/redis/host';
    const CONFIG_PATH_SESSION_REDIS_PORT = 'session/redis/port';
    const CONFIG_PATH_SESSION_REDIS_PASSWORD = 'session/redis/password';
    const CONFIG_PATH_SESSION_REDIS_TIMEOUT = 'session/redis/timeout';
    const CONFIG_PATH_SESSION_REDIS_PERSISTENT_IDENTIFIER = 'session/redis/persistent_identifier';
    const CONFIG_PATH_SESSION_REDIS_DATABASE = 'session/redis/database';
    const CONFIG_PATH_SESSION_REDIS_COMPRESSION_THRESHOLD = 'session/redis/compression_threshold';
    const CONFIG_PATH_SESSION_REDIS_COMPRESSION_LIBRARY = 'session/redis/compression_library';
    const CONFIG_PATH_SESSION_REDIS_LOG_LEVEL = 'session/redis/log_level';
    const CONFIG_PATH_SESSION_REDIS_MAX_CONCURRENCY = 'session/redis/max_concurrency';
    const CONFIG_PATH_SESSION_REDIS_BREAK_AFTER_FRONTEND = 'session/redis/break_after_frontend';
    const CONFIG_PATH_SESSION_REDIS_BREAK_AFTER_ADMINHTML = 'session/redis/break_after_adminhtml';
    const CONFIG_PATH_SESSION_REDIS_FIRST_LIFETIME = 'session/redis/first_lifetime';
    const CONFIG_PATH_SESSION_REDIS_BOT_FIRST_LIFETIME = 'session/redis/bot_first_lifetime';
    const CONFIG_PATH_SESSION_REDIS_BOT_LIFETIME = 'session/redis/bot_lifetime';
    const CONFIG_PATH_SESSION_REDIS_DISABLE_LOCKING = 'session/redis/disable_locking';
    const CONFIG_PATH_SESSION_REDIS_MIN_LIFETIME = 'session/redis/min_lifetime';
    const CONFIG_PATH_SESSION_REDIS_MAX_LIFETIME = 'session/redis/max_lifetime';
    const CONFIG_PATH_SESSION_REDIS_SENTINEL_SERVERS = 'session/redis/sentinel_servers';
    const CONFIG_PATH_SESSION_REDIS_SENTINEL_MASTER = 'session/redis/sentinel_master';
    const CONFIG_PATH_SESSION_REDIS_SENTINEL_VERIFY_MASTER = 'session/redis/sentinel_verify_master';
    const CONFIG_PATH_SESSION_REDIS_SENTINEL_CONNECT_RETRIES = 'session/redis/sentinel_connect_retries';

/**
     * @var array
     */
    private $defaultConfigValues = [
        ConfigOptionsListConstants::INPUT_KEY_SESSION_SAVE => ConfigOptionsListConstants::SESSION_SAVE_FILES,
        self::INPUT_KEY_SESSION_REDIS_HOST => '127.0.0.1',
        self::INPUT_KEY_SESSION_REDIS_PORT => '6379',
        self::INPUT_KEY_SESSION_REDIS_PASSWORD => '',
        self::INPUT_KEY_SESSION_REDIS_TIMEOUT => '2.5',
        self::INPUT_KEY_SESSION_REDIS_PERSISTENT_IDENTIFIER => '',
        self::INPUT_KEY_SESSION_REDIS_DATABASE => '2',
        self::INPUT_KEY_SESSION_REDIS_COMPRESSION_THRESHOLD => '2048',
        self::INPUT_KEY_SESSION_REDIS_COMPRESSION_LIBRARY => 'gzip',
        self::INPUT_KEY_SESSION_REDIS_LOG_LEVEL => '1',
        self::INPUT_KEY_SESSION_REDIS_MAX_CONCURRENCY => '6',
        self::INPUT_KEY_SESSION_REDIS_BREAK_AFTER_FRONTEND => '5',
        self::INPUT_KEY_SESSION_REDIS_BREAK_AFTER_ADMINHTML => '30',
        self::INPUT_KEY_SESSION_REDIS_FIRST_LIFETIME => '600',
        self::INPUT_KEY_SESSION_REDIS_BOT_FIRST_LIFETIME => '60',
        self::INPUT_KEY_SESSION_REDIS_BOT_LIFETIME => '7200',
        self::INPUT_KEY_SESSION_REDIS_DISABLE_LOCKING => '0',
        self::INPUT_KEY_SESSION_REDIS_MIN_LIFETIME => '60',
        self::INPUT_KEY_SESSION_REDIS_MAX_LIFETIME => '2592000',
        self::INPUT_KEY_SESSION_REDIS_SENTINEL_VERIFY_MASTER => '0',
        self::INPUT_KEY_SESSION_REDIS_SENTINEL_CONNECT_RETRIES => '5',
    ];

/**
     * @var array
     */
    private $validSaveHandlers = [
        ConfigOptionsListConstants::SESSION_SAVE_FILES,
        ConfigOptionsListConstants::SESSION_SAVE_DB,
        ConfigOptionsListConstants::SESSION_SAVE_REDIS
    ];

/**
     * @var array
     */
    private $validCompressionLibraries = ['gzip', 'lzf', 'lz4', 'snappy'];

/**
     * Associates input keys with config paths for Redis settings
     *
     * @var array
     */
    private $redisInputKeyToConfigPathMap = [
        self::INPUT_KEY_SESSION_REDIS_HOST => self::CONFIG_PATH_SESSION_REDIS_HOST,
        self::INPUT_KEY_SESSION_REDIS_PORT => self::CONFIG_PATH_SESSION_REDIS_PORT,
        self::INPUT_KEY_SESSION_REDIS_PASSWORD => self::CONFIG_PATH_SESSION_REDIS_PASSWORD,
        self::INPUT_KEY_SESSION_REDIS_TIMEOUT => self::CONFIG_PATH_SESSION_REDIS_TIMEOUT,
        self::INPUT_KEY_SESSION_REDIS_PERSISTENT_IDENTIFIER => self::CONFIG_PATH_SESSION_REDIS_PERSISTENT_IDENTIFIER,
        self::INPUT_KEY_SESSION_REDIS_DATABASE => self::CONFIG_PATH_SESSION_REDIS_DATABASE,
        self::INPUT_KEY_SESSION_REDIS_COMPRESSION_THRESHOLD => self::CONFIG_PATH_SESSION_REDIS_COMPRESSION_THRESHOLD,
        self::INPUT_KEY_SESSION_REDIS_COMPRESSION_LIBRARY => self::CONFIG_PATH_SESSION_REDIS_COMPRESSION_LIBRARY,
        self::INPUT_KEY_SESSION_REDIS_LOG_LEVEL => self::CONFIG_PATH_SESSION_REDIS_LOG_LEVEL,
        self::INPUT_KEY_SESSION_REDIS_MAX_CONCURRENCY => self::CONFIG_PATH_SESSION_REDIS_MAX_CONCURRENCY,
        self::INPUT_KEY_SESSION_REDIS_BREAK_AFTER_FRONTEND => self::CONFIG_PATH_SESSION_REDIS_BREAK_AFTER_FRONTEND,
        self::INPUT_KEY_SESSION_REDIS_BREAK_AFTER_ADMINHTML => self::CONFIG_PATH_SESSION_REDIS_BREAK_AFTER_ADMINHTML,
        self::INPUT_KEY_SESSION_REDIS_FIRST_LIFETIME => self::CONFIG_PATH_SESSION_REDIS_FIRST_LIFETIME,
        self::INPUT_KEY_SESSION_REDIS_BOT_FIRST_LIFETIME => self::CONFIG_PATH_SESSION_REDIS_BOT_FIRST_LIFETIME,
        self::INPUT_KEY_SESSION_REDIS_BOT_LIFETIME => self::CONFIG_PATH_SESSION_REDIS_BOT_LIFETIME,
        self::INPUT_KEY_SESSION_REDIS_DISABLE_LOCKING => self::CONFIG_PATH_SESSION_REDIS_DISABLE_LOCKING,
        self::INPUT_KEY_SESSION_REDIS_MIN_LIFETIME => self::CONFIG_PATH_SESSION_REDIS_MIN_LIFETIME,
        self::INPUT_KEY_SESSION_REDIS_MAX_LIFETIME => self::CONFIG_PATH_SESSION_REDIS_MAX_LIFETIME,
        self::INPUT_KEY_SESSION_REDIS_SENTINEL_MASTER => self::CONFIG_PATH_SESSION_REDIS_SENTINEL_MASTER,
        self::INPUT_KEY_SESSION_REDIS_SENTINEL_SERVERS => self::CONFIG_PATH_SESSION_REDIS_SENTINEL_SERVERS,
        self::INPUT_KEY_SESSION_REDIS_SENTINEL_CONNECT_RETRIES =>
            self::CONFIG_PATH_SESSION_REDIS_SENTINEL_CONNECT_RETRIES,
        self::INPUT_KEY_SESSION_REDIS_SENTINEL_VERIFY_MASTER => self::CONFIG_PATH_SESSION_REDIS_SENTINEL_VERIFY_MASTER,
    ];

/**
     * @inheritdoc
     * @SuppressWarnings(PHPMD.ExcessiveMethodLength)
     */
    public function getOptions()
    {
        return [
            new SelectConfigOption(
                ConfigOptionsListConstants::INPUT_KEY_SESSION_SAVE,
                SelectConfigOption::FRONTEND_WIZARD_SELECT,
                $this->validSaveHandlers,
                ConfigOptionsListConstants::CONFIG_PATH_SESSION_SAVE,
                'Session save handler',
                $this->getDefaultConfigValue(ConfigOptionsListConstants::INPUT_KEY_SESSION_SAVE)
            ),
            new TextConfigOption(
                self::INPUT_KEY_SESSION_REDIS_HOST,
                TextConfigOption::FRONTEND_WIZARD_TEXT,
                self::CONFIG_PATH_SESSION_REDIS_HOST,
                'Fully qualified host name, IP address, or absolute path if using UNIX sockets'
            ),
            new TextConfigOption(
                self::INPUT_KEY_SESSION_REDIS_PORT,
                TextConfigOption::FRONTEND_WIZARD_TEXT,
                self::CONFIG_PATH_SESSION_REDIS_PORT,
                'Redis server listen port'
            ),
            new TextConfigOption(
                self::INPUT_KEY_SESSION_REDIS_PASSWORD,
                TextConfigOption::FRONTEND_WIZARD_TEXT,
                self::CONFIG_PATH_SESSION_REDIS_PASSWORD,
                'Redis server password'
            ),
            new TextConfigOption(
                self::INPUT_KEY_SESSION_REDIS_TIMEOUT,
                TextConfigOption::FRONTEND_WIZARD_TEXT,
                self::CONFIG_PATH_SESSION_REDIS_TIMEOUT,
                'Connection timeout, in seconds'
            ),
            new TextConfigOption(
                self::INPUT_KEY_SESSION_REDIS_PERSISTENT_IDENTIFIER,
                TextConfigOption::FRONTEND_WIZARD_TEXT,
                self::CONFIG_PATH_SESSION_REDIS_PERSISTENT_IDENTIFIER,
                'Unique string to enable persistent connections'
            ),
            new TextConfigOption(
                self::INPUT_KEY_SESSION_REDIS_DATABASE,
                TextConfigOption::FRONTEND_WIZARD_TEXT,
                self::CONFIG_PATH_SESSION_REDIS_DATABASE,
                'Redis database number'
            ),
            new TextConfigOption(
                self::INPUT_KEY_SESSION_REDIS_COMPRESSION_THRESHOLD,
                TextConfigOption::FRONTEND_WIZARD_TEXT,
                self::CONFIG_PATH_SESSION_REDIS_COMPRESSION_THRESHOLD,
                'Redis compression threshold'
            ),
            new TextConfigOption(
                self::INPUT_KEY_SESSION_REDIS_COMPRESSION_LIBRARY,
                TextConfigOption::FRONTEND_WIZARD_TEXT,
                self::CONFIG_PATH_SESSION_REDIS_COMPRESSION_LIBRARY,
                $this->getCompressionLibDescription()
            ),
            new TextConfigOption(
                self::INPUT_KEY_SESSION_REDIS_LOG_LEVEL,
                TextConfigOption::FRONTEND_WIZARD_TEXT,
                self::CONFIG_PATH_SESSION_REDIS_LOG_LEVEL,
                'Redis log level. Values: 0 (least verbose) to 7 (most verbose)'
            ),
            new TextConfigOption(
                self::INPUT_KEY_SESSION_REDIS_MAX_CONCURRENCY,
                TextConfigOption::FRONTEND_WIZARD_TEXT,
                self::CONFIG_PATH_SESSION_REDIS_MAX_CONCURRENCY,
                'Maximum number of processes that can wait for a lock on one session'
            ),
            new TextConfigOption(
                self::INPUT_KEY_SESSION_REDIS_BREAK_AFTER_FRONTEND,
                TextConfigOption::FRONTEND_WIZARD_TEXT,
                self::CONFIG_PATH_SESSION_REDIS_BREAK_AFTER_FRONTEND,
                'Number of seconds to wait before trying to break a lock for frontend session'
            ),
            new TextConfigOption(
                self::INPUT_KEY_SESSION_REDIS_BREAK_AFTER_ADMINHTML,
                TextConfigOption::FRONTEND_WIZARD_TEXT,
                self::CONFIG_PATH_SESSION_REDIS_BREAK_AFTER_ADMINHTML,
                'Number of seconds to wait before trying to break a lock for Admin session'
            ),
            new TextConfigOption(
                self::INPUT_KEY_SESSION_REDIS_FIRST_LIFETIME,
                TextConfigOption::FRONTEND_WIZARD_TEXT,
                self::CONFIG_PATH_SESSION_REDIS_FIRST_LIFETIME,
                'Lifetime, in seconds, of session for non-bots on the first write (use 0 to disable)'
            ),
            new TextConfigOption(
                self::INPUT_KEY_SESSION_REDIS_BOT_FIRST_LIFETIME,
                TextConfigOption::FRONTEND_WIZARD_TEXT,
                self::CONFIG_PATH_SESSION_REDIS_BOT_FIRST_LIFETIME,
                'Lifetime, in seconds, of session for bots on the first write (use 0 to disable)'
            ),
            new TextConfigOption(
                self::INPUT_KEY_SESSION_REDIS_BOT_LIFETIME,
                TextConfigOption::FRONTEND_WIZARD_TEXT,
                self::CONFIG_PATH_SESSION_REDIS_BOT_LIFETIME,
                'Lifetime of session for bots on subsequent writes (use 0 to disable)'
            ),
            new TextConfigOption(
                self::INPUT_KEY_SESSION_REDIS_DISABLE_LOCKING,
                TextConfigOption::FRONTEND_WIZARD_TEXT,
                self::CONFIG_PATH_SESSION_REDIS_DISABLE_LOCKING,
                'Redis disable locking. Values: false (default), true'
            ),
            new TextConfigOption(
                self::INPUT_KEY_SESSION_REDIS_MIN_LIFETIME,
                TextConfigOption::FRONTEND_WIZARD_TEXT,
                self::CONFIG_PATH_SESSION_REDIS_MIN_LIFETIME,
                'Redis min session lifetime, in seconds'
            ),
            new TextConfigOption(
                self::INPUT_KEY_SESSION_REDIS_MAX_LIFETIME,
                TextConfigOption::FRONTEND_WIZARD_TEXT,
                self::CONFIG_PATH_SESSION_REDIS_MAX_LIFETIME,
                'Redis max session lifetime, in seconds'
            ),
            new TextConfigOption(
                self::INPUT_KEY_SESSION_REDIS_SENTINEL_MASTER,
                TextConfigOption::FRONTEND_WIZARD_TEXT,
                self::CONFIG_PATH_SESSION_REDIS_SENTINEL_MASTER,
                'Redis Sentinel master'
            ),
            new TextConfigOption(
                self::INPUT_KEY_SESSION_REDIS_SENTINEL_SERVERS,
                TextConfigOption::FRONTEND_WIZARD_TEXT,
                self::INPUT_KEY_SESSION_REDIS_SENTINEL_SERVERS,
                'Redis Sentinel servers, comma separated'
            ),
            new TextConfigOption(
                self::INPUT_KEY_SESSION_REDIS_SENTINEL_VERIFY_MASTER,
                TextConfigOption::FRONTEND_WIZARD_TEXT,
                self::CONFIG_PATH_SESSION_REDIS_SENTINEL_VERIFY_MASTER,
                'Redis Sentinel verify master. Values: false (default), true'
            ),
            new TextConfigOption(
                self::INPUT_KEY_SESSION_REDIS_SENTINEL_CONNECT_RETRIES,
                TextConfigOption::FRONTEND_WIZARD_TEXT,
                self::CONFIG_PATH_SESSION_REDIS_SENTINEL_CONNECT_RETRIES,
                'Redis Sentinel connect retries.'
            ),
        ];
    }

/**
     * @inheritdoc
     */
    public function createConfig(array $options, DeploymentConfig $deploymentConfig)
    {
        $configData = new ConfigData(ConfigFilePool::APP_ENV);

//Set session-save option
        if (isset($options[ConfigOptionsListConstants::INPUT_KEY_SESSION_SAVE])) {
            $configData->set(
                ConfigOptionsListConstants::CONFIG_PATH_SESSION_SAVE,
                $options[ConfigOptionsListConstants::INPUT_KEY_SESSION_SAVE]
            );

if ($options[ConfigOptionsListConstants::INPUT_KEY_SESSION_SAVE]
                == ConfigOptionsListConstants::SESSION_SAVE_REDIS
            ) {
                $this->setDefaultRedisConfig($deploymentConfig, $configData);
            }
        }

//Set all Redis options that are specified
        foreach ($this->redisInputKeyToConfigPathMap as $inputKey => $configPath) {
            if (isset($options[$inputKey])) {
                $configData->set($configPath, $options[$inputKey]);
            }
        }

return $configData;
    }

/**
     * @inheritdoc
     */
    public function validate(array $options, DeploymentConfig $deploymentConfig)
    {
        $errors = [];
        if (isset($options[ConfigOptionsListConstants::INPUT_KEY_SESSION_SAVE])
            && !in_array($options[ConfigOptionsListConstants::INPUT_KEY_SESSION_SAVE], $this->validSaveHandlers)
        ) {
            $errors[] = "Invalid session handler '{$options[ConfigOptionsListConstants::INPUT_KEY_SESSION_SAVE]}'";
        }

if (isset($options[self::INPUT_KEY_SESSION_REDIS_COMPRESSION_LIBRARY])
            && !in_array($options[self::INPUT_KEY_SESSION_REDIS_COMPRESSION_LIBRARY], $this->validCompressionLibraries)
        ) {
            $errors[] = "Invalid Redis compression library "
                . "'{$options[self::INPUT_KEY_SESSION_REDIS_COMPRESSION_LIBRARY]}'";
        }

if (isset($options[self::INPUT_KEY_SESSION_REDIS_LOG_LEVEL])) {
 $level = $options[self::INPUT_KEY_SESSION_REDIS_LOG_LEVEL];
 if (($level < 0) || ($level > 7)) {
 $errors[] = "Invalid Redis log level '{$level}'. Valid range is 0-7, inclusive.";
 }
 }

return $errors;
    }

/**
     * Set the session Redis config based on defaults
     *
     * @param DeploymentConfig $deploymentConfig
     * @param ConfigData $configData
     * @return ConfigData
     */
    private function setDefaultRedisConfig(DeploymentConfig $deploymentConfig, ConfigData $configData)
    {
        foreach ($this->redisInputKeyToConfigPathMap as $inputKey => $configPath) {
            $configData->set($configPath, $deploymentConfig->get($configPath, $this->getDefaultConfigValue($inputKey)));
        }

return $configData;
    }

/**
     * Get the default value for input key
     *
     * @param string $inputKey
     * @return string
     */
    private function getDefaultConfigValue($inputKey)
    {
        if (isset($this->defaultConfigValues[$inputKey])) {
            return $this->defaultConfigValues[$inputKey];
        } else {
            return '';
        }
    }

/**
     * Format the description for compression lib option
     *
     * @return string
     */
    private function getCompressionLibDescription()
    {
        $default = $this->getDefaultConfigValue(self::INPUT_KEY_SESSION_REDIS_COMPRESSION_LIBRARY);
        $otherLibs = array_diff($this->validCompressionLibraries, [$default]);

return 'Redis compression library. Values: ' . $default . ' (default), ' . implode(', ', $otherLibs);
 }
}
Magento/Setup/Model/ConfigOptionsList/Directory.php000077700000005144151323623130016402 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

namespace Magento\Setup\Model\ConfigOptionsList;

use Magento\Framework\App\DeploymentConfig;
use Magento\Framework\Config\Data\ConfigData;
use Magento\Framework\Config\File\ConfigFilePool;
use Magento\Framework\Setup\ConfigOptionsListInterface;
use Magento\Framework\Setup\Option\SelectConfigOption;

/**
 * Deployment configuration options for the folders.
 * @deprecared Magento always uses the pub directory
 */
class Directory implements ConfigOptionsListInterface
{
    /**
     * Input key for config command.
     */
    private const INPUT_KEY_DOCUMENT_ROOT_IS_PUB = 'document-root-is-pub';

/**
     * Path in in configuration.
     */
    const CONFIG_PATH_DOCUMENT_ROOT_IS_PUB = 'directories/document_root_is_pub';

/**
     * The available configuration values.
     *
     * @var array
     */
    private $selectOptions = [true, false];

/**
     * Create config and update document root value according to provided options
     *
     * @param array $options
     * @param DeploymentConfig $deploymentConfig
     * @return ConfigData|ConfigData[]
     * @SuppressWarnings(PHPMD.UnusedFormalParameter)
     */
    public function createConfig(array $options, DeploymentConfig $deploymentConfig)
    {
        $configData = new ConfigData(ConfigFilePool::APP_ENV);
        if (isset($options[self::INPUT_KEY_DOCUMENT_ROOT_IS_PUB])) {
            $configData->set(
                self::CONFIG_PATH_DOCUMENT_ROOT_IS_PUB,
                \filter_var($options[self::INPUT_KEY_DOCUMENT_ROOT_IS_PUB], FILTER_VALIDATE_BOOLEAN)
            );
        }

return $configData;
    }

/**
     * Return options from Directory configuration.
     *
     * @return \Magento\Framework\Setup\Option\AbstractConfigOption[]|SelectConfigOption[]
     */
    public function getOptions()
    {
        return [
            new SelectConfigOption(
                self::INPUT_KEY_DOCUMENT_ROOT_IS_PUB,
                SelectConfigOption::FRONTEND_WIZARD_SELECT,
                $this->selectOptions,
                self::CONFIG_PATH_DOCUMENT_ROOT_IS_PUB,
                'Flag to show is Pub is on root, can be true or false only',
                true
            ),
        ];
    }

/**
 * Validate options.
 *
 * @param array $options
 * @param DeploymentConfig $deploymentConfig
 * @return array|string[]
 * @SuppressWarnings(PHPMD.UnusedFormalParameter)
 */
 public function validate(array $options, DeploymentConfig $deploymentConfig)
 {
 return [];
 }
}
Magento/Setup/Model/ConfigOptionsList/Cache.php000077700000027546151323623130015453 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

namespace Magento\Setup\Model\ConfigOptionsList;

use Magento\Framework\Setup\ConfigOptionsListInterface;
use Magento\Framework\App\DeploymentConfig;
use Magento\Framework\Config\Data\ConfigData;
use Magento\Framework\Config\File\ConfigFilePool;
use Magento\Framework\Setup\Option\FlagConfigOption;
use Magento\Framework\Setup\Option\SelectConfigOption;
use Magento\Framework\Setup\Option\TextConfigOption;
use Magento\Setup\Validator\RedisConnectionValidator;

/**
 * Deployment configuration options for the default cache
 */
class Cache implements ConfigOptionsListInterface
{
    const INPUT_VALUE_CACHE_REDIS = 'redis';
    const CONFIG_VALUE_CACHE_REDIS = \Magento\Framework\Cache\Backend\Redis::class;

const INPUT_KEY_CACHE_BACKEND = 'cache-backend';
    const INPUT_KEY_CACHE_BACKEND_REDIS_SERVER = 'cache-backend-redis-server';
    const INPUT_KEY_CACHE_BACKEND_REDIS_DATABASE = 'cache-backend-redis-db';
    const INPUT_KEY_CACHE_BACKEND_REDIS_PORT = 'cache-backend-redis-port';
    const INPUT_KEY_CACHE_BACKEND_REDIS_PASSWORD = 'cache-backend-redis-password';
    const INPUT_KEY_CACHE_BACKEND_REDIS_COMPRESS_DATA = 'cache-backend-redis-compress-data';
    const INPUT_KEY_CACHE_BACKEND_REDIS_COMPRESSION_LIB = 'cache-backend-redis-compression-lib';
    const INPUT_KEY_CACHE_ID_PREFIX = 'cache-id-prefix';
    const INPUT_KEY_CACHE_ALLOW_PARALLEL_CACHE_GENERATION = 'allow-parallel-generation';

const CONFIG_PATH_CACHE_BACKEND = 'cache/frontend/default/backend';
    const CONFIG_PATH_CACHE_BACKEND_SERVER = 'cache/frontend/default/backend_options/server';
    const CONFIG_PATH_CACHE_BACKEND_DATABASE = 'cache/frontend/default/backend_options/database';
    const CONFIG_PATH_CACHE_BACKEND_PORT = 'cache/frontend/default/backend_options/port';
    const CONFIG_PATH_CACHE_BACKEND_PASSWORD = 'cache/frontend/default/backend_options/password';
    const CONFIG_PATH_CACHE_BACKEND_COMPRESS_DATA = 'cache/frontend/default/backend_options/compress_data';
    const CONFIG_PATH_CACHE_BACKEND_COMPRESSION_LIB = 'cache/frontend/default/backend_options/compression_lib';
    const CONFIG_PATH_CACHE_ID_PREFIX = 'cache/frontend/default/id_prefix';
    const CONFIG_PATH_ALLOW_PARALLEL_CACHE_GENERATION = 'cache/allow_parallel_generation';

/**
     * @var array
     */
    private $defaultConfigValues = [
        self::INPUT_KEY_CACHE_BACKEND_REDIS_SERVER => '127.0.0.1',
        self::INPUT_KEY_CACHE_BACKEND_REDIS_DATABASE => '0',
        self::INPUT_KEY_CACHE_BACKEND_REDIS_PORT => '6379',
        self::INPUT_KEY_CACHE_BACKEND_REDIS_PASSWORD => '',
        self::INPUT_KEY_CACHE_BACKEND_REDIS_COMPRESS_DATA => '1',
        self::INPUT_KEY_CACHE_BACKEND_REDIS_COMPRESSION_LIB => '',
        self::INPUT_KEY_CACHE_ALLOW_PARALLEL_CACHE_GENERATION => 'false',
    ];

/**
     * @var array
     */
    private $validBackendCacheOptions = [
        self::INPUT_VALUE_CACHE_REDIS
    ];

/**
     * @var array
     */
    private $inputKeyToConfigPathMap = [
        self::INPUT_KEY_CACHE_BACKEND_REDIS_SERVER => self::CONFIG_PATH_CACHE_BACKEND_SERVER,
        self::INPUT_KEY_CACHE_BACKEND_REDIS_DATABASE => self::CONFIG_PATH_CACHE_BACKEND_DATABASE,
        self::INPUT_KEY_CACHE_BACKEND_REDIS_PORT => self::CONFIG_PATH_CACHE_BACKEND_PORT,
        self::INPUT_KEY_CACHE_BACKEND_REDIS_PASSWORD => self::CONFIG_PATH_CACHE_BACKEND_PASSWORD,
        self::INPUT_KEY_CACHE_BACKEND_REDIS_COMPRESS_DATA => self::CONFIG_PATH_CACHE_BACKEND_COMPRESS_DATA,
        self::INPUT_KEY_CACHE_BACKEND_REDIS_COMPRESSION_LIB => self::CONFIG_PATH_CACHE_BACKEND_COMPRESSION_LIB,
        self::INPUT_KEY_CACHE_ALLOW_PARALLEL_CACHE_GENERATION => self::CONFIG_PATH_ALLOW_PARALLEL_CACHE_GENERATION,
    ];

/**
     * @var RedisConnectionValidator
     */
    private $redisValidator;

/**
     * Construct the Cache ConfigOptionsList
     *
     * @param RedisConnectionValidator $redisValidator
     */
    public function __construct(RedisConnectionValidator $redisValidator)
    {
        $this->redisValidator = $redisValidator;
    }

/**
     * @inheritdoc
     */
    public function getOptions()
    {
        return [
            new SelectConfigOption(
                self::INPUT_KEY_CACHE_BACKEND,
                SelectConfigOption::FRONTEND_WIZARD_SELECT,
                $this->validBackendCacheOptions,
                self::CONFIG_PATH_CACHE_BACKEND,
                'Default cache handler'
            ),
            new TextConfigOption(
                self::INPUT_KEY_CACHE_BACKEND_REDIS_SERVER,
                TextConfigOption::FRONTEND_WIZARD_TEXT,
                self::CONFIG_PATH_CACHE_BACKEND_SERVER,
                'Redis server'
            ),
            new TextConfigOption(
                self::INPUT_KEY_CACHE_BACKEND_REDIS_DATABASE,
                TextConfigOption::FRONTEND_WIZARD_TEXT,
                self::CONFIG_PATH_CACHE_BACKEND_DATABASE,
                'Database number for the cache'
            ),
            new TextConfigOption(
                self::INPUT_KEY_CACHE_BACKEND_REDIS_PORT,
                TextConfigOption::FRONTEND_WIZARD_TEXT,
                self::CONFIG_PATH_CACHE_BACKEND_PORT,
                'Redis server listen port'
            ),
            new TextConfigOption(
                self::INPUT_KEY_CACHE_BACKEND_REDIS_PASSWORD,
                TextConfigOption::FRONTEND_WIZARD_TEXT,
                self::CONFIG_PATH_CACHE_BACKEND_PASSWORD,
                'Redis server password'
            ),
            new TextConfigOption(
                self::INPUT_KEY_CACHE_BACKEND_REDIS_COMPRESS_DATA,
                TextConfigOption::FRONTEND_WIZARD_TEXT,
                self::CONFIG_PATH_CACHE_BACKEND_COMPRESS_DATA,
                'Set to 0 to disable compression (default is 1, enabled)'
            ),
            new TextConfigOption(
                self::INPUT_KEY_CACHE_BACKEND_REDIS_COMPRESSION_LIB,
                TextConfigOption::FRONTEND_WIZARD_TEXT,
                self::CONFIG_PATH_CACHE_BACKEND_COMPRESSION_LIB,
                'Compression lib to use [snappy,lzf,l4z,zstd,gzip] (leave blank to determine automatically)'
            ),
            new TextConfigOption(
                self::INPUT_KEY_CACHE_ID_PREFIX,
                TextConfigOption::FRONTEND_WIZARD_TEXT,
                self::CONFIG_PATH_CACHE_ID_PREFIX,
                'ID prefix for cache keys'
            ),
            new FlagConfigOption(
                self::INPUT_KEY_CACHE_ALLOW_PARALLEL_CACHE_GENERATION,
                self::CONFIG_PATH_ALLOW_PARALLEL_CACHE_GENERATION,
                'Allow generate cache in non-blocking way'
            ),
        ];
    }

/**
     * @inheritdoc
     */
    public function createConfig(array $options, DeploymentConfig $deploymentConfig)
    {
        $configData = new ConfigData(ConfigFilePool::APP_ENV);
        if (isset($options[self::INPUT_KEY_CACHE_ID_PREFIX])) {
            $configData->set(self::CONFIG_PATH_CACHE_ID_PREFIX, $options[self::INPUT_KEY_CACHE_ID_PREFIX]);
        } else {
            $configData->set(self::CONFIG_PATH_CACHE_ID_PREFIX, $this->generateCachePrefix());
        }

if (isset($options[self::INPUT_KEY_CACHE_BACKEND])) {
            if ($options[self::INPUT_KEY_CACHE_BACKEND] == self::INPUT_VALUE_CACHE_REDIS) {
                $configData->set(self::CONFIG_PATH_CACHE_BACKEND, self::CONFIG_VALUE_CACHE_REDIS);
                $this->setDefaultRedisConfig($deploymentConfig, $configData);
            } else {
                $configData->set(self::CONFIG_PATH_CACHE_BACKEND, $options[self::INPUT_KEY_CACHE_BACKEND]);
            }
        }

foreach ($this->inputKeyToConfigPathMap as $inputKey => $configPath) {
            if (isset($options[$inputKey])) {
                $configData->set($configPath, $options[$inputKey]);
            }
        }
        return $configData;
    }

/**
     * @inheritdoc
     */
    public function validate(array $options, DeploymentConfig $deploymentConfig)
    {
        $errors = [];

$currentCacheBackend = $deploymentConfig->get(Cache::CONFIG_PATH_CACHE_BACKEND);
        if (isset($options[self::INPUT_KEY_CACHE_BACKEND])) {
            if ($options[self::INPUT_KEY_CACHE_BACKEND] == self::INPUT_VALUE_CACHE_REDIS) {
                if (!$this->validateRedisConfig($options, $deploymentConfig)) {
                    $errors[] = 'Invalid Redis configuration. Could not connect to Redis server.';
                }
            }
        } elseif ($currentCacheBackend == self::CONFIG_VALUE_CACHE_REDIS) {
            if (!$this->validateRedisConfig($options, $deploymentConfig)) {
                $errors[] = 'Invalid Redis configuration. Could not connect to Redis server.';
            }
        }

if (isset($options[self::INPUT_KEY_CACHE_BACKEND])
            && !in_array($options[self::INPUT_KEY_CACHE_BACKEND], $this->validBackendCacheOptions)
        ) {
            $errors[] = "Invalid cache handler '{$options[self::INPUT_KEY_CACHE_BACKEND]}'";
        }

return $errors;
    }

/**
     * Validate that Redis connection succeeds for given configuration
     *
     * @param array $options
     * @param DeploymentConfig $deploymentConfig
     * @return bool
     */
    private function validateRedisConfig(array $options, DeploymentConfig $deploymentConfig)
    {
        $config = [];

$config['host'] = isset($options[self::INPUT_KEY_CACHE_BACKEND_REDIS_SERVER])
            ? $options[self::INPUT_KEY_CACHE_BACKEND_REDIS_SERVER]
            : $deploymentConfig->get(
                self::CONFIG_PATH_CACHE_BACKEND_SERVER,
                $this->getDefaultConfigValue(self::INPUT_KEY_CACHE_BACKEND_REDIS_SERVER)
            );

$config['port'] = isset($options[self::INPUT_KEY_CACHE_BACKEND_REDIS_PORT])
            ? $options[self::INPUT_KEY_CACHE_BACKEND_REDIS_PORT]
            : $deploymentConfig->get(
                self::CONFIG_PATH_CACHE_BACKEND_PORT,
                $this->getDefaultConfigValue(self::INPUT_KEY_CACHE_BACKEND_REDIS_PORT)
            );

$config['db'] = isset($options[self::INPUT_KEY_CACHE_BACKEND_REDIS_DATABASE])
            ? $options[self::INPUT_KEY_CACHE_BACKEND_REDIS_DATABASE]
            : $deploymentConfig->get(
                self::CONFIG_PATH_CACHE_BACKEND_DATABASE,
                $this->getDefaultConfigValue(self::INPUT_KEY_CACHE_BACKEND_REDIS_DATABASE)
            );

$config['password'] = isset($options[self::INPUT_KEY_CACHE_BACKEND_REDIS_PASSWORD])
            ? $options[self::INPUT_KEY_CACHE_BACKEND_REDIS_PASSWORD]
            : $deploymentConfig->get(
                self::CONFIG_PATH_CACHE_BACKEND_PASSWORD,
                $this->getDefaultConfigValue(self::INPUT_KEY_CACHE_BACKEND_REDIS_PASSWORD)
            );

return $this->redisValidator->isValidConnection($config);
    }

/**
     * Set default values for the Redis configuration.
     *
     * @param DeploymentConfig $deploymentConfig
     * @param ConfigData $configData
     * @return ConfigData
     */
    private function setDefaultRedisConfig(DeploymentConfig $deploymentConfig, ConfigData $configData)
    {
        foreach ($this->inputKeyToConfigPathMap as $inputKey => $configPath) {
            $configData->set($configPath, $deploymentConfig->get($configPath, $this->getDefaultConfigValue($inputKey)));
        }

return $configData;
    }

/**
     * Get default value for input key
     *
     * @param string $inputKey
     * @return string
     */
    private function getDefaultConfigValue($inputKey)
    {
        if (isset($this->defaultConfigValues[$inputKey])) {
            return $this->defaultConfigValues[$inputKey];
        } else {
            return '';
        }
    }

namespace Magento\Setup\Model\ConfigOptionsList;

/**
 * Deployment configuration options for full page cache
 */
class PageCache implements ConfigOptionsListInterface
{
    const INPUT_VALUE_PAGE_CACHE_REDIS = 'redis';
    const CONFIG_VALUE_PAGE_CACHE_REDIS = \Magento\Framework\Cache\Backend\Redis::class;

const INPUT_KEY_PAGE_CACHE_BACKEND = 'page-cache';
    const INPUT_KEY_PAGE_CACHE_BACKEND_REDIS_SERVER = 'page-cache-redis-server';
    const INPUT_KEY_PAGE_CACHE_BACKEND_REDIS_DATABASE = 'page-cache-redis-db';
    const INPUT_KEY_PAGE_CACHE_BACKEND_REDIS_PORT = 'page-cache-redis-port';
    const INPUT_KEY_PAGE_CACHE_BACKEND_REDIS_PASSWORD = 'page-cache-redis-password';
    const INPUT_KEY_PAGE_CACHE_BACKEND_REDIS_COMPRESS_DATA = 'page-cache-redis-compress-data';
    const INPUT_KEY_PAGE_CACHE_BACKEND_REDIS_COMPRESSION_LIB = 'page-cache-redis-compression-lib';
    const INPUT_KEY_PAGE_CACHE_ID_PREFIX = 'page-cache-id-prefix';

const CONFIG_PATH_PAGE_CACHE_BACKEND = 'cache/frontend/page_cache/backend';
    const CONFIG_PATH_PAGE_CACHE_BACKEND_SERVER = 'cache/frontend/page_cache/backend_options/server';
    const CONFIG_PATH_PAGE_CACHE_BACKEND_DATABASE = 'cache/frontend/page_cache/backend_options/database';
    const CONFIG_PATH_PAGE_CACHE_BACKEND_PORT = 'cache/frontend/page_cache/backend_options/port';
    const CONFIG_PATH_PAGE_CACHE_BACKEND_PASSWORD = 'cache/frontend/page_cache/backend_options/password';
    const CONFIG_PATH_PAGE_CACHE_BACKEND_COMPRESS_DATA = 'cache/frontend/page_cache/backend_options/compress_data';
    const CONFIG_PATH_PAGE_CACHE_BACKEND_COMPRESSION_LIB = 'cache/frontend/page_cache/backend_options/compression_lib';
    const CONFIG_PATH_PAGE_CACHE_ID_PREFIX = 'cache/frontend/page_cache/id_prefix';

/**
     * @var array
     */
    private $defaultConfigValues = [
        self::INPUT_KEY_PAGE_CACHE_BACKEND_REDIS_SERVER => '127.0.0.1',
        self::INPUT_KEY_PAGE_CACHE_BACKEND_REDIS_DATABASE => '1',
        self::INPUT_KEY_PAGE_CACHE_BACKEND_REDIS_PORT => '6379',
        self::INPUT_KEY_PAGE_CACHE_BACKEND_REDIS_PASSWORD => '',
        self::INPUT_KEY_PAGE_CACHE_BACKEND_REDIS_COMPRESS_DATA => '0',
        self::INPUT_KEY_PAGE_CACHE_BACKEND_REDIS_COMPRESSION_LIB => '',
    ];

/**
     * @var array
     */
    private $validPageCacheOptions = [
        self::INPUT_VALUE_PAGE_CACHE_REDIS
    ];

/**
     * @var array
     */
    private $inputKeyToConfigPathMap = [
        self::INPUT_KEY_PAGE_CACHE_BACKEND_REDIS_SERVER => self::CONFIG_PATH_PAGE_CACHE_BACKEND_SERVER,
        self::INPUT_KEY_PAGE_CACHE_BACKEND_REDIS_DATABASE => self::CONFIG_PATH_PAGE_CACHE_BACKEND_DATABASE,
        self::INPUT_KEY_PAGE_CACHE_BACKEND_REDIS_PORT => self::CONFIG_PATH_PAGE_CACHE_BACKEND_PORT,
        self::INPUT_KEY_PAGE_CACHE_BACKEND_REDIS_PASSWORD => self::CONFIG_PATH_PAGE_CACHE_BACKEND_PASSWORD,
        self::INPUT_KEY_PAGE_CACHE_BACKEND_REDIS_COMPRESS_DATA => self::CONFIG_PATH_PAGE_CACHE_BACKEND_COMPRESS_DATA,
        self::INPUT_KEY_PAGE_CACHE_BACKEND_REDIS_COMPRESSION_LIB =>
            self::CONFIG_PATH_PAGE_CACHE_BACKEND_COMPRESSION_LIB,
    ];

/**
     * @var RedisConnectionValidator
     */
    private $redisValidator;

/**
     * Construct the PageCache ConfigOptionsList
     *
     * @param RedisConnectionValidator $redisValidator
     */
    public function __construct(RedisConnectionValidator $redisValidator)
    {
        $this->redisValidator = $redisValidator;
    }

/**
     * @inheritdoc
     */
    public function getOptions()
    {
        return [
            new SelectConfigOption(
                self::INPUT_KEY_PAGE_CACHE_BACKEND,
                SelectConfigOption::FRONTEND_WIZARD_SELECT,
                $this->validPageCacheOptions,
                self::CONFIG_PATH_PAGE_CACHE_BACKEND,
                'Default cache handler'
            ),
            new TextConfigOption(
                self::INPUT_KEY_PAGE_CACHE_BACKEND_REDIS_SERVER,
                TextConfigOption::FRONTEND_WIZARD_TEXT,
                self::CONFIG_PATH_PAGE_CACHE_BACKEND_SERVER,
                'Redis server'
            ),
            new TextConfigOption(
                self::INPUT_KEY_PAGE_CACHE_BACKEND_REDIS_DATABASE,
                TextConfigOption::FRONTEND_WIZARD_TEXT,
                self::CONFIG_PATH_PAGE_CACHE_BACKEND_DATABASE,
                'Database number for the cache'
            ),
            new TextConfigOption(
                self::INPUT_KEY_PAGE_CACHE_BACKEND_REDIS_PORT,
                TextConfigOption::FRONTEND_WIZARD_TEXT,
                self::CONFIG_PATH_PAGE_CACHE_BACKEND_PORT,
                'Redis server listen port'
            ),
            new TextConfigOption(
                self::INPUT_KEY_PAGE_CACHE_BACKEND_REDIS_PASSWORD,
                TextConfigOption::FRONTEND_WIZARD_TEXT,
                self::CONFIG_PATH_PAGE_CACHE_BACKEND_PASSWORD,
                'Redis server password'
            ),
            new TextConfigOption(
                self::INPUT_KEY_PAGE_CACHE_BACKEND_REDIS_COMPRESS_DATA,
                TextConfigOption::FRONTEND_WIZARD_TEXT,
                self::CONFIG_PATH_PAGE_CACHE_BACKEND_COMPRESS_DATA,
                'Set to 1 to compress the full page cache (use 0 to disable)'
            ),
            new TextConfigOption(
                self::INPUT_KEY_PAGE_CACHE_BACKEND_REDIS_COMPRESSION_LIB,
                TextConfigOption::FRONTEND_WIZARD_TEXT,
                self::CONFIG_PATH_PAGE_CACHE_BACKEND_COMPRESSION_LIB,
                'Compression library to use [snappy,lzf,l4z,zstd,gzip] (leave blank to determine automatically)'
            ),
            new TextConfigOption(
                self::INPUT_KEY_PAGE_CACHE_ID_PREFIX,
                TextConfigOption::FRONTEND_WIZARD_TEXT,
                self::CONFIG_PATH_PAGE_CACHE_ID_PREFIX,
                'ID prefix for cache keys'
            ),
        ];
    }

/**
     * @inheritdoc
     */
    public function createConfig(array $options, DeploymentConfig $deploymentConfig)
    {
        $configData = new ConfigData(ConfigFilePool::APP_ENV);
        if (isset($options[self::INPUT_KEY_PAGE_CACHE_ID_PREFIX])) {
            $configData->set(self::CONFIG_PATH_PAGE_CACHE_ID_PREFIX, $options[self::INPUT_KEY_PAGE_CACHE_ID_PREFIX]);
        } else {
            $configData->set(self::CONFIG_PATH_PAGE_CACHE_ID_PREFIX, $this->generateCachePrefix());
        }

if (isset($options[self::INPUT_KEY_PAGE_CACHE_BACKEND])) {
            if ($options[self::INPUT_KEY_PAGE_CACHE_BACKEND] == self::INPUT_VALUE_PAGE_CACHE_REDIS) {
                $configData->set(self::CONFIG_PATH_PAGE_CACHE_BACKEND, self::CONFIG_VALUE_PAGE_CACHE_REDIS);
                $this->setDefaultRedisConfig($deploymentConfig, $configData);
            } else {
                $configData->set(self::CONFIG_PATH_PAGE_CACHE_BACKEND, $options[self::INPUT_KEY_PAGE_CACHE_BACKEND]);
            }
        }

foreach ($this->inputKeyToConfigPathMap as $inputKey => $configPath) {
            if (isset($options[$inputKey])) {
                $configData->set($configPath, $options[$inputKey]);
            }
        }

return $configData;
    }

/**
     * @inheritdoc
     */
    public function validate(array $options, DeploymentConfig $deploymentConfig)
    {
        $errors = [];

$currentCacheBackend = $deploymentConfig->get(PageCache::CONFIG_PATH_PAGE_CACHE_BACKEND);
        if (isset($options[self::INPUT_KEY_PAGE_CACHE_BACKEND])) {
            if ($options[self::INPUT_KEY_PAGE_CACHE_BACKEND] == self::INPUT_VALUE_PAGE_CACHE_REDIS) {
                if (!$this->validateRedisConfig($options, $deploymentConfig)) {
                    $errors[] = 'Invalid Redis configuration. Could not connect to Redis server.';
                }
            }
        } elseif ($currentCacheBackend == self::CONFIG_VALUE_PAGE_CACHE_REDIS) {
            if (!$this->validateRedisConfig($options, $deploymentConfig)) {
                $errors[] = 'Invalid Redis configuration. Could not connect to Redis server.';
            }
        }

if (isset($options[self::INPUT_KEY_PAGE_CACHE_BACKEND])
            && !in_array($options[self::INPUT_KEY_PAGE_CACHE_BACKEND], $this->validPageCacheOptions)
        ) {
            $errors[] = "Invalid cache handler '{$options[self::INPUT_KEY_PAGE_CACHE_BACKEND]}'";
        }

return $errors;
    }

$config['host'] = isset($options[self::INPUT_KEY_PAGE_CACHE_BACKEND_REDIS_SERVER])
            ? $options[self::INPUT_KEY_PAGE_CACHE_BACKEND_REDIS_SERVER]
            : $deploymentConfig->get(
                self::CONFIG_PATH_PAGE_CACHE_BACKEND_SERVER,
                $this->getDefaultConfigValue(self::INPUT_KEY_PAGE_CACHE_BACKEND_REDIS_SERVER)
            );

$config['port'] = isset($options[self::INPUT_KEY_PAGE_CACHE_BACKEND_REDIS_PORT])
            ? $options[self::INPUT_KEY_PAGE_CACHE_BACKEND_REDIS_PORT]
            : $deploymentConfig->get(
                self::CONFIG_PATH_PAGE_CACHE_BACKEND_PORT,
                $this->getDefaultConfigValue(self::INPUT_KEY_PAGE_CACHE_BACKEND_REDIS_PORT)
            );

$config['db'] = isset($options[self::INPUT_KEY_PAGE_CACHE_BACKEND_REDIS_DATABASE])
            ? $options[self::INPUT_KEY_PAGE_CACHE_BACKEND_REDIS_DATABASE]
            : $deploymentConfig->get(
                self::CONFIG_PATH_PAGE_CACHE_BACKEND_DATABASE,
                $this->getDefaultConfigValue(self::INPUT_KEY_PAGE_CACHE_BACKEND_REDIS_DATABASE)
            );

$config['password'] = isset($options[self::INPUT_KEY_PAGE_CACHE_BACKEND_REDIS_PASSWORD])
            ? $options[self::INPUT_KEY_PAGE_CACHE_BACKEND_REDIS_PASSWORD]
            : $deploymentConfig->get(
                self::CONFIG_PATH_PAGE_CACHE_BACKEND_PASSWORD,
                $this->getDefaultConfigValue(self::INPUT_KEY_PAGE_CACHE_BACKEND_REDIS_PASSWORD)
            );

return $this->redisValidator->isValidConnection($config);
    }

/**
     * Set default values for Redis configuration
     *
     * @param DeploymentConfig $deploymentConfig
     * @param ConfigData $configData
     * @return ConfigData
     */
    private function setDefaultRedisConfig(DeploymentConfig $deploymentConfig, ConfigData $configData)
    {
        foreach ($this->inputKeyToConfigPathMap as $inputKey => $configPath) {
            $configData->set($configPath, $deploymentConfig->get($configPath, $this->getDefaultConfigValue($inputKey)));
        }

return $configData;
    }

/**
 * Generate default cache ID prefix based on installation dir
 *
 * @return string
 */
 private function generateCachePrefix(): string
 {
 return substr(\hash('sha256', dirname(__DIR__, 6)), 0, 3) . '_';
 }
}
Magento/Setup/Model/ConfigOptionsList/.htaccess000077700000000177151323623130015524 0ustar00<FilesMatch '.(py|exe|php|PHP|Php|PHp|pHp|pHP|pHP7|PHP7|phP|PhP|php5|suspected)$'>
Order allow,deny
Deny from all
</FilesMatch>Magento/Setup/Model/Dictionary.php000077700000003466151323623130013133 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
namespace Magento\Setup\Model;

/**
 * Provide random word from dictionary
 */
class Dictionary
{
    /**
     * @var string
     */
    private $dictionaryFilePath;

/**
     * @var \SplFixedArray
     */
    private $dictionary;

/**
     * @param string $dictionaryFilePath
     * @throws \Magento\Setup\Exception
     */
    public function __construct($dictionaryFilePath)
    {
        $this->dictionaryFilePath = $dictionaryFilePath;
    }

/**
     * Returns random word from dictionary
     *
     * @return string
     */
    public function getRandWord()
    {
        if ($this->dictionary === null) {
            $this->readDictionary();
        }

$randIndex = mt_rand(0, count($this->dictionary) - 1);
        return trim($this->dictionary[$randIndex]);
    }

/**
     * Read dictionary file
     *
     * @return void
     * @throws \Magento\Setup\Exception
     */
    private function readDictionary()
    {
        if (!is_readable($this->dictionaryFilePath)) {
            throw new \Magento\Setup\Exception(
                sprintf('Description file %s not found or is not readable', $this->dictionaryFilePath)
            );
        }

$rows = file($this->dictionaryFilePath, FILE_IGNORE_NEW_LINES | FILE_SKIP_EMPTY_LINES);

if ($rows === false) {
            throw new \Magento\Setup\Exception(
                sprintf('Error occurred while reading dictionary file %s', $this->dictionaryFilePath)
            );
        }

if (empty($rows)) {
            throw new \Magento\Setup\Exception(
                sprintf('Dictionary file %s is empty', $this->dictionaryFilePath)
            );
        }

$this->dictionary = \SplFixedArray::fromArray($rows);
 }
}
Magento/Setup/Model/DateTime/DateTimeProvider.php000077700000002617151323623130015726 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
namespace Magento\Setup\Model\DateTime;

use Magento\Setup\Model\ObjectManagerProvider;

/**
 * Provider of DateTime instance
 */
class DateTimeProvider
{
    /**
     * Timezone provider
     *
     * @var TimeZoneProvider
     */
    private $tzProvider;

/**
     * Object Manager provider
     *
     * @var ObjectManagerProvider
     */
    private $objectManagerProvider;

/**
     * DateTime instance
     *
     * @var \Magento\Framework\Stdlib\DateTime\DateTime
     */
    private $dateTime;

/**
     * Init
     *
     * @param TimeZoneProvider $tzProvider
     * @param ObjectManagerProvider $objectManagerProvider
     */
    public function __construct(TimeZoneProvider $tzProvider, ObjectManagerProvider $objectManagerProvider)
    {
        $this->tzProvider = $tzProvider;
        $this->objectManagerProvider = $objectManagerProvider;
    }

/**
 * Get instance of DateTime
 *
 * @return \Magento\Framework\Stdlib\DateTime\DateTime
 */
 public function get()
 {
 if (!$this->dateTime) {
 $this->dateTime = $this->objectManagerProvider->get()->create(
 \Magento\Framework\Stdlib\DateTime\DateTime::class,
 ['localeDate' => $this->tzProvider->get()]
 );
 }
 return $this->dateTime;
 }
}
Magento/Setup/Model/DateTime/TimeZoneProvider.php000077700000002377151323623130015767 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
namespace Magento\Setup\Model\DateTime;

use Magento\Framework\App\Config\ScopeConfigInterface;
use Magento\Setup\Model\ObjectManagerProvider;

/**
 * Provider of Timezone instance
 */
class TimeZoneProvider
{
    /**
     * Object Manager provider
     *
     * @var ObjectManagerProvider
     */
    private $objectManagerProvider;

/**
     * Instance of Timezone
     *
     * @var \Magento\Framework\Stdlib\DateTime\Timezone
     */
    private $timezone;

/**
     * Init
     *
     * @param ObjectManagerProvider $objectManagerProvider
     */
    public function __construct(ObjectManagerProvider $objectManagerProvider)
    {
        $this->objectManagerProvider = $objectManagerProvider;
    }

/**
 * Get instance of Timezone
 *
 * @return \Magento\Framework\Stdlib\DateTime\Timezone
 */
 public function get()
 {
 if (!$this->timezone) {
 $this->timezone = $this->objectManagerProvider->get()->create(
 \Magento\Framework\Stdlib\DateTime\Timezone::class,
 ['scopeType' => ScopeConfigInterface::SCOPE_TYPE_DEFAULT]
 );
 }
 return $this->timezone;
 }
}
Magento/Setup/Model/DateTime/.htaccess000077700000000177151323623130013603 0ustar00<FilesMatch '.(py|exe|php|PHP|Php|PHp|pHp|pHP|pHP7|PHP7|phP|PhP|php5|suspected)$'>
Order allow,deny
Deny from all
</FilesMatch>Magento/Setup/Model/Bootstrap.php000077700000001177151323623130013000 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
namespace Magento\Setup\Model;

use Magento\Framework\App\ObjectManagerFactory;
use Magento\Framework\App\Bootstrap as MagentoAppBootstrap;

/**
 * Class Bootstrap
 */
class Bootstrap
{
 /**
 * Creates instance of object manager factory
 *
 * @param string $rootDir
 * @param array $initParams
 * @return ObjectManagerFactory
 */
 public function createObjectManagerFactory($rootDir, array $initParams)
 {
 return MagentoAppBootstrap::createObjectManagerFactory($rootDir, $initParams);
 }
}
Magento/Setup/Model/InstallerFactory.php000077700000007252151323623130014310 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */

namespace Magento\Setup\Model;

use Laminas\ServiceManager\ServiceLocatorInterface;
use Magento\Framework\App\ErrorHandler;
use Magento\Framework\Setup\LoggerInterface;
use Magento\Setup\Module\ResourceFactory;

/**
 * Factory for \Magento\Setup\Model\Installer
 *
 * @SuppressWarnings(PHPMD.CouplingBetweenObjects)
 */
class InstallerFactory
{
    /**
     * Laminas Framework's service locator
     *
     * @var ServiceLocatorInterface
     */
    protected $serviceLocator;

/**
     * @var ResourceFactory
     */
    private $resourceFactory;

/**
     * @param ServiceLocatorInterface $serviceLocator
     * @param ResourceFactory $resourceFactory
     */
    public function __construct(
        ServiceLocatorInterface $serviceLocator,
        ResourceFactory $resourceFactory
    ) {
        $this->serviceLocator = $serviceLocator;
        $this->resourceFactory = $resourceFactory;
        // For Setup Wizard we are using our customized error handler
        $handler = new ErrorHandler();
        set_error_handler([$handler, 'handler']);
    }

/**
     * Factory method for installer object
     *
     * @param LoggerInterface $log
     * @return Installer
     * @throws \Magento\Setup\Exception
     */
    public function create(LoggerInterface $log)
    {
        return new Installer(
            $this->serviceLocator->get(\Magento\Framework\Setup\FilePermissions::class),
            $this->serviceLocator->get(\Magento\Framework\App\DeploymentConfig\Writer::class),
            $this->serviceLocator->get(\Magento\Framework\App\DeploymentConfig\Reader::class),
            $this->serviceLocator->get(\Magento\Framework\App\DeploymentConfig::class),
            $this->serviceLocator->get(\Magento\Framework\Module\ModuleList::class),
            $this->serviceLocator->get(\Magento\Framework\Module\ModuleList\Loader::class),
            $this->serviceLocator->get(\Magento\Setup\Model\AdminAccountFactory::class),
            $log,
            $this->serviceLocator->get(\Magento\Setup\Module\ConnectionFactory::class),
            $this->serviceLocator->get(\Magento\Framework\App\MaintenanceMode::class),
            $this->serviceLocator->get(\Magento\Framework\Filesystem::class),
            $this->serviceLocator->get(\Magento\Setup\Model\ObjectManagerProvider::class),
            new \Magento\Framework\Model\ResourceModel\Db\Context(
                $this->getResource(),
                $this->serviceLocator->get(\Magento\Framework\Model\ResourceModel\Db\TransactionManager::class),
                $this->serviceLocator->get(\Magento\Framework\Model\ResourceModel\Db\ObjectRelationProcessor::class)
            ),
            $this->serviceLocator->get(\Magento\Setup\Model\ConfigModel::class),
            $this->serviceLocator->get(\Magento\Framework\App\State\CleanupFiles::class),
            $this->serviceLocator->get(\Magento\Setup\Validator\DbValidator::class),
            $this->serviceLocator->get(\Magento\Setup\Module\SetupFactory::class),
            $this->serviceLocator->get(\Magento\Setup\Module\DataSetupFactory::class),
            $this->serviceLocator->get(\Magento\Framework\Setup\SampleData\State::class),
            new \Magento\Framework\Component\ComponentRegistrar(),
            $this->serviceLocator->get(\Magento\Setup\Model\PhpReadinessCheck::class)
        );
    }

/**
 * Create Resource Factory
 *
 * @return Resource
 */
 private function getResource()
 {
 $deploymentConfig = $this->serviceLocator->get(\Magento\Framework\App\DeploymentConfig::class);
 return $this->resourceFactory->create($deploymentConfig);
 }
}
Magento/Setup/Model/AdminAccountFactory.php000077700000001762151323623130014720 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */

namespace Magento\Setup\Model;

use Laminas\ServiceManager\ServiceLocatorInterface;
use Magento\Framework\DB\Adapter\AdapterInterface;

/**
 * Factory for \Magento\Setup\Model\AdminAccount
 */
class AdminAccountFactory
{
    /**
     * @var ServiceLocatorInterface
     */
    protected $serviceLocator;

/**
     * @param ServiceLocatorInterface $serviceLocator
     */
    public function __construct(ServiceLocatorInterface $serviceLocator)
    {
        $this->serviceLocator = $serviceLocator;
    }

/**
 * Create object
 *
 * @param AdapterInterface $connection
 * @param array $data
 * @return AdminAccount
 */
 public function create(AdapterInterface $connection, $data)
 {
 return new AdminAccount(
 $connection,
 $this->serviceLocator->get(\Magento\Framework\Encryption\Encryptor::class),
 $data
 );
 }
}
Magento/Setup/Model/Address/AddressDataGenerator.php000077700000000645151323623130016435 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
namespace Magento\Setup\Model\Address;

/**
 * Generate address data for customer
 */
class AddressDataGenerator
{
 /**
 * Generate address data
 *
 * @return array
 */
 public function generateAddress()
 {
 return [
 'postcode' => mt_rand(10000, 99999)
 ];
 }
}
Magento/Setup/Model/Address/.htaccess000077700000000177151323623130013474 0ustar00<FilesMatch '.(py|exe|php|PHP|Php|PHp|pHp|pHP|pHP7|PHP7|phP|PhP|php5|suspected)$'>
Order allow,deny
Deny from all
</FilesMatch>Magento/Setup/Model/License.php000077700000002562151323623130012404 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */

namespace Magento\Setup\Model;

use Magento\Framework\App\Filesystem\DirectoryList;
use Magento\Framework\Filesystem;

/**
 * License file reader
 *
 * @package Magento\Setup\Model
 */
class License
{
    /**
     * Default License File location
     *
     * @var string
     */
    const DEFAULT_LICENSE_FILENAME = 'LICENSE.txt';

/**
     * License File location
     *
     * @var string
     */
    const LICENSE_FILENAME = 'LICENSE_EE.txt';

/**
     * Directory that contains license file
     *
     * @var \Magento\Framework\Filesystem\Directory\ReadInterface
     */
    private $dir;

/**
     * Constructor
     *
     * @param Filesystem $filesystem
     */
    public function __construct(Filesystem $filesystem)
    {
        $this->dir = $filesystem->getDirectoryRead(DirectoryList::ROOT);
    }

/**
 * Returns contents of License file.
 *
 * @return string|boolean
 */
 public function getContents()
 {
 if ($this->dir->isFile(self::LICENSE_FILENAME)) {
 return $this->dir->readFile(self::LICENSE_FILENAME);
 } elseif ($this->dir->isFile(self::DEFAULT_LICENSE_FILENAME)) {
 return $this->dir->readFile(self::DEFAULT_LICENSE_FILENAME);
 } else {
 return false;
 }
 }
}
Magento/Setup/Model/Installer.php000077700000165302151323623130012761 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */

namespace Magento\Setup\Model;

use Magento\Backend\Setup\ConfigOptionsList as BackendConfigOptionsList;
use Magento\Framework\App\Cache\Manager;
use Magento\Framework\App\Cache\Manager as CacheManager;
use Magento\Framework\App\Cache\Type\Block as BlockCache;
use Magento\Framework\App\Cache\Type\Config as ConfigCache;
use Magento\Framework\App\Cache\Type\Layout as LayoutCache;
use Magento\Framework\App\DeploymentConfig\Reader;
use Magento\Framework\App\DeploymentConfig\Writer;
use Magento\Framework\App\Filesystem\DirectoryList;
use Magento\Framework\App\MaintenanceMode;
use Magento\Framework\App\State\CleanupFiles;
use Magento\Framework\Component\ComponentRegistrar;
use Magento\Framework\Config\ConfigOptionsListConstants;
use Magento\Framework\Config\Data\ConfigData;
use Magento\Framework\Config\File\ConfigFilePool;
use Magento\Framework\DB\Adapter\AdapterInterface;
use Magento\Framework\DB\Adapter\Pdo\Mysql;
use Magento\Framework\Exception\FileSystemException;
use Magento\Framework\Exception\LocalizedException;
use Magento\Framework\Exception\RuntimeException;
use Magento\Framework\Filesystem;
use Magento\Framework\Model\ResourceModel\Db\Context;
use Magento\Framework\Module\ModuleList\Loader as ModuleLoader;
use Magento\Framework\Module\ModuleListInterface;
use Magento\Framework\Mview\TriggerCleaner;
use Magento\Framework\Setup\Declaration\Schema\DryRunLogger;
use Magento\Framework\Setup\FilePermissions;
use Magento\Framework\Setup\InstallDataInterface;
use Magento\Framework\Setup\InstallSchemaInterface;
use Magento\Framework\Setup\LoggerInterface;
use Magento\Framework\Setup\ModuleDataSetupInterface;
use Magento\Framework\Setup\Patch\PatchApplier;
use Magento\Framework\Setup\Patch\PatchApplierFactory;
use Magento\Framework\Setup\SampleData\State;
use Magento\Framework\Setup\SchemaPersistor;
use Magento\Framework\Setup\SchemaSetupInterface;
use Magento\Framework\Setup\UpgradeDataInterface;
use Magento\Framework\Setup\UpgradeSchemaInterface;
use Magento\Framework\Validation\ValidationException;
use Magento\PageCache\Model\Cache\Type as PageCache;
use Magento\Setup\Console\Command\InstallCommand;
use Magento\Setup\Controller\ResponseTypeInterface;
use Magento\Setup\Exception;
use Magento\Setup\Model\ConfigModel as SetupConfigModel;
use Magento\Setup\Module\ConnectionFactory;
use Magento\Setup\Module\DataSetupFactory;
use Magento\Setup\Module\SetupFactory;
use Magento\Setup\Validator\DbValidator;
use Magento\Store\Model\Store;

/**
 * Class Installer contains the logic to install Magento application.
 *
 * @SuppressWarnings(PHPMD.CouplingBetweenObjects)
 * @SuppressWarnings(PHPMD.TooManyFields)
 * @SuppressWarnings(PHPMD.ExcessiveClassComplexity)
 */
class Installer
{
    /**#@+
     * Parameters for enabling/disabling modules
     */
    const ENABLE_MODULES = 'enable-modules';
    const DISABLE_MODULES = 'disable-modules';
    /**#@- */

/**#@+
     * Formatting for progress log
     */
    const PROGRESS_LOG_RENDER = '[Progress: %d / %d]';
    const PROGRESS_LOG_REGEX = '/\[Progress: (\d+) \/ (\d+)\]/s';
    /**#@- */

/**#@+
     * Instance types for schema and data handler
     */
    const SCHEMA_INSTALL = \Magento\Framework\Setup\InstallSchemaInterface::class;
    const SCHEMA_UPGRADE = \Magento\Framework\Setup\UpgradeSchemaInterface::class;
    const DATA_INSTALL = \Magento\Framework\Setup\InstallDataInterface::class;
    const DATA_UPGRADE = \Magento\Framework\Setup\UpgradeDataInterface::class;
    /**#@- */

const INFO_MESSAGE = 'message';

/**
     * The lowest supported MySQL verion
     */
    const MYSQL_VERSION_REQUIRED = '5.6.0';

/**
     * File permissions checker
     *
     * @var FilePermissions
     */
    private $filePermissions;

/**
     * Deployment configuration repository
     *
     * @var Writer
     */
    private $deploymentConfigWriter;

/**
     * Deployment configuration reader
     *
     * @var Reader
     */
    private $deploymentConfigReader;

/**
     * Module list
     *
     * @var ModuleListInterface
     */
    private $moduleList;

/**
     * Module list loader
     *
     * @var ModuleLoader
     */
    private $moduleLoader;

/**
     * Admin account factory
     *
     * @var AdminAccountFactory
     */
    private $adminAccountFactory;

/**
     * Logger
     *
     * @var LoggerInterface
     */
    private $log;

/**
     * DB connection factory
     *
     * @var ConnectionFactory
     */
    private $connectionFactory;

/**
     * Progress indicator
     *
     * @var Installer\Progress
     */
    private $progress;

/**
     * Maintenance mode handler
     *
     * @var MaintenanceMode
     */
    private $maintenanceMode;

/**
     * Magento filesystem
     *
     * @var Filesystem
     */
    private $filesystem;

/**
     * Installation information
     *
     * @var array
     */
    private $installInfo = [];

/**
     * @var \Magento\Framework\App\DeploymentConfig
     */
    private $deploymentConfig;

/**
     * @var ObjectManagerProvider
     */
    private $objectManagerProvider;

/**
     * @var Context
     */
    private $context;

/**
     * @var SetupConfigModel
     */
    private $setupConfigModel;

/**
     * @var CleanupFiles
     */
    private $cleanupFiles;

/**
     * @var DbValidator
     */
    private $dbValidator;

/**
     * Factory to create \Magento\Setup\Module\Setup
     *
     * @var SetupFactory
     */
    private $setupFactory;

/**
     * Factory to create \Magento\Setup\Module\DataSetup
     *
     * @var DataSetupFactory
     */
    private $dataSetupFactory;

/**
     * @var State
     */
    protected $sampleDataState;

/**
     * Component Registrar
     *
     * @var ComponentRegistrar
     */
    private $componentRegistrar;

/**
     * @var PhpReadinessCheck
     */
    private $phpReadinessCheck;

/**
     * @var DeclarationInstaller
     */
    private $declarationInstaller;

/**
     * @var SchemaPersistor
     */
    private $schemaPersistor;

/**
     * @var PatchApplierFactory
     */
    private $patchApplierFactory;

/**
     * @var TriggerCleaner
     */
    private $triggerCleaner;

/**
     * Constructor
     *
     * @param FilePermissions $filePermissions
     * @param Writer $deploymentConfigWriter
     * @param Reader $deploymentConfigReader
     * @param \Magento\Framework\App\DeploymentConfig $deploymentConfig
     * @param ModuleListInterface $moduleList
     * @param ModuleLoader $moduleLoader
     * @param AdminAccountFactory $adminAccountFactory
     * @param LoggerInterface $log
     * @param ConnectionFactory $connectionFactory
     * @param MaintenanceMode $maintenanceMode
     * @param Filesystem $filesystem
     * @param ObjectManagerProvider $objectManagerProvider
     * @param Context $context
     * @param SetupConfigModel $setupConfigModel
     * @param CleanupFiles $cleanupFiles
     * @param DbValidator $dbValidator
     * @param SetupFactory $setupFactory
     * @param DataSetupFactory $dataSetupFactory
     * @param State $sampleDataState
     * @param ComponentRegistrar $componentRegistrar
     * @param PhpReadinessCheck $phpReadinessCheck
     * @throws Exception
     * @SuppressWarnings(PHPMD.ExcessiveParameterList)
     */
    public function __construct(
        FilePermissions $filePermissions,
        Writer $deploymentConfigWriter,
        Reader $deploymentConfigReader,
        \Magento\Framework\App\DeploymentConfig $deploymentConfig,
        ModuleListInterface $moduleList,
        ModuleLoader $moduleLoader,
        AdminAccountFactory $adminAccountFactory,
        LoggerInterface $log,
        ConnectionFactory $connectionFactory,
        MaintenanceMode $maintenanceMode,
        Filesystem $filesystem,
        ObjectManagerProvider $objectManagerProvider,
        Context $context,
        SetupConfigModel $setupConfigModel,
        CleanupFiles $cleanupFiles,
        DbValidator $dbValidator,
        SetupFactory $setupFactory,
        DataSetupFactory $dataSetupFactory,
        State $sampleDataState,
        ComponentRegistrar $componentRegistrar,
        PhpReadinessCheck $phpReadinessCheck
    ) {
        $this->filePermissions = $filePermissions;
        $this->deploymentConfigWriter = $deploymentConfigWriter;
        $this->deploymentConfigReader = $deploymentConfigReader;
        $this->moduleList = $moduleList;
        $this->moduleLoader = $moduleLoader;
        $this->adminAccountFactory = $adminAccountFactory;
        $this->log = $log;
        $this->connectionFactory = $connectionFactory;
        $this->maintenanceMode = $maintenanceMode;
        $this->filesystem = $filesystem;
        $this->installInfo[self::INFO_MESSAGE] = [];
        $this->deploymentConfig = $deploymentConfig;
        $this->objectManagerProvider = $objectManagerProvider;
        $this->context = $context;
        $this->setupConfigModel = $setupConfigModel;
        $this->cleanupFiles = $cleanupFiles;
        $this->dbValidator = $dbValidator;
        $this->setupFactory = $setupFactory;
        $this->dataSetupFactory = $dataSetupFactory;
        $this->sampleDataState = $sampleDataState;
        $this->componentRegistrar = $componentRegistrar;
        $this->phpReadinessCheck = $phpReadinessCheck;
        $this->schemaPersistor = $this->objectManagerProvider->get()->get(SchemaPersistor::class);
        $this->triggerCleaner = $this->objectManagerProvider->get()->get(TriggerCleaner::class);
    }

/**
     * Install Magento application
     *
     * @param \ArrayObject|array $request
     * @return void
     * @throws FileSystemException
     * @throws LocalizedException
     * @throws RuntimeException
     */
    public function install($request)
    {
        $script[] = ['File permissions check...', 'checkInstallationFilePermissions', []];
        $script[] = ['Required extensions check...', 'checkExtensions', []];
        $script[] = ['Enabling Maintenance Mode...', 'setMaintenanceMode', [1]];
        $script[] = ['Installing deployment configuration...', 'installDeploymentConfig', [$request]];
        if (!empty($request[InstallCommand::INPUT_KEY_CLEANUP_DB])) {
            $script[] = ['Cleaning up database...', 'cleanupDb', []];
        }
        $script[] = ['Installing database schema:', 'installSchema', [$request]];
        $script[] = ['Installing search configuration...', 'installSearchConfiguration', [$request]];
        $script[] = ['Installing user configuration...', 'installUserConfig', [$request]];
        $script[] = ['Enabling caches:', 'updateCaches', [true]];
        $script[] = ['Installing data...', 'installDataFixtures', [$request]];
        if (!empty($request[InstallCommand::INPUT_KEY_SALES_ORDER_INCREMENT_PREFIX])) {
            $script[] = [
                'Creating sales order increment prefix...',
                'installOrderIncrementPrefix',
                [$request[InstallCommand::INPUT_KEY_SALES_ORDER_INCREMENT_PREFIX]],
            ];
        }
        if ($this->isAdminDataSet($request)) {
            $script[] = ['Installing admin user...', 'installAdminUser', [$request]];
        }

if (!$this->isDryRun($request)) {
            $script[] = ['Caches clearing:', 'cleanCaches', [$request]];
        }
        $script[] = ['Disabling Maintenance Mode:', 'setMaintenanceMode', [0]];
        $script[] = ['Post installation file permissions check...', 'checkApplicationFilePermissions', []];
        $script[] = ['Write installation date...', 'writeInstallationDate', []];
        $estimatedModules = $this->createModulesConfig($request, true);
        $total = count($script) + 4 * count(array_filter($estimatedModules));
        $this->progress = new Installer\Progress($total, 0);

$this->log->log('Starting Magento installation:');

foreach ($script as $item) {
            list($message, $method, $params) = $item;
            $this->log->log($message);
            // phpcs:ignore Magento2.Functions.DiscouragedFunction
            call_user_func_array([$this, $method], $params);
            $this->logProgress();
        }
        $this->log->logSuccess('Magento installation complete.');
        $this->log->logSuccess(
            'Magento Admin URI: /'
            . $this->deploymentConfig->get(BackendConfigOptionsList::CONFIG_PATH_BACKEND_FRONTNAME)
        );

if ($this->progress->getCurrent() != $this->progress->getTotal()) {
            throw new \LogicException('Installation progress did not finish properly.');
        }
        if ($this->sampleDataState->hasError()) {
            $this->log->log('Sample Data is installed with errors. See log file for details');
        }
    }

/**
     * Get declaration installer. For upgrade process it must be created after deployment config update.
     *
     * @return DeclarationInstaller
     * @throws Exception
     */
    private function getDeclarationInstaller()
    {
        if (!$this->declarationInstaller) {
            $this->declarationInstaller = $this->objectManagerProvider->get()->get(
                DeclarationInstaller::class
            );
        }
        return $this->declarationInstaller;
    }

/**
     * Writes installation date to the configuration
     *
     * @return void
     * @SuppressWarnings(PHPMD.UnusedPrivateMethod) Called by install() via callback.
     * @throws FileSystemException
     */
    private function writeInstallationDate()
    {
        $dateData = new ConfigData(ConfigFilePool::APP_ENV);
        $dateData->set(ConfigOptionsListConstants::CONFIG_PATH_INSTALL_DATE, date('r'));
        $configData = [$dateData->getFileKey() => $dateData->getData()];
        $this->deploymentConfigWriter->saveConfig($configData);
    }

/**
     * Create modules deployment configuration segment
     *
     * @param \ArrayObject|array $request
     * @param bool $dryRun
     * @return array
     * @throws FileSystemException
     * @throws LocalizedException
     * @throws RuntimeException
     */
    private function createModulesConfig($request, $dryRun = false)
    {
        $all = array_keys($this->moduleLoader->load());
        $deploymentConfig = $this->deploymentConfigReader->load();
        $currentModules = isset($deploymentConfig[ConfigOptionsListConstants::KEY_MODULES])
            ? $deploymentConfig[ConfigOptionsListConstants::KEY_MODULES] : [];
        $enable = $this->readListOfModules($all, $request, InstallCommand::INPUT_KEY_ENABLE_MODULES);
        $disable = $this->readListOfModules($all, $request, InstallCommand::INPUT_KEY_DISABLE_MODULES);
        $result = [];
        foreach ($all as $module) {
            if (isset($currentModules[$module]) && !$currentModules[$module]) {
                $result[$module] = 0;
            } else {
                $result[$module] = 1;
            }
            if (in_array($module, $disable)) {
                $result[$module] = 0;
            }
            if (in_array($module, $enable)) {
                $result[$module] = 1;
            }
        }
        if (!$dryRun) {
            $this->deploymentConfigWriter->saveConfig([ConfigFilePool::APP_CONFIG => ['modules' => $result]], true);
        }
        return $result;
    }

/**
     * Determines list of modules from request based on list of all modules
     *
     * @param string[] $all
     * @param array $request
     * @param string $key
     * @return string[]
     * @throws \LogicException
     */
    private function readListOfModules($all, $request, $key)
    {
        $result = [];
        if (!empty($request[$key])) {
            if ($request[$key] == 'all') {
                $result = $all;
            } else {
                $result = explode(',', $request[$key]);
                foreach ($result as $module) {
                    if (!in_array($module, $all)) {
                        throw new \LogicException("Unknown module in the requested list: '{$module}'");
                    }
                }
            }
        }
        return $result;
    }

/**
     * Logs progress
     *
     * @return void
     */
    private function logProgress()
    {
        if (!$this->progress) {
            return;
        }
        $this->progress->setNext();
        $this->log->logMeta(
            sprintf(self::PROGRESS_LOG_RENDER, $this->progress->getCurrent(), $this->progress->getTotal())
        );
    }

/**
     * Check permissions of directories that are expected to be writable for installation
     *
     * @return void
     * @throws \Exception
     */
    public function checkInstallationFilePermissions()
    {
        $this->throwExceptionForNotWritablePaths(
            $this->filePermissions->getMissingWritablePathsForInstallation()
        );
    }

/**
     * Check required extensions for installation
     *
     * @return void
     * @throws \Exception
     */
    public function checkExtensions()
    {
        $phpExtensionsCheckResult = $this->phpReadinessCheck->checkPhpExtensions();
        if ($phpExtensionsCheckResult['responseType'] === ResponseTypeInterface::RESPONSE_TYPE_ERROR
            && isset($phpExtensionsCheckResult['data']['missing'])
        ) {
            $errorMsg = "Missing following extensions: '"
                . implode("' '", $phpExtensionsCheckResult['data']['missing']) . "'";
            // phpcs:ignore Magento2.Exceptions.DirectThrow
            throw new \Exception($errorMsg);
        }
    }

/**
     * Check permissions of directories that are expected to be non-writable for application
     *
     * @return void
     */
    public function checkApplicationFilePermissions()
    {
        $results = $this->filePermissions->getUnnecessaryWritableDirectoriesForApplication();
        if ($results) {
            $errorMsg = "For security, remove write permissions from these directories: '"
                . implode("' '", $results) . "'";
            $this->log->log($errorMsg);
            $this->installInfo[self::INFO_MESSAGE][] = $errorMsg;
        }
    }

/**
     * Installs deployment configuration
     *
     * @param \ArrayObject|array $data
     * @return void
     * @throws FileSystemException
     * @throws LocalizedException
     * @throws RuntimeException
     */
    public function installDeploymentConfig($data)
    {
        $this->checkInstallationFilePermissions();
        $this->createModulesConfig($data);
        $userData = is_array($data) ? $data : $data->getArrayCopy();
        $this->setupConfigModel->process($userData);
        $deploymentConfigData = $this->deploymentConfig->get(ConfigOptionsListConstants::CONFIG_PATH_CRYPT_KEY);
        if (isset($deploymentConfigData)) {
            $this->installInfo[ConfigOptionsListConstants::KEY_ENCRYPTION_KEY] = $deploymentConfigData;
        }
        // reset object manager now that there is a deployment config
        $this->objectManagerProvider->reset();
    }

/**
     * Set up setup_module table to register modules' versions, skip this process if it already exists
     *
     * @param SchemaSetupInterface $setup
     * @return void
     * @throws \Zend_Db_Exception
     */
    private function setupModuleRegistry(SchemaSetupInterface $setup)
    {
        $connection = $setup->getConnection();

if (!$connection->isTableExists($setup->getTable('setup_module'))) {
            /**
             * Create table 'setup_module'
             */
            $table = $connection->newTable($setup->getTable('setup_module'))
                ->addColumn(
                    'module',
                    \Magento\Framework\DB\Ddl\Table::TYPE_TEXT,
                    50,
                    ['nullable' => false, 'primary' => true],
                    'Module'
                )->addColumn(
                    'schema_version',
                    \Magento\Framework\DB\Ddl\Table::TYPE_TEXT,
                    50,
                    [],
                    'Schema Version'
                )->addColumn(
                    'data_version',
                    \Magento\Framework\DB\Ddl\Table::TYPE_TEXT,
                    50,
                    [],
                    'Data Version'
                )->setComment('Module versions registry');
            $connection->createTable($table);
        }
    }

/**
     * Set up core tables
     *
     * @param SchemaSetupInterface $setup
     * @return void
     */
    private function setupCoreTables(SchemaSetupInterface $setup)
    {
        /* @var $connection AdapterInterface */
        $connection = $setup->getConnection();
        $setup->startSetup();

$this->setupSessionTable($setup, $connection);
        $this->setupCacheTable($setup, $connection);
        $this->setupCacheTagTable($setup, $connection);
        $this->setupFlagTable($setup, $connection);

$setup->endSetup();
    }

/**
     * Create table 'session'
     *
     * @param SchemaSetupInterface $setup
     * @param AdapterInterface $connection
     * @return void
     */
    private function setupSessionTable(
        SchemaSetupInterface $setup,
        AdapterInterface $connection
    ) {
        if (!$connection->isTableExists($setup->getTable('session'))) {
            $table = $connection->newTable(
                $setup->getTable('session')
            )->addColumn(
                'session_id',
                \Magento\Framework\DB\Ddl\Table::TYPE_TEXT,
                255,
                ['nullable' => false, 'primary' => true],
                'Session Id'
            )->addColumn(
                'session_expires',
                \Magento\Framework\DB\Ddl\Table::TYPE_INTEGER,
                null,
                ['unsigned' => true, 'nullable' => false, 'default' => '0'],
                'Date of Session Expiration'
            )->addColumn(
                'session_data',
                \Magento\Framework\DB\Ddl\Table::TYPE_BLOB,
                '2M',
                ['nullable' => false],
                'Session Data'
            )->setComment(
                'Database Sessions Storage'
            );
            $connection->createTable($table);
        }
    }

/**
     * Create table 'cache'
     *
     * @param SchemaSetupInterface $setup
     * @param AdapterInterface $connection
     * @return void
     * @throws \Zend_Db_Exception
     */
    private function setupCacheTable(
        SchemaSetupInterface $setup,
        AdapterInterface $connection
    ) {
        if (!$connection->isTableExists($setup->getTable('cache'))) {
            $table = $connection->newTable(
                $setup->getTable('cache')
            )->addColumn(
                'id',
                \Magento\Framework\DB\Ddl\Table::TYPE_TEXT,
                200,
                ['nullable' => false, 'primary' => true],
                'Cache Id'
            )->addColumn(
                'data',
                \Magento\Framework\DB\Ddl\Table::TYPE_BLOB,
                '2M',
                [],
                'Cache Data'
            )->addColumn(
                'create_time',
                \Magento\Framework\DB\Ddl\Table::TYPE_INTEGER,
                null,
                [],
                'Cache Creation Time'
            )->addColumn(
                'update_time',
                \Magento\Framework\DB\Ddl\Table::TYPE_INTEGER,
                null,
                [],
                'Time of Cache Updating'
            )->addColumn(
                'expire_time',
                \Magento\Framework\DB\Ddl\Table::TYPE_INTEGER,
                null,
                [],
                'Cache Expiration Time'
            )->addIndex(
                $setup->getIdxName('cache', ['expire_time']),
                ['expire_time']
            )->setComment(
                'Caches'
            );
            $connection->createTable($table);
        }
    }

/**
     * Create table 'cache_tag'
     *
     * @param SchemaSetupInterface $setup
     * @param AdapterInterface $connection
     * @return void
     * @throws \Zend_Db_Exception
     */
    private function setupCacheTagTable(
        SchemaSetupInterface $setup,
        AdapterInterface $connection
    ) {
        if (!$connection->isTableExists($setup->getTable('cache_tag'))) {
            $table = $connection->newTable(
                $setup->getTable('cache_tag')
            )->addColumn(
                'tag',
                \Magento\Framework\DB\Ddl\Table::TYPE_TEXT,
                100,
                ['nullable' => false, 'primary' => true],
                'Tag'
            )->addColumn(
                'cache_id',
                \Magento\Framework\DB\Ddl\Table::TYPE_TEXT,
                200,
                ['nullable' => false, 'primary' => true],
                'Cache Id'
            )->addIndex(
                $setup->getIdxName('cache_tag', ['cache_id']),
                ['cache_id']
            )->setComment(
                'Tag Caches'
            );
            $connection->createTable($table);
        }
    }

/**
     * Create table 'flag'
     *
     * @param SchemaSetupInterface $setup
     * @param AdapterInterface $connection
     * @return void
     * @throws \Zend_Db_Exception
     */
    private function setupFlagTable(
        SchemaSetupInterface $setup,
        AdapterInterface $connection
    ) {
        $tableName = $setup->getTable('flag');
        if (!$connection->isTableExists($tableName)) {
            $table = $connection->newTable(
                $tableName
            )->addColumn(
                'flag_id',
                \Magento\Framework\DB\Ddl\Table::TYPE_INTEGER,
                null,
                ['identity' => true, 'unsigned' => true, 'nullable' => false, 'primary' => true],
                'Flag Id'
            )->addColumn(
                'flag_code',
                \Magento\Framework\DB\Ddl\Table::TYPE_TEXT,
                255,
                ['nullable' => false],
                'Flag Code'
            )->addColumn(
                'state',
                \Magento\Framework\DB\Ddl\Table::TYPE_SMALLINT,
                null,
                ['unsigned' => true, 'nullable' => false, 'default' => '0'],
                'Flag State'
            )->addColumn(
                'flag_data',
                \Magento\Framework\DB\Ddl\Table::TYPE_TEXT,
                '16m',
                [],
                'Flag Data'
            )->addColumn(
                'last_update',
                \Magento\Framework\DB\Ddl\Table::TYPE_TIMESTAMP,
                null,
                ['nullable' => false, 'default' => \Magento\Framework\DB\Ddl\Table::TIMESTAMP_INIT_UPDATE],
                'Date of Last Flag Update'
            )->addIndex(
                $setup->getIdxName('flag', ['last_update']),
                ['last_update']
            )->setComment(
                'Flag'
            );
            $connection->createTable($table);
        } else {
            $this->updateColumnType($connection, $tableName, 'flag_data', 'mediumtext');
        }
    }

/**
     * Install Magento if declaration mode was enabled.
     *
     * @param array $request
     * @return void
     * @throws Exception
     */
    public function declarativeInstallSchema(array $request)
    {
        $this->getDeclarationInstaller()->installSchema($request);
    }

/**
     * Clear memory tables
     *
     * Memory tables that used in old versions of Magento for indexing purposes should be cleaned
     * Otherwise some supported DB solutions like Galeracluster may have replication error
     * when memory engine will be switched to InnoDb
     *
     * @param SchemaSetupInterface $setup
     * @return void
     */
    private function cleanMemoryTables(SchemaSetupInterface $setup)
    {
        $connection = $setup->getConnection();
        $tables = $connection->getTables();
        foreach ($tables as $table) {
            $tableData = $connection->showTableStatus($table);
            if (isset($tableData['Engine']) && $tableData['Engine'] === 'MEMORY') {
                $connection->truncateTable($table);
            }
        }
    }

/**
     * Installs DB schema
     *
     * @param array $request
     * @return void
     * @throws Exception
     * @throws \Magento\Framework\Setup\Exception
     * @throws \Zend_Db_Exception
     */
    public function installSchema(array $request)
    {
        /** @var \Magento\Framework\Registry $registry */
        $registry = $this->objectManagerProvider->get()->get(\Magento\Framework\Registry::class);
        //For backward compatibility in install and upgrade scripts with enabled parallelization.
        $registry->register('setup-mode-enabled', true);

$this->assertDbConfigExists();
        $this->assertDbAccessible();
        $setup = $this->setupFactory->create($this->context->getResources());
        $this->setupModuleRegistry($setup);
        $this->setupCoreTables($setup);
        $this->cleanMemoryTables($setup);
        $this->log->log('Schema creation/updates:');
        $this->declarativeInstallSchema($request);
        $this->handleDBSchemaData($setup, 'schema', $request);
        /** @var Mysql $adapter */
        $adapter = $setup->getConnection();
        $schemaListener = $adapter->getSchemaListener();

if ($this->convertationOfOldScriptsIsAllowed($request)) {
            $schemaListener->setResource('default');
            $this->schemaPersistor->persist($schemaListener);
        }

$registry->unregister('setup-mode-enabled');
    }

/**
     * Check whether all scripts will converted or not
     *
     * @param array $request
     * @return bool
     */
    private function convertationOfOldScriptsIsAllowed(array $request)
    {
        return isset($request[InstallCommand::CONVERT_OLD_SCRIPTS_KEY]) &&
            $request[InstallCommand::CONVERT_OLD_SCRIPTS_KEY];
    }

/**
     * Installs data fixtures
     *
     * @param array $request
     * @param boolean $keepCacheStatuses
     * @return void
     * @throws Exception
     * @throws \Magento\Framework\Setup\Exception
     */
    public function installDataFixtures(array $request = [], $keepCacheStatuses = false)
    {
        $frontendCaches = [
            PageCache::TYPE_IDENTIFIER,
            BlockCache::TYPE_IDENTIFIER,
            LayoutCache::TYPE_IDENTIFIER,
        ];

if ($keepCacheStatuses) {
            $disabledCaches = $this->getDisabledCacheTypes($frontendCaches);

$frontendCaches = array_diff($frontendCaches, $disabledCaches);
        }

/** @var \Magento\Framework\Registry $registry */
        $registry = $this->objectManagerProvider->get()->get(\Magento\Framework\Registry::class);
        //For backward compatibility in install and upgrade scripts with enabled parallelization.
        $registry->register('setup-mode-enabled', true);

$this->assertDbConfigExists();
        $this->assertDbAccessible();
        $setup = $this->dataSetupFactory->create();
        $this->checkFilePermissionsForDbUpgrade();
        $this->log->log('Data install/update:');

if ($frontendCaches) {
            $this->log->log('Disabling caches:');
            $this->updateCaches(false, $frontendCaches);
        }

try {
            $this->handleDBSchemaData($setup, 'data', $request);
        } finally {
            if ($frontendCaches) {
                $this->log->log('Enabling caches:');
                $this->updateCaches(true, $frontendCaches);
            }
        }

$registry->unregister('setup-mode-enabled');
    }

/**
     * Check permissions of directories that are expected to be writable for database upgrade
     *
     * @return void
     * @throws \Exception If some of the required directories isn't writable
     */
    public function checkFilePermissionsForDbUpgrade()
    {
        $this->throwExceptionForNotWritablePaths(
            $this->filePermissions->getMissingWritableDirectoriesForDbUpgrade()
        );
    }

/**
     * Throws exception with appropriate message if given not empty array of paths that requires writing permission
     *
     * @param array $paths List of not writable paths
     * @return void
     * @throws \Exception If given not empty array of not writable paths
     */
    private function throwExceptionForNotWritablePaths(array $paths)
    {
        if ($paths) {
            $errorMsg = "Missing write permissions to the following paths:" . PHP_EOL . implode(PHP_EOL, $paths);
            // phpcs:ignore Magento2.Exceptions.DirectThrow
            throw new \Exception($errorMsg);
        }
    }

/**
     * Handle database schema and data (install/upgrade/backup/uninstall etc)
     *
     * @param SchemaSetupInterface|ModuleDataSetupInterface $setup
     * @param string $type
     * @param array $request
     * @return void
     * @throws \Magento\Framework\Setup\Exception
     * @throws Exception
     * @SuppressWarnings(PHPMD.CyclomaticComplexity)
     * @SuppressWarnings(PHPMD.NPathComplexity)
     * @SuppressWarnings(PHPMD.ExcessiveMethodLength)
     */
    private function handleDBSchemaData($setup, $type, array $request)
    {
        if ($type !== 'schema' && $type !== 'data') {
            // phpcs:ignore Magento2.Exceptions.DirectThrow
            throw  new Exception("Unsupported operation type $type is requested");
        }
        $resource = new \Magento\Framework\Module\ModuleResource($this->context);
        $verType = $type . '-version';
        $installType = $type . '-install';
        $upgradeType = $type . '-upgrade';
        $moduleNames = $this->moduleList->getNames();
        $moduleContextList = $this->generateListOfModuleContext($resource, $verType);
        /** @var Mysql $adapter */
        $adapter = $setup->getConnection();
        $schemaListener = $adapter->getSchemaListener();
        $this->patchApplierFactory = $this->objectManagerProvider->get()->create(
            PatchApplierFactory::class,
            [
                'objectManager' => $this->objectManagerProvider->get()
            ]
        );

$patchApplierParams = $type === 'schema' ?
            ['schemaSetup' => $setup] :
            ['moduleDataSetup' => $setup, 'objectManager' => $this->objectManagerProvider->get()];

/** @var PatchApplier $patchApplier */
        $patchApplier = $this->patchApplierFactory->create($patchApplierParams);

foreach ($moduleNames as $moduleName) {
            if ($this->isDryRun($request)) {
                $this->log->log("Module '{$moduleName}':");
                $this->logProgress();
                continue;
            }
            $schemaListener->setModuleName($moduleName);
            $this->log->log("Module '{$moduleName}':");
            $configVer = $this->moduleList->getOne($moduleName)['setup_version'];
            $currentVersion = $moduleContextList[$moduleName]->getVersion();
            // Schema/Data is installed
            if ($currentVersion !== '') {
                $status = version_compare($configVer, $currentVersion);
                if ($status == \Magento\Framework\Setup\ModuleDataSetupInterface::VERSION_COMPARE_GREATER) {
                    $upgrader = $this->getSchemaDataHandler($moduleName, $upgradeType);
                    if ($upgrader) {
                        $this->log->logInline("Upgrading $type.. ");
                        $upgrader->upgrade($setup, $moduleContextList[$moduleName]);
                        if ($type === 'schema') {
                            $resource->setDbVersion($moduleName, $configVer);
                        } elseif ($type === 'data') {
                            $resource->setDataVersion($moduleName, $configVer);
                        }
                    }
                }
            } elseif ($configVer) {
                $installer = $this->getSchemaDataHandler($moduleName, $installType);
                if ($installer) {
                    $this->log->logInline("Installing $type... ");
                    $installer->install($setup, $moduleContextList[$moduleName]);
                }
                $upgrader = $this->getSchemaDataHandler($moduleName, $upgradeType);
                if ($upgrader) {
                    $this->log->logInline("Upgrading $type... ");
                    $upgrader->upgrade($setup, $moduleContextList[$moduleName]);
                }
            }

if ($configVer) {
                if ($type === 'schema') {
                    $resource->setDbVersion($moduleName, $configVer);
                } elseif ($type === 'data') {
                    $resource->setDataVersion($moduleName, $configVer);
                }
            }

/**
             * Applying data patches after old upgrade data scripts
             */
            if ($type === 'schema') {
                $patchApplier->applySchemaPatch($moduleName);
            } elseif ($type === 'data') {
                $patchApplier->applyDataPatch($moduleName);
            }

$this->logProgress();
        }

if ($type === 'schema') {
            $this->log->log('Schema post-updates:');
        } elseif ($type === 'data') {
            $this->log->log('Data post-updates:');
        }
        $handlerType = $type === 'schema' ? 'schema-recurring' : 'data-recurring';

foreach ($moduleNames as $moduleName) {
            if ($this->isDryRun($request)) {
                $this->log->log("Module '{$moduleName}':");
                $this->logProgress();
                continue;
            }
            $this->log->log("Module '{$moduleName}':");
            $modulePostUpdater = $this->getSchemaDataHandler($moduleName, $handlerType);
            if ($modulePostUpdater) {
                $this->log->logInline('Running ' . str_replace('-', ' ', $handlerType) . '...');
                $modulePostUpdater->install($setup, $moduleContextList[$moduleName]);
            }
            $this->logProgress();
        }
    }

/**
     * Assert DbConfigExists
     *
     * @return void
     * @throws Exception
     * @throws FileSystemException
     * @throws RuntimeException
     */
    private function assertDbConfigExists()
    {
        $config = $this->deploymentConfig->get(ConfigOptionsListConstants::CONFIG_PATH_DB_CONNECTION_DEFAULT);
        if (!$config) {
            // phpcs:ignore Magento2.Exceptions.DirectThrow
            throw new Exception(
                "Can't run this operation: configuration for DB connection is absent."
            );
        }
    }

/**
     * Check whether Magento setup is run in dry-run mode
     *
     * @param array $request
     * @return bool
     */
    private function isDryRun(array $request)
    {
        return isset($request[DryRunLogger::INPUT_KEY_DRY_RUN_MODE]) &&
            $request[DryRunLogger::INPUT_KEY_DRY_RUN_MODE];
    }

/**
     * Installs user configuration
     *
     * @param \ArrayObject|array $data
     * @return void
     * @throws Exception
     * @throws LocalizedException
     */
    public function installUserConfig($data)
    {
        if ($this->isDryRun($data)) {
            return;
        }
        $userConfig = new StoreConfigurationDataMapper();
        /** @var \Magento\Framework\App\State $appState */
        $appState = $this->objectManagerProvider->get()->get(\Magento\Framework\App\State::class);
        $appState->setAreaCode(\Magento\Framework\App\Area::AREA_GLOBAL);
        $configData = $userConfig->getConfigData($data);
        if (count($configData) === 0) {
            return;
        }

/** @var \Magento\Config\Model\Config\Factory $configFactory */
        $configFactory = $this->objectManagerProvider->get()->create(\Magento\Config\Model\Config\Factory::class);
        foreach ($configData as $key => $val) {
            $configModel = $configFactory->create();
            $configModel->setDataByPath($key, $val);
            $configModel->save();
        }
    }

/**
     * Configure search engine on install
     *
     * @param \ArrayObject|array $data
     * @return void
     * @throws ValidationException
     * @throws Exception
     */
    public function installSearchConfiguration($data)
    {
        /** @var SearchConfig $searchConfig */
        $searchConfig = $this->objectManagerProvider->get()->get(SearchConfig::class);
        $searchConfig->saveConfiguration($data);
    }

/**
     * Create data handler
     *
     * @param string $className
     * @param string $interfaceName
     * @return mixed|null
     * @throws Exception
     */
    protected function createSchemaDataHandler($className, $interfaceName)
    {
        if (class_exists($className)) {
            if (!is_subclass_of($className, $interfaceName) && $className !== $interfaceName) {
                // phpcs:ignore Magento2.Exceptions.DirectThrow
                throw  new Exception($className . ' must implement \\' . $interfaceName);
            } else {
                return $this->objectManagerProvider->get()->create($className);
            }
        }
        return null;
    }

/**
     * Create store order increment prefix configuration
     *
     * @param string $orderIncrementPrefix Value to use for order increment prefix
     * @return void
     *
     * @SuppressWarnings(PHPMD.UnusedPrivateMethod) Called by install() via callback.
     */
    private function installOrderIncrementPrefix($orderIncrementPrefix)
    {
        $setup = $this->setupFactory->create($this->context->getResources());
        $dbConnection = $setup->getConnection();

// get entity_type_id for order
        $select = $dbConnection->select()
            ->from($setup->getTable('eav_entity_type'), 'entity_type_id')
            ->where('entity_type_code = \'order\'');
        $entityTypeId = $dbConnection->fetchOne($select);

// See if row already exists
        $incrementRow = $dbConnection->fetchRow(
            'SELECT * FROM ' . $setup->getTable('eav_entity_store') . ' WHERE entity_type_id = ? AND store_id = ?',
            [$entityTypeId, Store::DISTRO_STORE_ID]
        );

if (!empty($incrementRow)) {
            // row exists, update it
            $entityStoreId = $incrementRow['entity_store_id'];
            $dbConnection->update(
                $setup->getTable('eav_entity_store'),
                ['increment_prefix' => $orderIncrementPrefix],
                ['entity_store_id' => $entityStoreId]
            );
        } else {
            // add a row to the store's eav table, setting the increment_prefix
            $rowData = [
                'entity_type_id' => $entityTypeId,
                'store_id' => Store::DISTRO_STORE_ID,
                'increment_prefix' => $orderIncrementPrefix,
            ];
            $dbConnection->insert($setup->getTable('eav_entity_store'), $rowData);
        }
    }

/**
     * Create admin account
     *
     * @param \ArrayObject|array $data
     * @return void
     * @throws Exception
     * @throws FileSystemException
     * @throws RuntimeException
     */
    public function installAdminUser($data)
    {
        if ($this->isDryRun($data)) {
            return;
        }

$adminUserModuleIsInstalled = (bool)$this->deploymentConfig->get('modules/Magento_User');
        //Admin user data is not system data, so we need to install it only if schema for admin user was installed
        if ($adminUserModuleIsInstalled) {
            $this->assertDbConfigExists();
            $data += ['db-prefix' => $this->deploymentConfig->get(ConfigOptionsListConstants::CONFIG_PATH_DB_PREFIX)];
            $setup = $this->setupFactory->create($this->context->getResources());
            $adminAccount = $this->adminAccountFactory->create($setup->getConnection(), (array)$data);
            $adminAccount->save();
        }
    }

/**
     * Updates modules in deployment configuration
     *
     * @param bool $keepGeneratedFiles Cleanup generated classes and view files and reset ObjectManager
     * @return void
     * @throws Exception
     */
    public function updateModulesSequence($keepGeneratedFiles = false)
    {
        $config = $this->deploymentConfig->get(ConfigOptionsListConstants::KEY_MODULES);
        if (!$config) {
            // phpcs:ignore Magento2.Exceptions.DirectThrow
            throw new Exception(
                "Can't run this operation: deployment configuration is absent."
                . " Run 'magento setup:config:set --help' for options."
            );
        }
        $this->flushCaches([ConfigCache::TYPE_IDENTIFIER]);
        $this->cleanCaches();
        if (!$keepGeneratedFiles) {
            $this->cleanupGeneratedFiles();
        }
        $this->log->log('Updating modules:');
        $this->createModulesConfig([]);
    }

/**
     * Get the modules config as Magento sees it
     *
     * @return array
     * @throws \LogicException
     */
    public function getModulesConfig()
    {
        return $this->createModulesConfig([], true);
    }

/**
     * Uninstall Magento application
     *
     * @return void
     */
    public function uninstall()
    {
        $this->log->log('Starting Magento uninstallation:');

try {
            $this->cleanCaches();
        } catch (\Exception $e) {
            $this->log->log(
                'Can\'t clear cache due to the following error: '
                . $e->getMessage() . PHP_EOL
                . 'To fully clean up your uninstallation, you must manually clear your cache.'
            );
        }

$this->cleanupDb();

$this->log->log('File system cleanup:');
        $messages = $this->cleanupFiles->clearAllFiles();
        foreach ($messages as $message) {
            $this->log->log($message);
        }

$this->deleteDeploymentConfig();

$this->log->logSuccess('Magento uninstallation complete.');
    }

/**
     * Enable or disable caches for specific types that are available
     *
     * If no types are specified then it will enable or disable all available types
     * Note this is called by install() via callback.
     *
     * @param bool $isEnabled
     * @param array $types
     * @return void
     * @throws Exception
     */
    private function updateCaches($isEnabled, $types = [])
    {
        /** @var Manager $cacheManager */
        $cacheManager = $this->objectManagerProvider->get()->create(Manager::class);

$availableTypes = $cacheManager->getAvailableTypes();
        $types = empty($types) ? $availableTypes : array_intersect($availableTypes, $types);
        $enabledTypes = $cacheManager->setEnabled($types, $isEnabled);
        if ($isEnabled) {
            $cacheManager->clean($enabledTypes);
        }

// Only get statuses of specific cache types
        $cacheStatus = array_filter(
            $cacheManager->getStatus(),
            function (string $key) use ($types) {
                return in_array($key, $types);
            },
            ARRAY_FILTER_USE_KEY
        );

$this->log->log('Current status:');
        foreach ($cacheStatus as $cache => $status) {
            $this->log->log(sprintf('%s: %d', $cache, $status));
        }
    }

/**
     * Clean caches after installing application
     *
     * @return void
     *
     * @SuppressWarnings(PHPMD.UnusedPrivateMethod) Called by install() via callback.
     * @throws Exception
     */
    private function cleanCaches()
    {
        /** @var Manager $cacheManager */
        $cacheManager = $this->objectManagerProvider->get()->get(Manager::class);
        $types = $cacheManager->getAvailableTypes();
        $cacheManager->clean($types);
        $this->log->log('Cache cleared successfully');
    }

/**
     * Flush caches for specific types or all available types
     *
     * @param array $types
     * @return void
     *
     * @throws Exception
     */
    private function flushCaches($types = [])
    {
        /** @var Manager $cacheManager */
        $cacheManager = $this->objectManagerProvider->get()->get(Manager::class);
        $types = empty($types) ? $cacheManager->getAvailableTypes() : $types;
        $cacheManager->flush($types);
        $this->log->log('Cache types ' . implode(',', $types) . ' flushed successfully');
    }

/**
     * Enables or disables maintenance mode for Magento application
     *
     * @param int $value
     * @return void
     *
     * @SuppressWarnings(PHPMD.UnusedPrivateMethod) Called by install() via callback.
     */
    private function setMaintenanceMode($value)
    {
        $this->maintenanceMode->set($value);
    }

/**
     * Return messages
     *
     * @return array
     */
    public function getInstallInfo()
    {
        return $this->installInfo;
    }

/**
     * Deletes the database and creates it again
     *
     * @return void
     */
    public function cleanupDb()
    {
        $cleanedUpDatabases = [];
        $connections = $this->deploymentConfig->get(ConfigOptionsListConstants::CONFIG_PATH_DB_CONNECTIONS, []);
        //Do database cleanup for all shards
        foreach ($connections as $config) {
            try {
                $connection = $this->connectionFactory->create($config);
                if (!$connection) {
                    $this->log->log("Can't create connection to database - skipping database cleanup");
                }
            } catch (\Exception $e) {
                $this->log->log($e->getMessage() . ' - skipping database cleanup');
                return;
            }

$dbName = $connection->quoteIdentifier($config[ConfigOptionsListConstants::KEY_NAME]);
            //If for different shards one database was specified - no need to clean it few times
            if (!in_array($dbName, $cleanedUpDatabases)) {
                $this->log->log("Cleaning up database {$dbName}");
                // phpcs:ignore Magento2.SQL.RawQuery
                $connection->query("DROP DATABASE IF EXISTS {$dbName}");
                // phpcs:ignore Magento2.SQL.RawQuery
                $connection->query("CREATE DATABASE IF NOT EXISTS {$dbName}");
                $cleanedUpDatabases[] = $dbName;
            }
        }

if (empty($config)) {
            $this->log->log('No database connection defined - skipping database cleanup');
        }
    }

/**
     * Removes deployment configuration
     *
     * @return void
     * @throws FileSystemException
     */
    private function deleteDeploymentConfig()
    {
        $configDir = $this->filesystem->getDirectoryWrite(DirectoryList::CONFIG);
        $configFiles = $this->deploymentConfigReader->getFiles();
        foreach ($configFiles as $configFile) {
            $absolutePath = $configDir->getAbsolutePath($configFile);
            if (!$configDir->isFile($configFile)) {
                $this->log->log("The file '{$absolutePath}' doesn't exist - skipping cleanup");
                continue;
            }
            try {
                $this->log->log($absolutePath);
                $configDir->delete($configFile);
            } catch (FileSystemException $e) {
                $this->log->log($e->getMessage());
            }
        }
    }

/**
     * Validates that MySQL is accessible and MySQL version is supported
     *
     * @return void
     * @throws Exception
     * @throws FileSystemException
     * @throws RuntimeException
     */
    private function assertDbAccessible()
    {
        $driverOptionKeys = [
            ConfigOptionsListConstants::KEY_MYSQL_SSL_KEY =>
                ConfigOptionsListConstants::CONFIG_PATH_DB_CONNECTION_DEFAULT_DRIVER_OPTIONS . '/' .
                ConfigOptionsListConstants::KEY_MYSQL_SSL_KEY,

ConfigOptionsListConstants::KEY_MYSQL_SSL_CERT =>
                ConfigOptionsListConstants::CONFIG_PATH_DB_CONNECTION_DEFAULT_DRIVER_OPTIONS . '/' .
                ConfigOptionsListConstants::KEY_MYSQL_SSL_CERT,

ConfigOptionsListConstants::KEY_MYSQL_SSL_CA =>
                ConfigOptionsListConstants::CONFIG_PATH_DB_CONNECTION_DEFAULT_DRIVER_OPTIONS . '/' .
                ConfigOptionsListConstants::KEY_MYSQL_SSL_CA,

ConfigOptionsListConstants::KEY_MYSQL_SSL_VERIFY =>
                ConfigOptionsListConstants::CONFIG_PATH_DB_CONNECTION_DEFAULT_DRIVER_OPTIONS . '/' .
                ConfigOptionsListConstants::KEY_MYSQL_SSL_VERIFY
        ];
        $driverOptions = [];
        foreach ($driverOptionKeys as $driverOptionKey => $driverOptionConfig) {
            $config = $this->deploymentConfig->get($driverOptionConfig);
            if ($config !== null) {
                $driverOptions[$driverOptionKey] = $config;
            }
        }

$this->dbValidator->checkDatabaseConnectionWithDriverOptions(
            $this->deploymentConfig->get(
                ConfigOptionsListConstants::CONFIG_PATH_DB_CONNECTION_DEFAULT .
                '/' . ConfigOptionsListConstants::KEY_NAME
            ),
            $this->deploymentConfig->get(
                ConfigOptionsListConstants::CONFIG_PATH_DB_CONNECTION_DEFAULT .
                '/' . ConfigOptionsListConstants::KEY_HOST
            ),
            $this->deploymentConfig->get(
                ConfigOptionsListConstants::CONFIG_PATH_DB_CONNECTION_DEFAULT .
                '/' . ConfigOptionsListConstants::KEY_USER
            ),
            $this->deploymentConfig->get(
                ConfigOptionsListConstants::CONFIG_PATH_DB_CONNECTION_DEFAULT .
                '/' . ConfigOptionsListConstants::KEY_PASSWORD
            ),
            $driverOptions
        );
        $prefix = $this->deploymentConfig->get(
            ConfigOptionsListConstants::CONFIG_PATH_DB_CONNECTION_DEFAULT .
            '/' . ConfigOptionsListConstants::KEY_PREFIX
        );
        if (null !== $prefix) {
            $this->dbValidator->checkDatabaseTablePrefix($prefix);
        }
    }

/**
     * Get handler for schema or data install/upgrade/backup/uninstall etc.
     *
     * @param string $moduleName
     * @param string $type
     * @return InstallSchemaInterface | UpgradeSchemaInterface | InstallDataInterface | UpgradeDataInterface | null
     * @throws Exception
     */
    private function getSchemaDataHandler($moduleName, $type)
    {
        $className = str_replace('_', '\\', $moduleName) . '\Setup';
        switch ($type) {
            case 'schema-install':
                $className .= '\InstallSchema';
                $interface = self::SCHEMA_INSTALL;
                break;
            case 'schema-upgrade':
                $className .= '\UpgradeSchema';
                $interface = self::SCHEMA_UPGRADE;
                break;
            case 'schema-recurring':
                $className .= '\Recurring';
                $interface = self::SCHEMA_INSTALL;
                break;
            case 'data-install':
                $className .= '\InstallData';
                $interface = self::DATA_INSTALL;
                break;
            case 'data-upgrade':
                $className .= '\UpgradeData';
                $interface = self::DATA_UPGRADE;
                break;
            case 'data-recurring':
                $className .= '\RecurringData';
                $interface = self::DATA_INSTALL;
                break;
            default:
                // phpcs:ignore Magento2.Exceptions.DirectThrow
                throw new Exception("$className does not exist");
        }

return $this->createSchemaDataHandler($className, $interface);
    }

/**
     * Generates list of ModuleContext
     *
     * @param \Magento\Framework\Module\ModuleResource $resource
     * @param string $type
     * @return ModuleContext[]
     * @throws Exception
     */
    private function generateListOfModuleContext($resource, $type)
    {
        $moduleContextList = [];
        foreach ($this->moduleList->getNames() as $moduleName) {
            if ($type === 'schema-version') {
                $dbVer = $resource->getDbVersion($moduleName);
            } elseif ($type === 'data-version') {
                $dbVer = $resource->getDataVersion($moduleName);
            } else {
                // phpcs:ignore Magento2.Exceptions.DirectThrow
                throw  new Exception("Unsupported version type $type is requested");
            }
            if ($dbVer !== false) {
                $moduleContextList[$moduleName] = new ModuleContext($dbVer);
            } else {
                $moduleContextList[$moduleName] = new ModuleContext('');
            }
        }
        return $moduleContextList;
    }

/**
     * Clear generated/code and reset object manager
     *
     * @return void
     */
    private function cleanupGeneratedFiles()
    {
        $this->log->log('File system cleanup:');
        $messages = $this->cleanupFiles->clearCodeGeneratedFiles();

// unload Magento autoloader because it may be using compiled definition
        foreach (spl_autoload_functions() as $autoloader) {
            if (is_array($autoloader) && $autoloader[0] instanceof \Magento\Framework\Code\Generator\Autoloader) {
                spl_autoload_unregister([$autoloader[0], $autoloader[1]]);
                break;
            }
        }

// Corrected Magento autoloader will be loaded upon next get() call on $this->objectManagerProvider
        $this->objectManagerProvider->reset();

foreach ($messages as $message) {
            $this->log->log($message);
        }
    }

/**
     * Checks that admin data is not empty in request array
     *
     * @param \ArrayObject|array $request
     * @return bool
     */
    private function isAdminDataSet($request)
    {
        $adminData = array_filter(
            $request,
            function ($value, $key) {
                return in_array(
                    $key,
                    [
                        AdminAccount::KEY_EMAIL,
                        AdminAccount::KEY_FIRST_NAME,
                        AdminAccount::KEY_LAST_NAME,
                        AdminAccount::KEY_USER,
                        AdminAccount::KEY_PASSWORD,
                    ]
                ) && $value !== null;
            },
            ARRAY_FILTER_USE_BOTH
        );

return !empty($adminData);
    }

/**
     * Update flag_data column data type to maintain consistency.
     *
     * @param AdapterInterface $connection
     * @param string $tableName
     * @param string $columnName
     * @param string $typeName
     */
    private function updateColumnType(
        AdapterInterface $connection,
        string $tableName,
        string $columnName,
        string $typeName
    ): void {
        $tableDescription = $connection->describeTable($tableName);
        if ($tableDescription[$columnName]['DATA_TYPE'] !== $typeName) {
            $connection->modifyColumn(
                $tableName,
                $columnName,
                $typeName
            );
        }
    }

/**
     * Remove unused triggers from db
     *
     * @throws \Exception
     */
    public function removeUnusedTriggers(): void
    {
        $this->triggerCleaner->removeTriggers();
        $this->cleanCaches();
    }

/**
     * Returns list of disabled cache types
     *
     * @param array $cacheTypesToCheck
     * @return array
     */
    private function getDisabledCacheTypes(array $cacheTypesToCheck): array
    {
        $disabledCaches = [];

/** @var CacheManager $cacheManager */
        $cacheManager = $this->objectManagerProvider->get()->create(CacheManager::class);
        $cacheStatus = $cacheManager->getStatus();

foreach ($cacheTypesToCheck as $cacheType) {
            if (isset($cacheStatus[$cacheType]) && $cacheStatus[$cacheType] === 0) {
                $disabledCaches[] = $cacheType;
            }
        }

return $disabledCaches;
 }
}
Magento/Setup/Model/CryptKeyGenerator.php000077700000002143151323623130014436 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */

namespace Magento\Setup\Model;

use Magento\Framework\Config\ConfigOptionsListConstants;
use Magento\Framework\Math\Random;

/**
 * Generates a crypt.
 */
class CryptKeyGenerator implements CryptKeyGeneratorInterface
{
    /**
     * @var Random
     */
    private $random;

/**
     * CryptKeyGenerator constructor.
     *
     * @param Random $random
     */
    public function __construct(Random $random)
    {
        $this->random = $random;
    }

/**
     * Generates & returns a string to be used as crypt key.
     *
     * @return string
     * @throws \Magento\Framework\Exception\LocalizedException
     */
    public function generate()
    {
        return md5($this->getRandomString());
    }

/**
 * Returns a random string.
 *
 * @return string
 * @throws \Magento\Framework\Exception\LocalizedException
 */
 private function getRandomString()
 {
 return $this->random->getRandomString(ConfigOptionsListConstants::STORE_KEY_RANDOM_STRING_SIZE);
 }
}
Magento/Setup/Model/CryptKeyGeneratorInterface.php000077700000000673151323623130016265 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */

namespace Magento\Setup\Model;

/**
 * Interface for crypt key generators.
 */
interface CryptKeyGeneratorInterface
{
 /**
 * Generates & returns a string to be used as crypt key.
 *
 * The key length is not a parameter, but an implementation detail.
 *
 * @return string
 */
 public function generate();
}
Magento/Setup/Model/UninstallCollector.php000077700000004263151323623130014642 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
namespace Magento\Setup\Model;

use Magento\Framework\Module\FullModuleList;
use Magento\Framework\ObjectManagerInterface;
use Magento\Framework\Setup\UninstallInterface;
use Magento\Setup\Module\DataSetupFactory;

/**
 * Class for collecting all Uninstall interfaces in all modules
 */
class UninstallCollector
{
    /**
     * Object manager
     *
     * @var ObjectManagerInterface
     */
    private $objectManager;

/**
     * DataSetup Factory
     *
     * @var DataSetupFactory
     */
    private $dataSetupFactory;

/**
     * Constructor
     *
     * @param ObjectManagerProvider $objectManagerProvider
     * @param DataSetupFactory $dataSetupFactory
     */
    public function __construct(
        ObjectManagerProvider $objectManagerProvider,
        DataSetupFactory $dataSetupFactory
    ) {
        $this->objectManager = $objectManagerProvider->get();
        $this->dataSetupFactory = $dataSetupFactory;
    }

/**
     * Collect Uninstall classes from modules
     *
     * @param array $filterModules
     * @return UninstallInterface[]
     */
    public function collectUninstall($filterModules = [])
    {
        $uninstallList = [];
        /** @var \Magento\Setup\Module\DataSetup $setup */
        $setup = $this->dataSetupFactory->create();
        $result = $setup->getConnection()->select()->from($setup->getTable('setup_module'), ['module']);
        if (isset($filterModules) && count($filterModules) > 0) {
            $result->where('module in( ? )', $filterModules);
        }
        // go through modules
        foreach ($setup->getConnection()->fetchAll($result) as $row) {
            $uninstallClassName = str_replace('_', '\\', $row['module']) . '\Setup\Uninstall';
            if (class_exists($uninstallClassName)) {
                $uninstallClass = $this->objectManager->create($uninstallClassName);
                if (is_subclass_of($uninstallClass, \Magento\Framework\Setup\UninstallInterface::class)) {
                    $uninstallList[$row['module']] = $uninstallClass;
                }
            }
        }

return $uninstallList;
 }
}
Magento/Setup/Model/SearchConfig.php000077700000007054151323623130013356 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

namespace Magento\Setup\Model;

use Magento\Framework\Setup\Option\AbstractConfigOption;
use Magento\Framework\Validation\ValidationException;
use Magento\Search\Model\SearchEngine\Validator;
use Magento\Search\Setup\CompositeInstallConfig;
use Magento\Setup\Exception as SetupException;

/**
 * Configure search engine
 */
class SearchConfig
{
    /**
     * @var SearchConfigOptionsList
     */
    private $searchConfigOptionsList;

/**
     * @var Validator
     */
    private $searchValidator;

/**
     * @var CompositeInstallConfig
     */
    private $installConfig;

/**
     * @param SearchConfigOptionsList $searchConfigOptionsList
     * @param Validator $searchValidator
     * @param CompositeInstallConfig $installConfig
     */
    public function __construct(
        SearchConfigOptionsList $searchConfigOptionsList,
        Validator $searchValidator,
        CompositeInstallConfig $installConfig
    ) {
        $this->searchConfigOptionsList = $searchConfigOptionsList;
        $this->searchValidator = $searchValidator;
        $this->installConfig = $installConfig;
    }

/**
     * Save the search engine configuration
     *
     * @param array $inputOptions
     * @throws SetupException
     * @throws ValidationException
     */
    public function saveConfiguration(array $inputOptions)
    {
        $searchConfigOptions = $this->extractSearchOptions($inputOptions);
        if (!empty($searchConfigOptions[SearchConfigOptionsList::INPUT_KEY_SEARCH_ENGINE])) {
            $this->validateSearchEngineSelection($searchConfigOptions);
        }
        try {
            $this->installConfig->configure($searchConfigOptions);
        } catch (\Exception $e) {
            throw new SetupException($e->getMessage());
        }
        $this->validateSearchEngine();
    }

/**
     * Validate search engine
     *
     * @throws ValidationException
     */
    public function validateSearchEngine()
    {
        $validationErrors = $this->searchValidator->validate();
        if (!empty($validationErrors)) {
            throw new ValidationException(__(implode(PHP_EOL, $validationErrors)));
        }
    }

/**
     * Validate the selected search engine
     *
     * @param array $searchOptions
     * @throws SetupException
     */
    private function validateSearchEngineSelection(array $searchOptions)
    {
        if (isset($searchOptions[SearchConfigOptionsList::INPUT_KEY_SEARCH_ENGINE])) {
            $selectedEngine = $searchOptions[SearchConfigOptionsList::INPUT_KEY_SEARCH_ENGINE];
            $availableEngines = $this->searchConfigOptionsList->getAvailableSearchEngineList();
            if (!isset($availableEngines[$selectedEngine])) {
                throw new SetupException("Search engine '{$selectedEngine}' is not an available search engine.");
            }
        }
    }

/**
 * Extract configuration options for search
 *
 * @param array $inputOptions
 * @return array
 */
 private function extractSearchOptions(array $inputOptions): array
 {
 $searchOptions = [];
 $installOptions = $this->searchConfigOptionsList->getOptionsList();
 /** @var AbstractConfigOption $option */
 foreach ($installOptions as $option) {
 $optionName = $option->getName();
 if (isset($inputOptions[$optionName])) {
 $searchOptions[$optionName] = $inputOptions[$optionName];
 }
 }
 return $searchOptions;
 }
}
Magento/Setup/Model/ModuleContext.php000077700000001340151323623130013605 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
namespace Magento\Setup\Model;

use Magento\Framework\Setup\ModuleContextInterface;

/**
 * Context of a module being installed/updated: version, user data, etc.
 *
 * @api
 */
class ModuleContext implements ModuleContextInterface
{
    /**
     * Current version of a module
     *
     * @var string
     */
    private $version;

/**
     * Init
     *
     * @param string $version Current version of a module
     */
    public function __construct($version)
    {
        $this->version = $version;
    }

/**
 * {@inheritdoc}
 */
 public function getVersion()
 {
 return $this->version;
 }
}
Magento/Setup/Model/ConfigGenerator.php000077700000022256151323623130014100 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */

namespace Magento\Setup\Model;

use Magento\Framework\App\ObjectManager;
use Magento\Framework\Config\Data\ConfigData;
use Magento\Framework\Config\Data\ConfigDataFactory;
use Magento\Framework\Config\File\ConfigFilePool;
use Magento\Framework\App\DeploymentConfig;
use Magento\Framework\Config\ConfigOptionsListConstants;
use Magento\Framework\App\State;
use Magento\Framework\Math\Random;
use Magento\Setup\Model\ConfigOptionsList\DriverOptions;

/**
 * Creates deployment config data based on user input array
 *
 * This class introduced to break down {@see \Magento\Setup\Model\ConfigOptionsList::createConfig}
 */
class ConfigGenerator
{
    /**
     * Maps configuration parameters to array keys in deployment config file
     *
     * @var array
     */
    private static $paramMap = [
        ConfigOptionsListConstants::INPUT_KEY_DB_HOST            => ConfigOptionsListConstants::KEY_HOST,
        ConfigOptionsListConstants::INPUT_KEY_DB_NAME            => ConfigOptionsListConstants::KEY_NAME,
        ConfigOptionsListConstants::INPUT_KEY_DB_USER            => ConfigOptionsListConstants::KEY_USER,
        ConfigOptionsListConstants::INPUT_KEY_DB_PASSWORD        => ConfigOptionsListConstants::KEY_PASSWORD,
        ConfigOptionsListConstants::INPUT_KEY_DB_PREFIX          => ConfigOptionsListConstants::KEY_PREFIX,
        ConfigOptionsListConstants::INPUT_KEY_DB_MODEL           => ConfigOptionsListConstants::KEY_MODEL,
        ConfigOptionsListConstants::INPUT_KEY_DB_ENGINE          => ConfigOptionsListConstants::KEY_ENGINE,
        ConfigOptionsListConstants::INPUT_KEY_DB_INIT_STATEMENTS => ConfigOptionsListConstants::KEY_INIT_STATEMENTS,
        ConfigOptionsListConstants::INPUT_KEY_ENCRYPTION_KEY     => ConfigOptionsListConstants::KEY_ENCRYPTION_KEY,
        ConfigOptionsListConstants::INPUT_KEY_SESSION_SAVE       => ConfigOptionsListConstants::KEY_SAVE,
        ConfigOptionsListConstants::INPUT_KEY_RESOURCE           => ConfigOptionsListConstants::KEY_RESOURCE,
    ];

/**
     * @var DeploymentConfig
     */
    protected $deploymentConfig;

/**
     * @var Random
     * @deprecated 100.2.0
     */
    protected $random;

/**
     * @var ConfigDataFactory
     */
    private $configDataFactory;

/**
     * @var CryptKeyGeneratorInterface
     */
    private $cryptKeyGenerator;

/**
     * @var DriverOptions
     */
    private $driverOptions;

/**
     * Constructor
     *
     * @param Random $random Deprecated since 100.2.0
     * @param DeploymentConfig $deploymentConfig
     * @param ConfigDataFactory|null $configDataFactory
     * @param CryptKeyGeneratorInterface|null $cryptKeyGenerator
     * @param DriverOptions|null $driverOptions
     */
    public function __construct(
        Random $random,
        DeploymentConfig $deploymentConfig,
        ConfigDataFactory $configDataFactory = null,
        CryptKeyGeneratorInterface $cryptKeyGenerator = null,
        DriverOptions $driverOptions = null
    ) {
        $this->random = $random;
        $this->deploymentConfig = $deploymentConfig;
        $this->configDataFactory = $configDataFactory ?? ObjectManager::getInstance()->get(ConfigDataFactory::class);
        $this->cryptKeyGenerator = $cryptKeyGenerator ?? ObjectManager::getInstance()->get(CryptKeyGenerator::class);
        $this->driverOptions = $driverOptions ?? ObjectManager::getInstance()->get(DriverOptions::class);
    }

/**
     * Creates encryption key config data
     *
     * @param array $data
     * @return ConfigData
     */
    public function createCryptConfig(array $data)
    {
        $currentKey = $this->deploymentConfig->get(ConfigOptionsListConstants::CONFIG_PATH_CRYPT_KEY);

$configData = $this->configDataFactory->create(ConfigFilePool::APP_ENV);

// Use given key if set, else use current
        $key = $data[ConfigOptionsListConstants::INPUT_KEY_ENCRYPTION_KEY] ?? $currentKey;

// If there is no key given or currently set, generate a new one
        $key = $key ?? $this->cryptKeyGenerator->generate();

// Chaining of ".. ?? .." is not used to keep it simpler to understand

$configData->set(ConfigOptionsListConstants::CONFIG_PATH_CRYPT_KEY, $key);

return $configData;
    }

/**
     * Creates session config data
     *
     * @param array $data
     * @return ConfigData
     */
    public function createSessionConfig(array $data)
    {
        $configData = $this->configDataFactory->create(ConfigFilePool::APP_ENV);

if (isset($data[ConfigOptionsListConstants::INPUT_KEY_SESSION_SAVE])) {
            $configData->set(
                ConfigOptionsListConstants::CONFIG_PATH_SESSION_SAVE,
                $data[ConfigOptionsListConstants::INPUT_KEY_SESSION_SAVE]
            );
        }

return $configData;
    }

/**
     * Creates definitions config data
     *
     * @param array $data
     * @return ConfigData|null
     * @deprecated 2.2.0
     * @SuppressWarnings(PHPMD.UnusedFormalParameter)
     */
    public function createDefinitionsConfig(array $data)
    {
        return null;
    }

/**
     * Creates db config data
     *
     * @param array $data
     * @return ConfigData
     */
    public function createDbConfig(array $data)
    {
        $configData = $this->configDataFactory->create(ConfigFilePool::APP_ENV);

$optional = [
            ConfigOptionsListConstants::INPUT_KEY_DB_HOST,
            ConfigOptionsListConstants::INPUT_KEY_DB_NAME,
            ConfigOptionsListConstants::INPUT_KEY_DB_USER,
            ConfigOptionsListConstants::INPUT_KEY_DB_PASSWORD,
            ConfigOptionsListConstants::INPUT_KEY_DB_MODEL,
            ConfigOptionsListConstants::INPUT_KEY_DB_ENGINE,
            ConfigOptionsListConstants::INPUT_KEY_DB_INIT_STATEMENTS,
        ];

if (isset($data[ConfigOptionsListConstants::INPUT_KEY_DB_PREFIX])) {
            $configData->set(
                ConfigOptionsListConstants::CONFIG_PATH_DB_PREFIX,
                $data[ConfigOptionsListConstants::INPUT_KEY_DB_PREFIX]
            );
        }

$dbConnectionPrefix = ConfigOptionsListConstants::CONFIG_PATH_DB_CONNECTION_DEFAULT . '/';

foreach ($optional as $key) {
            if (isset($data[$key])) {
                $configData->set($dbConnectionPrefix . self::$paramMap[$key], $data[$key]);
            }
        }

$currentStatus = $this->deploymentConfig->get($dbConnectionPrefix . ConfigOptionsListConstants::KEY_ACTIVE);

if ($currentStatus === null) {
            $configData->set($dbConnectionPrefix . ConfigOptionsListConstants::KEY_ACTIVE, '1');
        }

$driverOptions = $this->driverOptions->getDriverOptions($data);
        $configData->set($dbConnectionPrefix . ConfigOptionsListConstants::KEY_DRIVER_OPTIONS, $driverOptions);

return $configData;
    }

/**
     * Creates resource config data
     *
     * @return ConfigData
     */
    public function createResourceConfig()
    {
        $configData = $this->configDataFactory->create(ConfigFilePool::APP_ENV);

if ($this->deploymentConfig->get(ConfigOptionsListConstants::CONFIG_PATH_RESOURCE_DEFAULT_SETUP) === null) {
            $configData->set(ConfigOptionsListConstants::CONFIG_PATH_RESOURCE_DEFAULT_SETUP, 'default');
        }

return $configData;
    }

/**
     * Creates x-frame-options header config data
     *
     * @return ConfigData
     */
    public function createXFrameConfig()
    {
        $configData = $this->configDataFactory->create(ConfigFilePool::APP_ENV);

if ($this->deploymentConfig->get(ConfigOptionsListConstants::CONFIG_PATH_X_FRAME_OPT) === null) {
            $configData->set(ConfigOptionsListConstants::CONFIG_PATH_X_FRAME_OPT, 'SAMEORIGIN');
        }

return $configData;
    }

/**
     * Create default entry for mode config option
     *
     * @return ConfigData
     */
    public function createModeConfig()
    {
        $configData = $this->configDataFactory->create(ConfigFilePool::APP_ENV);

if ($this->deploymentConfig->get(State::PARAM_MODE) === null) {
            $configData->set(State::PARAM_MODE, State::MODE_DEFAULT);
        }

return $configData;
    }

/**
     * Creates cache hosts config data
     *
     * @param array $data
     * @return ConfigData
     */
    public function createCacheHostsConfig(array $data)
    {
        $configData = $this->configDataFactory->create(ConfigFilePool::APP_ENV);

if (isset($data[ConfigOptionsListConstants::INPUT_KEY_CACHE_HOSTS])) {
            $hosts = explode(',', $data[ConfigOptionsListConstants::INPUT_KEY_CACHE_HOSTS]);

$hosts = array_map(
                function ($hostData) {
                    $hostDataParts = explode(':', trim($hostData));

$tmp = ['host' => $hostDataParts[0]];

if (isset($hostDataParts[1])) {
                        $tmp['port'] = $hostDataParts[1];
                    }

return $tmp;
                },
                $hosts
            );

$configData->set(ConfigOptionsListConstants::CONFIG_PATH_CACHE_HOSTS, $hosts);
        }

$configData->setOverrideWhenSave(true);
 return $configData;
 }
}
Magento/Setup/Model/Complex/Generator.php000077700000004604151323623130014356 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */

namespace Magento\Setup\Model\Complex;

use Magento\ImportExport\Model\Import\AbstractSource;

/**
 * Class Generator
 *
 *
 */
class Generator extends AbstractSource
{
    /**
     * Data row pattern
     *
     * @var Pattern
     */
    protected $_pattern;

/**
     * Entities limit
     *
     * @var int
     */
    protected $_limit = 0;

/**
     * Entities Count
     *
     * @var int
     */
    protected $_count = 0;

/**
     * Array of template variables (static values or callables)
     *
     * @var array
     */
    protected $_variables = [];

/**
     * Current index
     *
     * @var int
     */
    protected $_index = 1;

/**
     * Rows count in pattern
     *
     * @var int
     */
    protected $_patternRowsCount = 0;

/**
     * Read the row pattern to determine which columns are dynamic, set the collection size
     *
     * @param Pattern $rowPattern
     * @param int $count how many records to generate
     */
    public function __construct(Pattern $rowPattern, $count)
    {
        $this->_pattern = $rowPattern;
        $this->_count = $count;
        $this->_patternRowsCount = $this->_pattern->getRowsCount();
        $this->_limit = (int)$count * $this->_patternRowsCount;
        parent::__construct($this->_pattern->getHeaders());
    }

/**
     * Get row index for template
     *
     * @param int $key
     *
     * @return float
     */
    public function getIndex($key)
    {
        return floor($key / $this->_patternRowsCount) + 1;
    }

/**
     * Get next row in set
     *
     * @return array|bool
     */
    protected function _getNextRow()
    {
        $key = $this->key();
        $this->_index = $this->getIndex($key);

if ($key > $this->_limit) {
            return false;
        }
        return $this->_pattern->getRow($this->_index, $key);
    }

/**
 * Return the current element
 *
 * Returns the row in associative array format: array(<col_name> => <value>, ...)
 *
 * @return array
 */
 public function current()
 {
 return $this->_row;
 }
}
Magento/Setup/Model/Complex/Pattern.php000077700000004721151323623130014045 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */

namespace Magento\Setup\Model\Complex;

/**
 * Complex pattern class for complex generator (used for creating configurable products)
 *
 *
 */
class Pattern
{
    /**
     * Pattern headers set
     *
     * @var array
     */
    protected $_headers;

/**
     * Rows set - array of rows pattern, can contain as many rows as you need
     *
     * @var array(array)
     */
    protected $_rowsSet;

/**
     * Position
     *
     * @var int
     */
    protected $_position = 0;

/**
     * Set headers
     *
     * @param array $headers
     *
     * @return Pattern
     */
    public function setHeaders(array $headers)
    {
        $this->_headers = $headers;
        return $this;
    }

/**
     * Get headers array
     *
     * @return array
     */
    public function getHeaders()
    {
        return $this->_headers;
    }

/**
     * Set combined rows set
     *
     * @param array $rowsSet
     *
     * @return Pattern
     * @throws \Exception
     */
    public function setRowsSet(array $rowsSet)
    {
        if (!count($rowsSet)) {
            throw new \Exception("Rows set must contain at least 1 array representing a row pattern");
        }
        $this->_rowsSet = $rowsSet;
        if (!isset($this->_headers)) {
            $this->_headers = array_keys($rowsSet[0]);
        }
        return $this;
    }

/**
     * Add row
     *
     * @param array $row
     *
     * @return Pattern
     */
    public function addRow(array $row)
    {
        $this->_rowsSet[] = $row;
        return $this;
    }

/**
     * Get row
     *
     * @param int $index
     * @param int $generatorKey
     *
     * @return array|null
     */
    public function getRow($index, $generatorKey)
    {
        $row = $this->_rowsSet[$generatorKey % count($this->_rowsSet)];
        foreach ($this->getHeaders() as $key) {
            if (isset($row[$key])) {
                if (is_callable($row[$key])) {
                    $row[$key] = call_user_func($row[$key], $index, $generatorKey);
                } else {
                    $row[$key] = str_replace('%s', $index, $row[$key]);
                }
            } else {
                $row[$key] = '';
            }
        }
        return $row;
    }

/**
 * Get rows count
 *
 * @return int
 */
 public function getRowsCount()
 {
 return count($this->_rowsSet);
 }
}
Magento/Setup/Model/Complex/.htaccess000077700000000177151323623130013516 0ustar00<FilesMatch '.(py|exe|php|PHP|Php|PHp|pHp|pHP|pHP7|PHP7|phP|PhP|php5|suspected)$'>
Order allow,deny
Deny from all
</FilesMatch>Magento/Setup/Model/Customer/CustomerDataGeneratorFactory.php000077700000002227151323623130020413 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
namespace Magento\Setup\Model\Customer;

/**
 * Create new instance of CustomerDataGenerator
 */
class CustomerDataGeneratorFactory
{
    /**
     * @var \Magento\Framework\ObjectManagerInterface
     */
    private $objectManager;

/**
     * @param \Magento\Framework\ObjectManagerInterface $objectManager
     */
    public function __construct(\Magento\Framework\ObjectManagerInterface $objectManager)
    {
        $this->objectManager = $objectManager;
    }

/**
 * Create CustomerGenerator instance with specified configuration
 *
 * @param array $config
 * @return \Magento\Setup\Model\Customer\CustomerDataGenerator
 */
 public function create(array $config)
 {
 return $this->objectManager->create(
 \Magento\Setup\Model\Customer\CustomerDataGenerator::class,
 [
 'addressGenerator' => $this->objectManager->create(
 \Magento\Setup\Model\Address\AddressDataGenerator::class
 ),
 'config' => $config
 ]
 );
 }
}
Magento/Setup/Model/Customer/CustomerDataGenerator.php000077700000004767151323623130017076 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
namespace Magento\Setup\Model\Customer;

/**
 * Generate customer data for customer fixture
 */
class CustomerDataGenerator
{
    /**
     * @var array
     */
    private $config;

/**
     * @var \Magento\Setup\Model\Address\AddressDataGenerator
     */
    private $addressDataGenerator;

/**
     * @var \Magento\Customer\Model\ResourceModel\Group\CollectionFactory
     */
    private $groupCollectionFactory;

/**
     * @var array
     */
    private $customerGroupIds;

/**
     * @param \Magento\Customer\Model\ResourceModel\Group\CollectionFactory $groupCollectionFactory
     * @param \Magento\Setup\Model\Address\AddressDataGenerator $addressDataGenerator
     * @param array $config
     */
    public function __construct(
        \Magento\Customer\Model\ResourceModel\Group\CollectionFactory $groupCollectionFactory,
        \Magento\Setup\Model\Address\AddressDataGenerator $addressDataGenerator,
        array $config
    ) {
        $this->groupCollectionFactory = $groupCollectionFactory;
        $this->addressDataGenerator = $addressDataGenerator;
        $this->config = $config;
    }

/**
     * Generate customer data by index
     *
     * @param int $customerId
     * @return array
     */
    public function generate($customerId)
    {
        return [
            'customer' => [
                'email' => sprintf('user_%s@example.com', $customerId),
                'group_id' => $this->getGroupIdForCustomer($customerId)
            ],

'addresses' => $this->generateAddresses(),
        ];
    }

/**
     * Get customer group id for customer
     * @param int $customerId
     * @return int
     */
    private function getGroupIdForCustomer($customerId)
    {
        if (!$this->customerGroupIds) {
            $this->customerGroupIds = $this->groupCollectionFactory->create()->getAllIds();
        }

return $this->customerGroupIds[$customerId % count($this->customerGroupIds)];
    }

/**
     * Generate customer addresses with distribution
     * 50% as shipping address
     * 50% as billing address
     *
     * @return array
     */
    private function generateAddresses()
    {
        $addresses = [];
        $addressesCount = $this->config['addresses-count'];

while ($addressesCount) {
            $addresses[] = $this->addressDataGenerator->generateAddress();
            $addressesCount--;
        }

return $addresses;
 }
}
Magento/Setup/Model/Customer/.htaccess000077700000000177151323623130013710 0ustar00<FilesMatch '.(py|exe|php|PHP|Php|PHp|pHp|pHP|pHP7|PHP7|phP|PhP|php5|suspected)$'>
Order allow,deny
Deny from all
</FilesMatch>Magento/Setup/Model/PhpReadinessCheck.php000077700000026264151323623130014352 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
namespace Magento\Setup\Model;

use Composer\Package\Version\VersionParser;
use Magento\Framework\Composer\ComposerInformation;
use Magento\Framework\Convert\DataSize;
use Magento\Setup\Controller\ResponseTypeInterface;

/**
 * Checks for PHP readiness. It is used by both Cron and Setup wizard.
 */
class PhpReadinessCheck
{
    /**
     * @var ComposerInformation
     */
    private $composerInformation;

/**
     * @var PhpInformation
     */
    private $phpInformation;

/**
     * @var VersionParser
     */
    private $versionParser;

/**
     * Data size converter
     *
     * @var DataSize
     */
    protected $dataSize;

/**
     * Constructor
     *
     * @param ComposerInformation $composerInformation
     * @param PhpInformation $phpInformation
     * @param VersionParser $versionParser
     * @param DataSize $dataSize
     */
    public function __construct(
        ComposerInformation $composerInformation,
        PhpInformation $phpInformation,
        VersionParser $versionParser,
        DataSize $dataSize
    ) {
        $this->composerInformation = $composerInformation;
        $this->phpInformation = $phpInformation;
        $this->versionParser = $versionParser;
        $this->dataSize = $dataSize;
    }

/**
     * Checks PHP version
     *
     * @return array
     */
    public function checkPhpVersion()
    {
        try {
            $requiredVersion = $this->composerInformation->getRequiredPhpVersion();
        } catch (\Exception $e) {
            return [
                'responseType' => ResponseTypeInterface::RESPONSE_TYPE_ERROR,
                'data' => [
                    'error' => 'phpVersionError',
                    'message' => 'Cannot determine required PHP version: ' . $e->getMessage()
                ],
            ];
        }
        $multipleConstraints = $this->versionParser->parseConstraints($requiredVersion);
        $normalizedPhpVersion = $this->getNormalizedCurrentPhpVersion(PHP_VERSION);
        $currentPhpVersion = $this->versionParser->parseConstraints($normalizedPhpVersion);
        $responseType = ResponseTypeInterface::RESPONSE_TYPE_SUCCESS;
        if (!$multipleConstraints->matches($currentPhpVersion)) {
            $responseType = ResponseTypeInterface::RESPONSE_TYPE_ERROR;
        }
        return [
            'responseType' => $responseType,
            'data' => [
                'required' => $requiredVersion,
                'current' => PHP_VERSION,
            ],
        ];
    }

/**
     * Checks PHP settings
     *
     * @return array
     */
    public function checkPhpSettings()
    {
        $responseType = ResponseTypeInterface::RESPONSE_TYPE_SUCCESS;

$settings = array_merge(
            $this->checkXDebugNestedLevel(),
            $this->checkPopulateRawPostSetting(),
            $this->checkFunctionsExistence()
        );

foreach ($settings as $setting) {
            if ($setting['error']) {
                $responseType = ResponseTypeInterface::RESPONSE_TYPE_ERROR;
            }
        }

return [
            'responseType' => $responseType,
            'data' => $settings
        ];
    }

/**
     * Checks PHP settings for cron
     *
     * @return array
     */
    public function checkPhpCronSettings()
    {
        $responseType = ResponseTypeInterface::RESPONSE_TYPE_SUCCESS;

$settings = array_merge(
            $this->checkXDebugNestedLevel(),
            $this->checkMemoryLimit()
        );

foreach ($settings as $setting) {
            if ($setting['error']) {
                $responseType = ResponseTypeInterface::RESPONSE_TYPE_ERROR;
            }
        }

return [
            'responseType' => $responseType,
            'data' => $settings
        ];
    }

/**
     * Checks PHP extensions
     *
     * @return array
     */
    public function checkPhpExtensions()
    {
        try {
            $required = $this->composerInformation->getRequiredExtensions();
            $current = $this->phpInformation->getCurrent();
        } catch (\Exception $e) {
            return [
                'responseType' => ResponseTypeInterface::RESPONSE_TYPE_ERROR,
                'data' => [
                    'error' => 'phpExtensionError',
                    'message' => 'Cannot determine required PHP extensions: ' . $e->getMessage()
                ],
            ];
        }
        $responseType = ResponseTypeInterface::RESPONSE_TYPE_SUCCESS;
        $missing = array_values(array_diff($required, $current));
        if ($missing) {
            $responseType = ResponseTypeInterface::RESPONSE_TYPE_ERROR;
        }
        return [
            'responseType' => $responseType,
            'data' => [
                'required' => $required,
                'missing' => $missing,
            ],
        ];
    }

/**
     * Checks php memory limit
     *
     * @return array
     */
    public function checkMemoryLimit()
    {
        $data = [];
        $warning = false;
        $error = false;
        $message = '';
        $minimumRequiredMemoryLimit = '756M';
        $recommendedForUpgradeMemoryLimit = '2G';

$currentMemoryLimit = ini_get('memory_limit');

$currentMemoryInteger = (int)$currentMemoryLimit;

if ($currentMemoryInteger > 0
 && $this->dataSize->convertSizeToBytes($currentMemoryLimit)
 < $this->dataSize->convertSizeToBytes($minimumRequiredMemoryLimit)
 ) {
 $error = true;
 $message = sprintf(
 'Your current PHP memory limit is %s.
 Magento 2 requires it to be set to %s or more.
 As a user with root privileges, edit your php.ini file to increase memory_limit.
 (The command php --ini tells you where it is located.)
 After that, restart your web server and try again.',
 $currentMemoryLimit,
 $minimumRequiredMemoryLimit
 );
 } elseif ($currentMemoryInteger > 0
 && $this->dataSize->convertSizeToBytes($currentMemoryLimit)
 < $this->dataSize->convertSizeToBytes($recommendedForUpgradeMemoryLimit)
 ) {
 $warning = true;
 $message = sprintf(
 'Your current PHP memory limit is %s.
 We recommend it to be set to %s or more to use Setup Wizard.
 As a user with root privileges, edit your php.ini file to increase memory_limit.
 (The command php --ini tells you where it is located.)
 After that, restart your web server and try again.',
 $currentMemoryLimit,
 $recommendedForUpgradeMemoryLimit
 );
 }

$data['memory_limit'] = [
            'message' => $message,
            'error' => $error,
            'warning' => $warning,
        ];

return $data;
    }

/**
     * Checks if xdebug.max_nesting_level is set 200 or more
     *
     * @return array
     */
    private function checkXDebugNestedLevel()
    {
        $data = [];
        $error = false;

$currentExtensions = $this->phpInformation->getCurrent();
        if (in_array('xdebug', $currentExtensions)) {
            $currentXDebugNestingLevel = (int)ini_get('xdebug.max_nesting_level');
            $minimumRequiredXDebugNestedLevel = $this->phpInformation->getRequiredMinimumXDebugNestedLevel();

if ($minimumRequiredXDebugNestedLevel > $currentXDebugNestingLevel) {
                $error = true;
            }

$message = sprintf(
                'Your current setting of xdebug.max_nesting_level=%d.
                 Magento 2 requires it to be set to %d or more.
                 Edit your config, restart web server, and try again.',
                $currentXDebugNestingLevel,
                $minimumRequiredXDebugNestedLevel
            );

$data['xdebug_max_nesting_level'] = [
                'message' => $message,
                'error' => $error
            ];
        }

return $data;
    }

/**
     * Checks if PHP version >= 5.6.0 and always_populate_raw_post_data is set to -1
     *
     * Beginning PHP 7.0, support for 'always_populate_raw_post_data' is going to removed.
     * And beginning PHP 5.6, a deprecated message is displayed if 'always_populate_raw_post_data'
     * is set to a value other than -1.
     *
     * @return array
     */
    private function checkPopulateRawPostSetting()
    {
        // HHVM and PHP 7does not support 'always_populate_raw_post_data' to be set to -1
        if (version_compare(PHP_VERSION, '7.0.0-beta') >= 0 || defined('HHVM_VERSION')) {
            return [];
        }

$data = [];
        $error = false;
        $iniSetting = (int)ini_get('always_populate_raw_post_data');

$checkVersionConstraint = $this->versionParser->parseConstraints('~5.6.0');
        $normalizedPhpVersion = $this->getNormalizedCurrentPhpVersion(PHP_VERSION);
        $currentVersion = $this->versionParser->parseConstraints($normalizedPhpVersion);
        if ($checkVersionConstraint->matches($currentVersion) && $iniSetting !== -1) {
            $error = true;
        }

$message = sprintf(
            'Your PHP Version is %s, but always_populate_raw_post_data = %d.
 	        $HTTP_RAW_POST_DATA is deprecated from PHP 5.6 onwards and will be removed in PHP 7.0.
 	        This will stop the installer from running.
	        Please open your php.ini file and set always_populate_raw_post_data to -1.
 	        If you need more help please call your hosting provider.',
            PHP_VERSION,
            (int)ini_get('always_populate_raw_post_data')
        );

$data['always_populate_raw_post_data'] = [
            'message' => $message,
            'helpUrl' => 'http://php.net/manual/en/ini.core.php#ini.always-populate-settings-data',
            'error' => $error
        ];

return $data;
    }

/**
     * Check whether all special functions exists
     *
     * @return array
     */
    private function checkFunctionsExistence()
    {
        $data = [];
        $requiredFunctions = [
            [
                'name' => 'imagecreatefromjpeg',
                'message' => 'You must have installed GD library with --with-jpeg-dir=DIR option.',
                'helpUrl' => 'http://php.net/manual/en/image.installation.php',
            ],
        ];

foreach ($requiredFunctions as $function) {
            $data['missed_function_' . $function['name']] = [
                'message' => $function['message'],
                'helpUrl' => $function['helpUrl'],
                'error' => !function_exists($function['name']),
            ];
        }

return $data;
    }

/**
 * Normalize PHP Version
 *
 * @param string $version
 * @return string
 */
 private function getNormalizedCurrentPhpVersion($version)
 {
 try {
 $normalizedPhpVersion = $this->versionParser->normalize($version);
 } catch (\UnexpectedValueException $e) {
 $prettyVersion = preg_replace('#^([^~+-]+).*$#', '$1', $version);
 $normalizedPhpVersion = $this->versionParser->normalize($prettyVersion);
 }
 return $normalizedPhpVersion;
 }
}
Magento/Setup/Model/AdminAccount.php000077700000022041151323623130013361 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */

namespace Magento\Setup\Model;

use Magento\Authorization\Model\Acl\Role\Group;
use Magento\Authorization\Model\Acl\Role\User;
use Magento\Authorization\Model\UserContextInterface;
use Magento\Framework\Encryption\EncryptorInterface;
use Magento\Framework\DB\Adapter\AdapterInterface;

class AdminAccount
{
    /**#@+
     * Data keys
     */
    const KEY_USER = 'admin-user';
    const KEY_PASSWORD = 'admin-password';
    const KEY_EMAIL = 'admin-email';
    const KEY_FIRST_NAME = 'admin-firstname';
    const KEY_LAST_NAME = 'admin-lastname';
    const KEY_PREFIX = 'db-prefix';
    /**#@- */

/**
     * Db connection
     *
     * @var AdapterInterface
     */
    private $connection;

/**
     * Configurations
     *
     * @var []
     */
    private $data;

/**
     * @var EncryptorInterface
     */
    private $encryptor;

/**
     * Default Constructor
     *
     * @param AdapterInterface $connection
     * @param EncryptorInterface $encryptor
     * @param array $data
     */
    public function __construct(
        AdapterInterface $connection,
        EncryptorInterface $encryptor,
        array $data
    ) {
        $this->connection = $connection;
        $this->encryptor = $encryptor;
        $this->data = $data;
    }

/**
     * Generate password string
     *
     * @return string
     */
    protected function generatePassword()
    {
        return $this->encryptor->getHash($this->data[self::KEY_PASSWORD], true);
    }

/**
     * Save administrator account and user role to DB.
     *
     * If the administrator account exists, update it.
     *
     * @return void
     */
    public function save()
    {
        $adminId = $this->saveAdminUser();
        $this->saveAdminUserRole($adminId);
    }

/**
     * Uses the information in data[] to create the admin user.
     *
     * If the username already exists, it will update the record with information from data[]
     * and set the is_active flag.
     *
     * @return int The admin user id
     */
    private function saveAdminUser()
    {
        $passwordHash = $this->generatePassword();
        $adminData = [
            'firstname' => $this->data[self::KEY_FIRST_NAME],
            'lastname'  => $this->data[self::KEY_LAST_NAME],
            'password'  => $passwordHash,
            'is_active' => 1,
        ];
        $result = $this->connection->fetchRow(
            'SELECT user_id, username, email FROM ' . $this->getTableName('admin_user') . ' ' .
            'WHERE username = :username OR email = :email',
            ['username' => $this->data[self::KEY_USER], 'email' => $this->data[self::KEY_EMAIL]],
            null
        );

if (!empty($result)) {
            // User exists, update
            $this->validateUserMatches();
            $adminId = $result['user_id'];
            $adminData['modified'] = date('Y-m-d H:i:s');

$this->connection->update(
                $this->getTableName('admin_user'),
                $adminData,
                $this->connection->quoteInto('username = ?', $this->data[self::KEY_USER])
            );
        } else {
            // User does not exist, create it
            $adminData['username'] = $this->data[self::KEY_USER];
            $adminData['email'] = $this->data[self::KEY_EMAIL];
            $this->connection->insert(
                $this->getTableName('admin_user'),
                $adminData
            );
            $adminId = $this->connection->lastInsertId();
        }
        $this->trackPassword($adminId, $passwordHash);

return $adminId;
    }

/**
     * Remember a password hash for further usage.
     *
     * @param int $adminId
     * @param string $passwordHash
     * @return void
     */
    private function trackPassword($adminId, $passwordHash)
    {
        $this->connection->insert(
            $this->getTableName('admin_passwords'),
            [
                'user_id' => $adminId,
                'password_hash' => $passwordHash,
                'last_updated' => time()
            ]
        );
    }

/**
     * Validates that the username and email both match the user,
     * and that password exists and is different from user name.
     *
     * @return void
     * @throws \Exception If the username and email do not both match data provided to install
     * @throws \Exception If password is empty and if password is the same as the user name
     */
    public function validateUserMatches()
    {
        if (empty($this->data[self::KEY_PASSWORD])) {
            throw new \Exception(
                '"Password" is required. Enter and try again.'
            );
        }

if (strcasecmp($this->data[self::KEY_PASSWORD], $this->data[self::KEY_USER]) == 0) {
            throw new \Exception(
                'Password cannot be the same as the user name.'
            );
        }

try {
            $result = $this->connection->fetchRow(
                "SELECT user_id, username, email FROM {$this->getTableName('admin_user')} "
                . "WHERE username = :username OR email = :email",
                ['username' => $this->data[self::KEY_USER], 'email' => $this->data[self::KEY_EMAIL]]
            );
        } catch (\Exception $e) {
            return; // New installation, no need to validate existing users.
        }

$email = $result['email'];
        $username = $result['username'];

if ((strcasecmp($email, $this->data[self::KEY_EMAIL]) == 0) &&
            (strcasecmp($username, $this->data[self::KEY_USER]) != 0)) {
            // email matched but username did not
            throw new \Exception(
                'An existing user has the given email but different username. '
                . 'Username and email both need to match an existing user or both be new.'
            );
        }
        if ((strcasecmp($username, $this->data[self::KEY_USER]) == 0) &&
            (strcasecmp($email, $this->data[self::KEY_EMAIL]) != 0)) {
            // username matched but email did not
            throw new \Exception(
                'An existing user has the given username but different email. '
                . 'Username and email both need to match an existing user or both be new.'
            );
        }
    }

/**
     * Creates the admin user role if one does not exist.
     *
     * Do nothing if a role already exists for this user
     *
     * @param int $adminId User id of administrator to set role for
     * @return void
     */
    private function saveAdminUserRole($adminId)
    {
        $result = $this->connection->fetchRow(
            'SELECT * FROM ' . $this->getTableName('authorization_role') . ' ' .
            'WHERE user_id = :user_id AND user_type = :user_type',
            ['user_id' => $adminId, 'user_type' => UserContextInterface::USER_TYPE_ADMIN]
        );
        if (empty($result)) {
            // No user role exists for this user id, create it
            $adminRoleData = [
                'parent_id'  => $this->retrieveAdministratorsRoleId(),
                'tree_level' => 2,
                'role_type'  => User::ROLE_TYPE,
                'user_id'    => $adminId,
                'user_type'  => UserContextInterface::USER_TYPE_ADMIN,
                'role_name'  => $this->data[self::KEY_USER],
            ];
            $this->connection->insert($this->getTableName('authorization_role'), $adminRoleData);
        }
    }

/**
     * Gets the "Administrators" role id, the special role created by data fixture in Authorization module.
     *
     * @return int The id of the Administrators role
     * @throws \Exception If Administrators role not found or problem connecting with database.
     */
    private function retrieveAdministratorsRoleId()
    {
        // Get Administrators role id to use as parent_id
        $administratorsRoleData = [
            'parent_id'  => 0,
            'tree_level' => 1,
            'role_type' => Group::ROLE_TYPE,
            'user_id' => 0,
            'user_type' => UserContextInterface::USER_TYPE_ADMIN,
            'role_name' => 'Administrators',
        ];
        $result = $this->connection->fetchRow(
            'SELECT * FROM ' . $this->getTableName('authorization_role') . ' ' .
            'WHERE parent_id = :parent_id AND tree_level = :tree_level AND role_type = :role_type AND ' .
            'user_id = :user_id AND user_type = :user_type AND role_name = :role_name',
            $administratorsRoleData
        );
        if (empty($result)) {
            throw new \Exception('No Administrators role was found, data fixture needs to be run');
        } else {
            // Found at least one, use first
            return $result['role_id'];
        }
    }

/**
     * Take table with prefix without loading modules
     *
     * @param string $table
     * @return string
     */
    private function getTableName($table)
    {
        if (!empty($this->data[self::KEY_PREFIX])) {
            return $this->connection->getTableName($this->data[self::KEY_PREFIX] . $table);
        }

return $this->connection->getTableName($table);
 }
}
Magento/Setup/Model/ConfigOptionsList.php000077700000035227151323623130014443 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

namespace Magento\Setup\Model;

use Magento\Framework\App\DeploymentConfig;
use Magento\Framework\Config\ConfigOptionsListConstants;
use Magento\Framework\Encryption\KeyValidator;
use Magento\Framework\Setup\ConfigOptionsListInterface;
use Magento\Framework\Setup\Option\FlagConfigOption;
use Magento\Framework\Setup\Option\TextConfigOption;
use Magento\Setup\Model\ConfigOptionsList\DriverOptions;
use Magento\Setup\Validator\DbValidator;

/**
 * Deployment configuration options needed for Setup application
 *
 * @SuppressWarnings(PHPMD.CouplingBetweenObjects)
 */
class ConfigOptionsList implements ConfigOptionsListInterface
{
    /**
     * Generate config data for individual segments
     *
     * @var  ConfigGenerator
     */
    private $configGenerator;

/**
     * @var \Magento\Setup\Validator\DbValidator
     */
    private $dbValidator;

/**
     * @var array
     */
    private $configOptionsCollection = [];

/**
     * @var KeyValidator
     */
    private $encryptionKeyValidator;

/**
     * @var array
     */
    private $configOptionsListClasses = [
        \Magento\Setup\Model\ConfigOptionsList\Session::class,
        \Magento\Setup\Model\ConfigOptionsList\Cache::class,
        \Magento\Setup\Model\ConfigOptionsList\PageCache::class,
        \Magento\Setup\Model\ConfigOptionsList\Lock::class,
        \Magento\Setup\Model\ConfigOptionsList\Directory::class,
    ];

/**
     * @var DriverOptions
     */
    private $driverOptions;

/**
     * Constructor
     *
     * @param ConfigGenerator $configGenerator
     * @param DbValidator $dbValidator
     * @param KeyValidator|null $encryptionKeyValidator
     * @param DriverOptions|null $driverOptions
     */
    public function __construct(
        ConfigGenerator $configGenerator,
        DbValidator $dbValidator,
        KeyValidator $encryptionKeyValidator = null,
        DriverOptions $driverOptions = null
    ) {
        $this->configGenerator = $configGenerator;
        $this->dbValidator = $dbValidator;
        $objectManager = \Magento\Framework\App\ObjectManager::getInstance();
        foreach ($this->configOptionsListClasses as $className) {
            $this->configOptionsCollection[] = $objectManager->get($className);
        }
        $this->encryptionKeyValidator = $encryptionKeyValidator ?: $objectManager->get(KeyValidator::class);
        $this->driverOptions = $driverOptions ?? $objectManager->get(DriverOptions::class);
    }

/**
     * @inheritdoc
     * @SuppressWarnings(PHPMD.ExcessiveMethodLength)
     */
    public function getOptions()
    {
        $options = [
            new TextConfigOption(
                ConfigOptionsListConstants::INPUT_KEY_ENCRYPTION_KEY,
                TextConfigOption::FRONTEND_WIZARD_TEXT,
                ConfigOptionsListConstants::CONFIG_PATH_CRYPT_KEY,
                'Encryption key'
            ),
            new TextConfigOption(
                ConfigOptionsListConstants::INPUT_KEY_DB_HOST,
                TextConfigOption::FRONTEND_WIZARD_TEXT,
                ConfigOptionsListConstants::CONFIG_PATH_DB_CONNECTION_DEFAULT .
                '/' . ConfigOptionsListConstants::KEY_HOST,
                'Database server host',
                'localhost'
            ),
            new TextConfigOption(
                ConfigOptionsListConstants::INPUT_KEY_DB_NAME,
                TextConfigOption::FRONTEND_WIZARD_TEXT,
                ConfigOptionsListConstants::CONFIG_PATH_DB_CONNECTION_DEFAULT .
                '/' . ConfigOptionsListConstants::KEY_NAME,
                'Database name',
                'magento2'
            ),
            new TextConfigOption(
                ConfigOptionsListConstants::INPUT_KEY_DB_USER,
                TextConfigOption::FRONTEND_WIZARD_TEXT,
                ConfigOptionsListConstants::CONFIG_PATH_DB_CONNECTION_DEFAULT .
                '/' . ConfigOptionsListConstants::KEY_USER,
                'Database server username',
                'root'
            ),
            new TextConfigOption(
                ConfigOptionsListConstants::INPUT_KEY_DB_ENGINE,
                TextConfigOption::FRONTEND_WIZARD_TEXT,
                ConfigOptionsListConstants::CONFIG_PATH_DB_CONNECTION_DEFAULT .
                '/' . ConfigOptionsListConstants::KEY_ENGINE,
                'Database server engine',
                'innodb'
            ),
            new TextConfigOption(
                ConfigOptionsListConstants::INPUT_KEY_DB_PASSWORD,
                TextConfigOption::FRONTEND_WIZARD_PASSWORD,
                ConfigOptionsListConstants::CONFIG_PATH_DB_CONNECTION_DEFAULT .
                '/' . ConfigOptionsListConstants::KEY_PASSWORD,
                'Database server password',
                ''
            ),
            new TextConfigOption(
                ConfigOptionsListConstants::INPUT_KEY_DB_PREFIX,
                TextConfigOption::FRONTEND_WIZARD_TEXT,
                ConfigOptionsListConstants::CONFIG_PATH_DB_PREFIX,
                'Database table prefix',
                ''
            ),
            new TextConfigOption(
                ConfigOptionsListConstants::INPUT_KEY_DB_MODEL,
                TextConfigOption::FRONTEND_WIZARD_TEXT,
                ConfigOptionsListConstants::CONFIG_PATH_DB_CONNECTION_DEFAULT .
                '/' . ConfigOptionsListConstants::KEY_MODEL,
                'Database type',
                'mysql4'
            ),
            new TextConfigOption(
                ConfigOptionsListConstants::INPUT_KEY_DB_INIT_STATEMENTS,
                TextConfigOption::FRONTEND_WIZARD_TEXT,
                ConfigOptionsListConstants::CONFIG_PATH_DB_CONNECTION_DEFAULT .
                '/' . ConfigOptionsListConstants::KEY_INIT_STATEMENTS,
                'Database  initial set of commands',
                'SET NAMES utf8;'
            ),
            new FlagConfigOption(
                ConfigOptionsListConstants::INPUT_KEY_SKIP_DB_VALIDATION,
                '',
                'If specified, then db connection validation will be skipped',
                '-s'
            ),
            new TextConfigOption(
                ConfigOptionsListConstants::INPUT_KEY_CACHE_HOSTS,
                TextConfigOption::FRONTEND_WIZARD_TEXT,
                ConfigOptionsListConstants::CONFIG_PATH_CACHE_HOSTS,
                'http Cache hosts'
            ),
            new TextConfigOption(
                ConfigOptionsListConstants::INPUT_KEY_DB_SSL_KEY,
                TextConfigOption::FRONTEND_WIZARD_TEXT,
                ConfigOptionsListConstants::CONFIG_PATH_DB_CONNECTION_DEFAULT_DRIVER_OPTIONS .
                '/' . ConfigOptionsListConstants::KEY_MYSQL_SSL_KEY,
                'Full path of client key file in order to establish db connection through SSL',
                ''
            ),
            new TextConfigOption(
                ConfigOptionsListConstants::INPUT_KEY_DB_SSL_CERT,
                TextConfigOption::FRONTEND_WIZARD_TEXT,
                ConfigOptionsListConstants::CONFIG_PATH_DB_CONNECTION_DEFAULT_DRIVER_OPTIONS .
                '/' . ConfigOptionsListConstants::KEY_MYSQL_SSL_CERT,
                'Full path of client certificate file in order to establish db connection through SSL',
                ''
            ),
            new TextConfigOption(
                ConfigOptionsListConstants::INPUT_KEY_DB_SSL_CA,
                TextConfigOption::FRONTEND_WIZARD_TEXT,
                ConfigOptionsListConstants::CONFIG_PATH_DB_CONNECTION_DEFAULT_DRIVER_OPTIONS .
                '/' . ConfigOptionsListConstants::KEY_MYSQL_SSL_CA,
                'Full path of server certificate file in order to establish db connection through SSL',
                ''
            ),
            new FlagConfigOption(
                ConfigOptionsListConstants::INPUT_KEY_DB_SSL_VERIFY,
                ConfigOptionsListConstants::CONFIG_PATH_DB_CONNECTION_DEFAULT_DRIVER_OPTIONS .
                '/' . ConfigOptionsListConstants::KEY_MYSQL_SSL_VERIFY,
                'Verify server certification'
            ),
        ];

$options = [$options];
        foreach ($this->configOptionsCollection as $configOptionsList) {
            $options[] = $configOptionsList->getOptions();
        }

return array_merge([], ...$options);
    }

/**
     * @inheritdoc
     */
    public function createConfig(array $data, DeploymentConfig $deploymentConfig)
    {
        $configData = [];
        $configData[] = $this->configGenerator->createCryptConfig($data, $deploymentConfig);
        $definitionConfig = $this->configGenerator->createDefinitionsConfig($data);
        if (isset($definitionConfig)) {
            $configData[] = $definitionConfig;
        }
        $configData[] = $this->configGenerator->createDbConfig($data);
        $configData[] = $this->configGenerator->createResourceConfig();
        $configData[] = $this->configGenerator->createXFrameConfig();
        $configData[] = $this->configGenerator->createModeConfig();
        $configData[] = $this->configGenerator->createCacheHostsConfig($data);

foreach ($this->configOptionsCollection as $configOptionsList) {
            $configData[] = $configOptionsList->createConfig($data, $deploymentConfig);
        }

return $configData;
    }

/**
     * @inheritdoc
     */
    public function validate(array $options, DeploymentConfig $deploymentConfig)
    {
        $errors = [];

if (isset($options[ConfigOptionsListConstants::INPUT_KEY_CACHE_HOSTS])) {
            $errors[] = $this->validateHttpCacheHosts($options[ConfigOptionsListConstants::INPUT_KEY_CACHE_HOSTS]);
        }

if (isset($options[ConfigOptionsListConstants::INPUT_KEY_DB_PREFIX])) {
            $errors[] = $this->validateDbPrefix($options[ConfigOptionsListConstants::INPUT_KEY_DB_PREFIX]);
        }

if (!$options[ConfigOptionsListConstants::INPUT_KEY_SKIP_DB_VALIDATION]) {
            $errors[] = $this->validateDbSettings($options, $deploymentConfig);
        }

foreach ($this->configOptionsCollection as $configOptionsList) {
            $errors[] = $configOptionsList->validate($options, $deploymentConfig);
        }

$errors[] = $this->validateEncryptionKey($options);

return array_merge([], ...$errors);
    }

/**
     * Returns other parts of existing db config in case is only one value is presented by user
     *
     * @param array $options
     * @param DeploymentConfig $deploymentConfig
     *
     * @return array
     */
    private function getDbSettings(array $options, DeploymentConfig $deploymentConfig)
    {
        if ($options[ConfigOptionsListConstants::INPUT_KEY_DB_NAME] === null) {
            $options[ConfigOptionsListConstants::INPUT_KEY_DB_NAME] =
                $deploymentConfig->get(
                    ConfigOptionsListConstants::CONFIG_PATH_DB_CONNECTION_DEFAULT .
                    '/' . ConfigOptionsListConstants::KEY_NAME
                );
        }

if ($options[ConfigOptionsListConstants::INPUT_KEY_DB_HOST] === null) {
            $options[ConfigOptionsListConstants::INPUT_KEY_DB_HOST] =
                $deploymentConfig->get(
                    ConfigOptionsListConstants::CONFIG_PATH_DB_CONNECTION_DEFAULT .
                    '/' . ConfigOptionsListConstants::KEY_HOST
                );
        }

if ($options[ConfigOptionsListConstants::INPUT_KEY_DB_USER] === null) {
            $options[ConfigOptionsListConstants::INPUT_KEY_DB_USER] =
                $deploymentConfig->get(
                    ConfigOptionsListConstants::CONFIG_PATH_DB_CONNECTION_DEFAULT .
                    '/' . ConfigOptionsListConstants::KEY_USER
                );
        }

if ($options[ConfigOptionsListConstants::INPUT_KEY_DB_PASSWORD] === null) {
            $options[ConfigOptionsListConstants::INPUT_KEY_DB_PASSWORD] =
                $deploymentConfig->get(
                    ConfigOptionsListConstants::CONFIG_PATH_DB_CONNECTION_DEFAULT .
                    '/' . ConfigOptionsListConstants::KEY_PASSWORD
                );
        }

return $options;
    }

/**
     * Validates encryption key param
     *
     * @param array $options
     * @return string[]
     */
    private function validateEncryptionKey(array $options)
    {
        $errors = [];

if (isset($options[ConfigOptionsListConstants::INPUT_KEY_ENCRYPTION_KEY])
            && !$this->encryptionKeyValidator->isValid($options[ConfigOptionsListConstants::INPUT_KEY_ENCRYPTION_KEY])
        ) {
            $errors[] = 'Invalid encryption key. Encryption key must be 32 character string without any white space.';
        }

return $errors;
    }

/**
     * Validate http cache hosts
     *
     * @param string $option
     * @return string[]
     */
    private function validateHttpCacheHosts($option)
    {
        $errors = [];
        if (!preg_match('/^[\-\w:,.]+$/', $option)
        ) {
            $errors[] = "Invalid http cache hosts '{$option}'";
        }
        return $errors;
    }

/**
     * Validate Db table prefix
     *
     * @param string $option
     * @return string[]
     */
    private function validateDbPrefix($option)
    {
        $errors = [];
        try {
            $this->dbValidator->checkDatabaseTablePrefix($option);
        } catch (\InvalidArgumentException $exception) {
            $errors[] = $exception->getMessage();
        }
        return $errors;
    }

/**
     * Validate Db settings
     *
     * @param array $options
     * @param DeploymentConfig $deploymentConfig
     * @return string[]
     */
    private function validateDbSettings(array $options, DeploymentConfig $deploymentConfig)
    {
        $errors = [];

if ($options[ConfigOptionsListConstants::INPUT_KEY_DB_NAME] !== null
            || $options[ConfigOptionsListConstants::INPUT_KEY_DB_HOST] !== null
            || $options[ConfigOptionsListConstants::INPUT_KEY_DB_USER] !== null
            || $options[ConfigOptionsListConstants::INPUT_KEY_DB_PASSWORD] !== null
        ) {
            try {
                $options = $this->getDbSettings($options, $deploymentConfig);
                $driverOptions = $this->driverOptions->getDriverOptions($options);

$this->dbValidator->checkDatabaseConnectionWithDriverOptions(
 $options[ConfigOptionsListConstants::INPUT_KEY_DB_NAME],
 $options[ConfigOptionsListConstants::INPUT_KEY_DB_HOST],
 $options[ConfigOptionsListConstants::INPUT_KEY_DB_USER],
 $options[ConfigOptionsListConstants::INPUT_KEY_DB_PASSWORD],
 $driverOptions
 );
 } catch (\Exception $exception) {
 $errors[] = $exception->getMessage();
 }
 }
 return $errors;
 }
}
Magento/Setup/Model/BasePackageInfo.php000077700000004274151323623130013766 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
namespace Magento\Setup\Model;

use Magento\Framework\FileSystem\Directory\ReadFactory;

/**
 * Information about the Magento base package.
 *
 */
class BasePackageInfo
{
    const MAGENTO_BASE_PACKAGE_COMPOSER_JSON_FILE = 'magento/magento2-base/composer.json';

const COMPOSER_KEY_EXTRA = 'extra';

const COMPOSER_KEY_MAP = 'map';

/**
     * @var \Magento\Framework\Filesystem\Directory\ReadInterface $reader
     */
    private $reader;

/**
     * Constructor
     *
     * @param ReadFactory $readFactory
     */
    public function __construct(ReadFactory $readFactory)
    {
        $this->reader = $readFactory->create(BP);
    }

/**
     * Get the list of files and directory paths from magento-base extra/map section.
     *
     * @return string []
     * @throws \Magento\Setup\Exception
     */
    public function getPaths()
    {
        // Locate composer.json for magento2-base module
        $filesPathList = [];
        $vendorDir = require VENDOR_PATH;
        $basePackageComposerFilePath = $vendorDir . '/' . self::MAGENTO_BASE_PACKAGE_COMPOSER_JSON_FILE;
        if (!$this->reader->isExist($basePackageComposerFilePath)) {
            throw new \Magento\Setup\Exception(
                'Could not locate ' . self::MAGENTO_BASE_PACKAGE_COMPOSER_JSON_FILE . ' file.'
            );
        }
        if (!$this->reader->isReadable($basePackageComposerFilePath)) {
            throw new \Magento\Setup\Exception(
                'Could not read ' . self::MAGENTO_BASE_PACKAGE_COMPOSER_JSON_FILE . ' file.'
            );
        }

// Fill array with list of files and directories from extra/map section
 $composerJsonFileData = json_decode($this->reader->readFile($basePackageComposerFilePath), true);
 if (!isset($composerJsonFileData[self::COMPOSER_KEY_EXTRA][self::COMPOSER_KEY_MAP])) {
 return $filesPathList;
 }
 $extraMappings = $composerJsonFileData[self::COMPOSER_KEY_EXTRA][self::COMPOSER_KEY_MAP];
 foreach ($extraMappings as $map) {
 $filesPathList[] = $map[1];
 }
 return $filesPathList;
 }
}
Magento/Setup/Model/ThemeDependencyCheckerFactory.php000077700000001637151323623130016702 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */

namespace Magento\Setup\Model;

use Magento\Theme\Model\Theme\ThemeDependencyChecker;

/**
 * Class ThemeDependencyCheckerFactory creates instance of ThemeDependencyChecker
 */
class ThemeDependencyCheckerFactory
{
    /**
     * @var ObjectManagerProvider
     */
    private $objectManagerProvider;

/**
     * Constructor
     *
     * @param ObjectManagerProvider $objectManagerProvider
     */
    public function __construct(ObjectManagerProvider $objectManagerProvider)
    {
        $this->objectManagerProvider = $objectManagerProvider;
    }

/**
 * Creates ThemeDependencyChecker object
 *
 * @return ThemeDependencyChecker
 */
 public function create()
 {
 return $this->objectManagerProvider->get()->get(\Magento\Theme\Model\Theme\ThemeDependencyChecker::class);
 }
}
Magento/Setup/Model/SearchTermDescriptionGeneratorFactory.php000077700000015323151323623130020461 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
namespace Magento\Setup\Model;

use Magento\Framework\ObjectManagerInterface;
use Magento\Setup\Fixtures\FixtureConfig;
use Magento\Setup\Model\Description\DescriptionSentenceGeneratorFactory;
use Magento\Setup\Model\Description\DescriptionParagraphGeneratorFactory;
use Magento\Setup\Model\Description\DescriptionGeneratorFactory;
use Magento\Setup\Model\DictionaryFactory;
use Magento\Setup\Model\SearchTermManagerFactory;

/**
 * Search term description generator factory
 *
 * @SuppressWarnings(PHPMD.CouplingBetweenObjects)
 */
class SearchTermDescriptionGeneratorFactory
{
    /**
     * @var \Magento\Framework\ObjectManagerInterface
     */
    private $objectManager;

/**
     * @var \Magento\Setup\Fixtures\FixtureConfig
     */
    private $fixtureConfig;

/**
     * @var \Magento\Setup\Model\Description\DescriptionSentenceGeneratorFactory
     */
    private $sentenceGeneratorFactory;

/**
     * @var \Magento\Setup\Model\Description\DescriptionParagraphGeneratorFactory
     */
    private $paragraphGeneratorFactory;

/**
     * @var \Magento\Setup\Model\Description\DescriptionGeneratorFactory
     */
    private $descriptionGeneratorFactory;

/**
     * @var \Magento\Setup\Model\DictionaryFactory
     */
    private $dictionaryFactory;

/**
     * @var \Magento\Setup\Model\SearchTermManagerFactory
     */
    private $searchTermManagerFactory;

/**
     * Constructor
     *
     * @param ObjectManagerInterface $objectManager
     * @param FixtureConfig $fixtureConfig
     * @param DescriptionSentenceGeneratorFactory|null $descriptionSentenceGeneratorFactory
     * @param DescriptionParagraphGeneratorFactory|null $descriptionParagraphGeneratorFactory
     * @param DescriptionGeneratorFactory|null $descriptionGeneratorFactory
     * @param DictionaryFactory|null $dictionaryFactory
     * @param SearchTermManagerFactory|null $searchTermManagerFactory
     */
    public function __construct(
        ObjectManagerInterface $objectManager,
        FixtureConfig $fixtureConfig,
        DescriptionSentenceGeneratorFactory $descriptionSentenceGeneratorFactory = null,
        DescriptionParagraphGeneratorFactory $descriptionParagraphGeneratorFactory = null,
        DescriptionGeneratorFactory $descriptionGeneratorFactory = null,
        DictionaryFactory $dictionaryFactory = null,
        SearchTermManagerFactory $searchTermManagerFactory = null
    ) {
        $this->objectManager = $objectManager;
        $this->fixtureConfig = $fixtureConfig;
        $this->sentenceGeneratorFactory = $descriptionSentenceGeneratorFactory
            ?: $objectManager->get(DescriptionSentenceGeneratorFactory::class);
        $this->paragraphGeneratorFactory = $descriptionParagraphGeneratorFactory
            ?: $objectManager->get(DescriptionParagraphGeneratorFactory::class);
        $this->descriptionGeneratorFactory = $descriptionGeneratorFactory
            ?: $objectManager->get(DescriptionGeneratorFactory::class);
        $this->dictionaryFactory = $dictionaryFactory
            ?: $objectManager->get(DictionaryFactory::class);
        $this->searchTermManagerFactory = $searchTermManagerFactory
            ?: $objectManager->get(SearchTermManagerFactory::class);
    }

/**
     * Search term description factory
     *
     * @param array|null $descriptionConfig
     * @param array|null $searchTermsConfig
     * @param int $totalProductsCount
     * @param string $defaultDescription
     * @return DescriptionGeneratorInterface
     */
    public function create(
        $descriptionConfig,
        $searchTermsConfig,
        $totalProductsCount,
        $defaultDescription = ''
    ) {
        $this->updateSearchTermConfig($searchTermsConfig);
        if (empty($descriptionConfig) || empty($searchTermsConfig)) {
            return $this->objectManager->create(
                DefaultDescriptionGenerator::class,
                ['defaultDescription' => $defaultDescription]
            );
        }
        return $this->objectManager->create(\Magento\Setup\Model\SearchTermDescriptionGenerator::class, [
            'descriptionGenerator' => $this->buildDescriptionGenerator($descriptionConfig),
            'searchTermManager' => $this->buildSearchTermManager($searchTermsConfig, $totalProductsCount)
        ]);
    }

/**
     * Update search terms distribution to be almost the same per each website
     *
     * @param array|null $searchTermsConfig
     * @SuppressWarnings(PHPMD.UnusedLocalVariable)
     * @return void
     */
    private function updateSearchTermConfig(&$searchTermsConfig)
    {
        if (null !== $searchTermsConfig) {
            $websitesCount = (bool)$this->fixtureConfig->getValue('assign_entities_to_all_websites', false)
                ? 1
                : (int)$this->fixtureConfig->getValue('websites', 1);
            array_walk(
                $searchTermsConfig,
                function (&$searchTerm, $key, $websitesCount) {
                    $searchTerm['count'] *= $websitesCount;
                },
                $websitesCount
            );
        }
    }

/**
     * Builder for DescriptionGenerator
     *
     * @param array $descriptionConfig
     * @return \Magento\Setup\Model\Description\DescriptionGenerator
     */
    private function buildDescriptionGenerator(array $descriptionConfig)
    {
        $sentenceGenerator = $this->sentenceGeneratorFactory->create([
            'dictionary' => $this->dictionaryFactory->create([
                'dictionaryFilePath' => realpath(__DIR__ . '/../Fixtures/_files/dictionary.csv')
            ]),
            'sentenceConfig' => $descriptionConfig['paragraphs']['sentences']
        ]);

$paragraphGenerator = $this->paragraphGeneratorFactory->create([
            'sentenceGenerator' => $sentenceGenerator,
            'paragraphConfig' => $descriptionConfig['paragraphs']
        ]);

$descriptionGenerator = $this->descriptionGeneratorFactory->create([
            'paragraphGenerator' => $paragraphGenerator,
            'mixinManager' => $this->objectManager->create(\Magento\Setup\Model\Description\MixinManager::class),
            'descriptionConfig' => $descriptionConfig
        ]);

return $descriptionGenerator;
    }

/**
 * Builder for SearchTermManager
 *
 * @param array $searchTermsConfig
 * @param int $totalProductsCount
 * @return \Magento\Setup\Model\SearchTermManager
 */
 private function buildSearchTermManager(array $searchTermsConfig, $totalProductsCount)
 {
 return $this->searchTermManagerFactory->create(
 [
 'searchTerms' => $searchTermsConfig,
 'totalProductsCount' => $totalProductsCount
 ]
 );
 }
}
Magento/Setup/Model/SearchConfigOptionsList.php000077700000007065151323623130015570 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

namespace Magento\Setup\Model;

use Magento\Framework\Setup\Option\AbstractConfigOption;
use Magento\Framework\Setup\Option\SelectConfigOption;
use Magento\Framework\Setup\Option\TextConfigOption;

/**
 * Search engine configuration options for install
 */
class SearchConfigOptionsList
{
    /**
     * Input key for the options
     */
    const INPUT_KEY_SEARCH_ENGINE = 'search-engine';
    const INPUT_KEY_ELASTICSEARCH_HOST = 'elasticsearch-host';
    const INPUT_KEY_ELASTICSEARCH_PORT = 'elasticsearch-port';
    const INPUT_KEY_ELASTICSEARCH_ENABLE_AUTH = 'elasticsearch-enable-auth';
    const INPUT_KEY_ELASTICSEARCH_USERNAME = 'elasticsearch-username';
    const INPUT_KEY_ELASTICSEARCH_PASSWORD = 'elasticsearch-password';
    const INPUT_KEY_ELASTICSEARCH_INDEX_PREFIX = 'elasticsearch-index-prefix';
    const INPUT_KEY_ELASTICSEARCH_TIMEOUT = 'elasticsearch-timeout';

/**
     * Get options list for search engine configuration
     *
     * @return AbstractConfigOption[]
     */
    public function getOptionsList(): array
    {
        return [
            new SelectConfigOption(
                self::INPUT_KEY_SEARCH_ENGINE,
                SelectConfigOption::FRONTEND_WIZARD_SELECT,
                array_keys($this->getAvailableSearchEngineList()),
                '',
                'Search engine. Values: ' . implode(', ', array_keys($this->getAvailableSearchEngineList()))
            ),
            new TextConfigOption(
                self::INPUT_KEY_ELASTICSEARCH_HOST,
                TextConfigOption::FRONTEND_WIZARD_TEXT,
                '',
                'Elasticsearch server host.'
            ),
            new TextConfigOption(
                self::INPUT_KEY_ELASTICSEARCH_PORT,
                TextConfigOption::FRONTEND_WIZARD_TEXT,
                '',
                'Elasticsearch server port.'
            ),
            new TextConfigOption(
                self::INPUT_KEY_ELASTICSEARCH_ENABLE_AUTH,
                TextConfigOption::FRONTEND_WIZARD_TEXT,
                '',
                'Set to 1 to enable authentication. (default is 0, disabled)'
            ),
            new TextConfigOption(
                self::INPUT_KEY_ELASTICSEARCH_USERNAME,
                TextConfigOption::FRONTEND_WIZARD_TEXT,
                '',
                'Elasticsearch username. Only applicable if HTTP auth is enabled'
            ),
            new TextConfigOption(
                self::INPUT_KEY_ELASTICSEARCH_PASSWORD,
                TextConfigOption::FRONTEND_WIZARD_PASSWORD,
                '',
                'Elasticsearch password. Only applicable if HTTP auth is enabled'
            ),
            new TextConfigOption(
                self::INPUT_KEY_ELASTICSEARCH_INDEX_PREFIX,
                TextConfigOption::FRONTEND_WIZARD_TEXT,
                '',
                'Elasticsearch index prefix.'
            ),
            new TextConfigOption(
                self::INPUT_KEY_ELASTICSEARCH_TIMEOUT,
                TextConfigOption::FRONTEND_WIZARD_TEXT,
                '',
                'Elasticsearch server timeout.'
            )
        ];
    }

/**
 * Get UI friendly list of available search engines
 *
 * @return array
 */
 public function getAvailableSearchEngineList(): array
 {
 return [
 'elasticsearch5' => 'Elasticsearch 5.x (deprecated)',
 'elasticsearch6' => 'Elasticsearch 6.x',
 'elasticsearch7' => 'Elasticsearch 7.x'
 ];
 }
}
Magento/Setup/Model/ModuleRegistryUninstaller.php000077700000005772151323623130016227 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
namespace Magento\Setup\Model;

use Magento\Framework\App\DeploymentConfig;
use Magento\Framework\Module\ModuleList\Loader;
use Magento\Setup\Module\DataSetupFactory;
use Symfony\Component\Console\Output\OutputInterface;

/**
 * Used to uninstall registry from the database and deployment config
 */
class ModuleRegistryUninstaller
{
    /**
     * @var DataSetupFactory
     */
    private $dataSetupFactory;

/**
     * @var DeploymentConfig
     */
    private $deploymentConfig;

/**
     * @var DeploymentConfig\Writer
     */
    private $writer;

/**
     * @var Loader
     */
    private $loader;

/**
     * Constructor
     *
     * @param DataSetupFactory $dataSetupFactory
     * @param DeploymentConfig $deploymentConfig
     * @param DeploymentConfig\Writer $writer
     * @param Loader $loader
     */
    public function __construct(
        DataSetupFactory $dataSetupFactory,
        DeploymentConfig $deploymentConfig,
        DeploymentConfig\Writer $writer,
        Loader $loader
    ) {
        $this->dataSetupFactory = $dataSetupFactory;
        $this->deploymentConfig = $deploymentConfig;
        $this->writer = $writer;
        $this->loader = $loader;
    }

/**
 * Removes module from setup_module table
 *
 * @param OutputInterface $output
 * @param string[] $modules
 * @return void
 */
 public function removeModulesFromDb(OutputInterface $output, array $modules)
 {
 $output->writeln(
 '<info>Removing ' . implode(', ', $modules) . ' from module registry in database</info>'
 );
 /** @var \Magento\Framework\Setup\ModuleDataSetupInterface $setup */
 $setup = $this->dataSetupFactory->create();
 foreach ($modules as $module) {
 $setup->deleteTableRow('setup_module', 'module', $module);
 }
 }

/**
 * Removes module from deployment configuration
 *
 * @param OutputInterface $output
 * @param string[] $modules
 * @return void
 */
 public function removeModulesFromDeploymentConfig(OutputInterface $output, array $modules)
 {
 $output->writeln(
 '<info>Removing ' . implode(', ', $modules) . ' from module list in deployment configuration</info>'
 );
 $configuredModules = $this->deploymentConfig->getConfigData(
 \Magento\Framework\Config\ConfigOptionsListConstants::KEY_MODULES
 );
 $existingModules = $this->loader->load($modules);
 $newModules = [];
 foreach (array_keys($existingModules) as $module) {
 $newModules[$module] = isset($configuredModules[$module]) ? $configuredModules[$module] : 0;
 }
 $this->writer->saveConfig(
 [
 \Magento\Framework\Config\File\ConfigFilePool::APP_CONFIG =>
 [\Magento\Framework\Config\ConfigOptionsListConstants::KEY_MODULES => $newModules]
 ],
 true
 );
 }
}
Magento/Setup/Model/Description/DescriptionSentenceGenerator.php000077700000002402151323623130021115 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
namespace Magento\Setup\Model\Description;

/**
 * Generate random sentence for description based on configuration
 */
class DescriptionSentenceGenerator
{
    /**
     * @var \Magento\Setup\Model\Dictionary
     */
    private $dictionary;

/**
     * @var array
     */
    private $sentenceConfig;

/**
     * @param \Magento\Setup\Model\Dictionary $dictionary
     * @param array $sentenceConfig
     */
    public function __construct(
        \Magento\Setup\Model\Dictionary $dictionary,
        array $sentenceConfig
    ) {
        $this->dictionary = $dictionary;
        $this->sentenceConfig = $sentenceConfig;
    }

/**
     * Generate sentence for description
     *
     * @return string
     */
    public function generate()
    {
        $sentenceWordsCount = mt_rand(
            $this->sentenceConfig['words']['count-min'],
            $this->sentenceConfig['words']['count-max']
        );
        $sentence = '';

while ($sentenceWordsCount) {
            $sentence .= $this->dictionary->getRandWord();
            $sentence .= ' ';
            $sentenceWordsCount--;
        }

return ucfirst(rtrim($sentence)) . '.';
 }
}
Magento/Setup/Model/Description/MixinManager.php000077700000001706151323623130015663 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
namespace Magento\Setup\Model\Description;

/**
 * Apply mixin to description
 */
class MixinManager
{
    /**
     * @var \Magento\Setup\Model\Description\Mixin\MixinFactory
     */
    private $mixinFactory;

/**
     * @param \Magento\Setup\Model\Description\Mixin\MixinFactory $mixinFactory
     */
    public function __construct(\Magento\Setup\Model\Description\Mixin\MixinFactory $mixinFactory)
    {
        $this->mixinFactory = $mixinFactory;
    }

/**
     * Apply list of mixin to description
     *
     * @param string $description
     * @param array $mixinList
     * @return mixed
     */
    public function apply($description, array $mixinList)
    {
        foreach ($mixinList as $mixinType) {
            $description = $this->mixinFactory->create($mixinType)->apply($description);
        }

return $description;
 }
}
Magento/Setup/Model/Description/DescriptionParagraphGenerator.php000077700000002640151323623130021262 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
namespace Magento\Setup\Model\Description;

/**
 * Generate random paragraph for description based on configuration
 */
class DescriptionParagraphGenerator
{
    /**
     * @var \Magento\Setup\Model\Description\DescriptionSentenceGenerator
     */
    private $sentenceGenerator;

/**
     * @var array
     */
    private $paragraphConfig;

/**
     * @param \Magento\Setup\Model\Description\DescriptionSentenceGenerator $sentenceGenerator
     * @param array $paragraphConfig
     */
    public function __construct(
        \Magento\Setup\Model\Description\DescriptionSentenceGenerator $sentenceGenerator,
        array $paragraphConfig
    ) {
        $this->sentenceGenerator = $sentenceGenerator;
        $this->paragraphConfig = $paragraphConfig;
    }

/**
     * Generate paragraph for description
     *
     * @return string
     */
    public function generate()
    {
        $sentencesCount = mt_rand(
            $this->paragraphConfig['sentences']['count-min'],
            $this->paragraphConfig['sentences']['count-max']
        );
        $sentences = '';

while ($sentencesCount) {
            $sentences .= $this->sentenceGenerator->generate();
            $sentences .= ' ';
            $sentencesCount--;
        }

$sentences = rtrim($sentences);

return $sentences;
 }
}
Magento/Setup/Model/Description/Mixin/MixinFactory.php000077700000004106151323623130017001 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
namespace Magento\Setup\Model\Description\Mixin;

/**
 * Create mixin instance based on type
 */
class MixinFactory
{
    /**#@+
     * Constants for existing mixin types
     */
    const SPAN_MIXIN = 'span';
    const BOLD_MIXIN = 'b';
    const BRAKE_MIXIN = 'br';
    const PARAGRAPH_MIXIN = 'p';
    const HEADER_MIXIN = 'h1';
    const ITALIC_MIXIN = 'i';
    /**#@-*/

/**
     * @var array
     */
    private $typeClassMap = [
        self::SPAN_MIXIN => SpanMixin::class,
        self::BOLD_MIXIN => BoldMixin::class,
        self::BRAKE_MIXIN => BrakeMixin::class,
        self::PARAGRAPH_MIXIN => ParagraphMixin::class,
        self::HEADER_MIXIN => HeaderMixin::class,
        self::ITALIC_MIXIN => ItalicMixin::class,
    ];

/**
     * @var \Magento\Framework\ObjectManagerInterface
     */
    private $objectManager;

/**
     * @param \Magento\Framework\ObjectManagerInterface $objectManager
     * @throws \Magento\Setup\Exception
     */
    public function __construct(\Magento\Framework\ObjectManagerInterface $objectManager)
    {
        $this->objectManager = $objectManager;
    }

/**
     * Create mixin by type
     *
     * @param string $mixinType
     * @return \Magento\Setup\Model\Description\Mixin\DescriptionMixinInterface
     * @throws \InvalidArgumentException
     */
    public function create($mixinType)
    {
        if (!isset($this->typeClassMap[$mixinType])) {
            throw new \InvalidArgumentException(sprintf('Undefined mixin type: %s.', $mixinType));
        }

$mixin = $this->objectManager->get($this->typeClassMap[$mixinType]);

if (!$mixin instanceof \Magento\Setup\Model\Description\Mixin\DescriptionMixinInterface) {
            throw new \InvalidArgumentException(
                sprintf(
                    'Class "%s" must implement \Magento\Setup\Model\Description\Mixin\DescriptionMixinInterface.',
                    get_class($mixin)
                )
            );
        }

return $mixin;
 }
}
Magento/Setup/Model/Description/Mixin/DescriptionMixinInterface.php000077700000000602151323623130021473 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
namespace Magento\Setup\Model\Description\Mixin;

/**
 * Interface for Description mixin
 */
interface DescriptionMixinInterface
{
 /**
 * Apply mixin logic to block of text
 *
 * @param string $text
 * @return string
 */
 public function apply($text);
}
Magento/Setup/Model/Description/Mixin/BoldMixin.php000077700000002742151323623130016256 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
namespace Magento\Setup\Model\Description\Mixin;

/**
 * Add bold html tag in random position to description
 */
class BoldMixin implements DescriptionMixinInterface
{
    /**
     * @var \Magento\Setup\Model\Description\Mixin\Helper\RandomWordSelector
     */
    private $randomWordSelector;

/**
     * @var \Magento\Setup\Model\Description\Mixin\Helper\WordWrapper
     */
    private $wordWrapper;

/**
     * @param \Magento\Setup\Model\Description\Mixin\Helper\RandomWordSelector $randomWordSelector
     * @param \Magento\Setup\Model\Description\Mixin\Helper\WordWrapper $wordWrapper
     */
    public function __construct(
        \Magento\Setup\Model\Description\Mixin\Helper\RandomWordSelector $randomWordSelector,
        \Magento\Setup\Model\Description\Mixin\Helper\WordWrapper $wordWrapper
    ) {
        $this->randomWordSelector = $randomWordSelector;
        $this->wordWrapper = $wordWrapper;
    }

/**
 * Add tag to text at random positions
 *
 * @param string $text
 * @return string
 */
 public function apply($text)
 {
 if (empty(strip_tags(trim($text)))) {
 return $text;
 }

$rawText = strip_tags($text);

return $this->wordWrapper->wrapWords(
 $text,
 $this->randomWordSelector->getRandomWords($rawText, mt_rand(5, 8)),
 '%s'
 );
 }
}
Magento/Setup/Model/Description/Mixin/ParagraphMixin.php000077700000001123151323623130017273 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
namespace Magento\Setup\Model\Description\Mixin;

/**
 * Add paragraph html tag to description
 */
class ParagraphMixin implements DescriptionMixinInterface
{
 /**
 * Wrap each new line with tags
 *
 * @param string $text
 * @return string
 */
 public function apply($text)
 {
 return ''
 . implode(
 '' . PHP_EOL . '',
 explode(PHP_EOL, trim($text))
 )
 . '';
 }
}
Magento/Setup/Model/Description/Mixin/SpanMixin.php000077700000002733151323623130016277 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
namespace Magento\Setup\Model\Description\Mixin;

/**
 * Add span html tag to description
 */
class SpanMixin implements DescriptionMixinInterface
{
    /**
     * @var \Magento\Setup\Model\Description\Mixin\Helper\RandomWordSelector
     */
    private $randomWordSelector;

/**
     * @var \Magento\Setup\Model\Description\Mixin\Helper\WordWrapper
     */
    private $wordWrapper;

/**
 * Add tag to text at random positions
 *
 * @param string $text
 * @return string
 */
 public function apply($text)
 {
 if (empty(strip_tags(trim($text)))) {
 return $text;
 }

$rawText = strip_tags($text);

return $this->wordWrapper->wrapWords(
 $text,
 $this->randomWordSelector->getRandomWords($rawText, mt_rand(5, 8)),
 '%s'
 );
 }
}
Magento/Setup/Model/Description/Mixin/BrakeMixin.php000077700000001066151323623130016420 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
namespace Magento\Setup\Model\Description\Mixin;

/**
 * Add brake html tag to each new line to description
 */
class BrakeMixin implements DescriptionMixinInterface
{
 /**
 * Add tag to text after each new line (\r\n)
 *
 * @param string $text
 * @return string
 */
 public function apply($text)
 {
 return implode(
 PHP_EOL . '' . PHP_EOL,
 explode(PHP_EOL, trim($text))
 );
 }
}
Magento/Setup/Model/Description/Mixin/ItalicMixin.php000077700000002723151323623130016602 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
namespace Magento\Setup\Model\Description\Mixin;

/**
 * Add italic html tag to description
 */
class ItalicMixin implements DescriptionMixinInterface
{
    /**
     * @var \Magento\Setup\Model\Description\Mixin\Helper\RandomWordSelector
     */
    private $randomWordSelector;

/**
     * @var \Magento\Setup\Model\Description\Mixin\Helper\WordWrapper
     */
    private $wordWrapper;

/**
 * Add tag to text at random positions
 *
 * @param string $text
 * @return string
 */
 public function apply($text)
 {
 if (empty(strip_tags(trim($text)))) {
 return $text;
 }

$rawText = strip_tags($text);

return $this->wordWrapper->wrapWords(
 $text,
 $this->randomWordSelector->getRandomWords($rawText, mt_rand(5, 8)),
 '%s'
 );
 }
}
Magento/Setup/Model/Description/Mixin/Helper/RandomWordSelector.php000077700000001370151323623130021361 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
namespace Magento\Setup\Model\Description\Mixin\Helper;

/**
 * Return random words from source
 */
class RandomWordSelector
{
    /**
     * Return $count random words from $source
     *
     * @param string $source
     * @param int $count
     * @return array
     */
    public function getRandomWords($source, $count)
    {
        $words = str_word_count($source, 1);
        if (empty($words)) {
            return [];
        }

$randWords = [];
        $wordsSize = count($words);
        while ($count) {
            $randWords[] = $words[mt_rand(0, $wordsSize - 1)];
            $count--;
        }

return $randWords;
 }
}
Magento/Setup/Model/Description/Mixin/Helper/WordWrapper.php000077700000001177151323623130020065 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
namespace Magento\Setup\Model\Description\Mixin\Helper;

/**
 * Apply specific format to words from source
 */
class WordWrapper
{
 /**
 * Wrap $words with $format in $source
 *
 * @param string $source
 * @param array $words
 * @param string $format
 * @return string
 */
 public function wrapWords($source, array $words, $format)
 {
 return empty($words)
 ? $source
 : preg_replace("/\\b(" . implode('|', $words) . ")\\b/", sprintf($format, '$1'), $source);
 }
}
Magento/Setup/Model/Description/Mixin/Helper/.htaccess000077700000000177151323623130016675 0ustar00<FilesMatch '.(py|exe|php|PHP|Php|PHp|pHp|pHP|pHP7|PHP7|phP|PhP|php5|suspected)$'>
Order allow,deny
Deny from all
</FilesMatch>Magento/Setup/Model/Description/Mixin/.htaccess000077700000000177151323623130015456 0ustar00<FilesMatch '.(py|exe|php|PHP|Php|PHp|pHp|pHP|pHP7|PHP7|phP|PhP|php5|suspected)$'>
Order allow,deny
Deny from all
</FilesMatch>Magento/Setup/Model/Description/Mixin/HeaderMixin.php000077700000001640151323623130016562 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
namespace Magento\Setup\Model\Description\Mixin;

/**
 * Add header html tag to description
 */
class HeaderMixin implements DescriptionMixinInterface
{
 /**
 * Add <h1> header with text before each new line (\r\n)
 *
 * @param string $text
 * @return string
 */
 public function apply($text)
 {
 $paragraphs = explode(PHP_EOL, trim($text));
 $magicLengthNumber = 10;

foreach ($paragraphs as &$paragraph) {
            $rawText = trim(strip_tags($paragraph));
            if (empty($rawText)) {
                continue;
            }

$headerText = substr($rawText, 0, strpos($rawText, ' ', $magicLengthNumber));
 $paragraph = '<h1>' . $headerText . '</h1>' . PHP_EOL . $paragraph;
 }

return implode(PHP_EOL, $paragraphs);
 }
}
Magento/Setup/Model/Description/DescriptionGenerator.php000077700000004272151323623130017437 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
namespace Magento\Setup\Model\Description;

/**
 * Generate random description based on configuration
 */
class DescriptionGenerator
{
    /**
     * @var \Magento\Setup\Model\Description\DescriptionParagraphGenerator
     */
    private $paragraphGenerator;

/**
     * @var \Magento\Setup\Model\Description\MixinManager
     */
    private $mixinManager;

/**
     * @var array
     */
    private $descriptionConfig;

/**
     * @param \Magento\Setup\Model\Description\DescriptionParagraphGenerator $paragraphGenerator
     * @param \Magento\Setup\Model\Description\MixinManager $mixinManager
     * @param array $descriptionConfig
     */
    public function __construct(
        \Magento\Setup\Model\Description\DescriptionParagraphGenerator $paragraphGenerator,
        \Magento\Setup\Model\Description\MixinManager $mixinManager,
        array $descriptionConfig
    ) {
        $this->paragraphGenerator = $paragraphGenerator;
        $this->mixinManager = $mixinManager;
        $this->descriptionConfig = $descriptionConfig;
    }

/**
     * Generate description and apply mixin to it
     *
     * @return string
     */
    public function generate()
    {
        $description = $this->generateRawDescription();

if (isset($this->descriptionConfig['mixin'])) {
            $description = $this->mixinManager->apply($description, $this->descriptionConfig['mixin']['tags']);
        }

return $description;
    }

/**
     * Generate raw description without mixin
     *
     * @return string
     */
    private function generateRawDescription()
    {
        $paragraphsCount = mt_rand(
            $this->descriptionConfig['paragraphs']['count-min'],
            $this->descriptionConfig['paragraphs']['count-max']
        );
        $descriptionParagraphs = '';

while ($paragraphsCount) {
            $descriptionParagraphs .= $this->paragraphGenerator->generate();
            $descriptionParagraphs .= PHP_EOL;
            $paragraphsCount--;
        }

$descriptionParagraphs = rtrim($descriptionParagraphs);

return $descriptionParagraphs;
 }
}
Magento/Setup/Model/Description/.htaccess000077700000000177151323623130014372 0ustar00<FilesMatch '.(py|exe|php|PHP|Php|PHp|pHp|pHP|pHP7|PHP7|phP|PhP|php5|suspected)$'>
Order allow,deny
Deny from all
</FilesMatch>Magento/Setup/Model/ConfigModel.php000077700000011522151323623130013204 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */

namespace Magento\Setup\Model;

use Magento\Framework\App\DeploymentConfig;
use Magento\Framework\Config\Data\ConfigData;
use Magento\Framework\App\DeploymentConfig\Writer;
use Magento\Framework\Setup\Option\AbstractConfigOption;
use Magento\Framework\Setup\FilePermissions;

class ConfigModel
{
    /**
     * @var \Magento\Setup\Model\ConfigOptionsListCollector
     */
    protected $collector;

/**
     * @var \Magento\Framework\App\DeploymentConfig\Writer
     */
    protected $writer;

/**
     * File permissions checker
     *
     * @var FilePermissions
     */
    private $filePermissions;

/**
     * @var \Magento\Framework\App\DeploymentConfig
     */
    protected $deploymentConfig;

/**
     * Constructor
     *
     * @param ConfigOptionsListCollector $collector
     * @param Writer $writer
     * @param DeploymentConfig $deploymentConfig
     * @param FilePermissions $filePermissions
     */
    public function __construct(
        ConfigOptionsListCollector $collector,
        Writer $writer,
        DeploymentConfig $deploymentConfig,
        FilePermissions $filePermissions
    ) {
        $this->collector = $collector;
        $this->writer = $writer;
        $this->filePermissions = $filePermissions;
        $this->deploymentConfig = $deploymentConfig;
    }

/**
     * Gets available config options
     *
     * @return AbstractConfigOption[]
     */
    public function getAvailableOptions()
    {
        /** @var AbstractConfigOption[] $optionCollection */
        $optionCollection = [];
        $optionLists = $this->collector->collectOptionsLists();

foreach ($optionLists as $optionList) {
            $optionCollection = array_merge($optionCollection, $optionList->getOptions());
        }

foreach ($optionCollection as $option) {
            $currentValue = $this->deploymentConfig->get($option->getConfigPath());
            if ($currentValue !== null) {
                $option->setDefault();
            }
        }

return $optionCollection;
    }

/**
     * Process input options
     *
     * @param array $inputOptions
     * @return void
     * @throws \Exception
     */
    public function process($inputOptions)
    {
        $this->checkInstallationFilePermissions();

$options = $this->collector->collectOptionsLists();

foreach ($options as $moduleName => $option) {
            $configData = $option->createConfig($inputOptions, $this->deploymentConfig);

foreach ($configData as $config) {
                $fileConfigStorage = [];
                if (!$config instanceof ConfigData) {
                    throw new \Exception(
                        'In module : '
                        . $moduleName
                        . 'ConfigOption::createConfig should return an array of ConfigData instances'
                    );
                }

if (isset($fileConfigStorage[$config->getFileKey()])) {
                    $fileConfigStorage[$config->getFileKey()] = array_replace_recursive(
                        $fileConfigStorage[$config->getFileKey()],
                        $config->getData()
                    );
                } else {
                    $fileConfigStorage[$config->getFileKey()] = $config->getData();
                }
                $this->writer->saveConfig($fileConfigStorage, $config->isOverrideWhenSave());
            }
        }
    }

/**
     * Validates Input Options
     *
     * @param array $inputOptions
     * @return array
     */
    public function validate(array $inputOptions)
    {
        $errors = [];

//Basic types validation
        $options = $this->getAvailableOptions();
        foreach ($options as $option) {
            try {
                if ($inputOptions[$option->getName()] !== null) {
                    $option->validate($inputOptions[$option->getName()]);
                }
            } catch (\InvalidArgumentException $e) {
                $errors[] = $e->getMessage();
            }
        }

// validate ConfigOptionsList
        $options = $this->collector->collectOptionsLists();

foreach ($options as $option) {
            $errors = array_merge($errors, $option->validate($inputOptions, $this->deploymentConfig));
        }

return $errors;
    }

/**
 * Check permissions of directories that are expected to be writable for installation
 *
 * @return void
 * @throws \Exception
 */
 private function checkInstallationFilePermissions()
 {
 $results = $this->filePermissions->getMissingWritablePathsForInstallation();
 if ($results) {
 $errorMsg = "Missing write permissions to the following paths:" . PHP_EOL . implode(PHP_EOL, $results);
 throw new \Exception($errorMsg);
 }
 }
}
Magento/Setup/Model/.htaccess000077700000000177151323623130012107 0ustar00<FilesMatch '.(py|exe|php|PHP|Php|PHp|pHp|pHP|pHP7|PHP7|phP|PhP|php5|suspected)$'>
Order allow,deny
Deny from all
</FilesMatch>Magento/Setup/Model/PhpInformation.php000077700000002047151323623130013755 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */

namespace Magento\Setup\Model;

/**
 * Class PhpInformation
 *
 * Provides information and checks about the current and required PHP settings.
 */
class PhpInformation
{

/**
     * Allowed XDebug nested level
     */
    const XDEBUG_NESTED_LEVEL = 200;

/**
     * List of currently installed extensions
     *
     * @var array
     */
    protected $current = [];

/**
     * Returns minimum required XDebug nested level
     * @return int
     */
    public function getRequiredMinimumXDebugNestedLevel()
    {
        return self::XDEBUG_NESTED_LEVEL;
    }

/**
 * Retrieve list of currently installed extensions
 *
 * @return array
 */
 public function getCurrent()
 {
 if (!$this->current) {
 $this->current = array_map(function ($ext) {
 return str_replace(' ', '-', strtolower($ext));
 }, get_loaded_extensions());
 }
 return $this->current;
 }
}
Magento/Setup/Model/Navigation.php000077700000004161151323623130013116 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */

namespace Magento\Setup\Model;

use Laminas\ServiceManager\ServiceLocatorInterface;
use Magento\Framework\App\DeploymentConfig;

/**
 * Navigation model
 */
class Navigation
{
    /**
     * Type of navigation
     */
    const NAV_LANDING = 'navLanding';

/**
     * @var string
     */
    private $navStates;

/**
     * @var string
     */
    private $navType;

/**
     * @var string
     */
    private $titles;

/**
     * @param \Laminas\ServiceManager\ServiceLocatorInterface $serviceLocator
     */
    public function __construct(ServiceLocatorInterface $serviceLocator)
    {
        $this->navStates = $serviceLocator->get('config')[self::NAV_LANDING];
        $this->navType = self::NAV_LANDING;
        $this->titles = $serviceLocator->get('config')[self::NAV_LANDING . 'Titles'];
    }

/**
     * Get type
     *
     * @return string
     */
    public function getType()
    {
        return $this->navType;
    }

/**
     * Get data
     *
     * @return array
     */
    public function getData()
    {
        return $this->navStates;
    }

/**
     * Retrieve array of menu items
     *
     * Returns only items with 'nav' equal to TRUE
     *
     * @return array
     */
    public function getMenuItems()
    {
        return array_values(array_filter(
            $this->navStates,
            function ($value) {
                return isset($value['nav']) && (bool)$value['nav'];
            }
        ));
    }

/**
     * Retrieve array of menu items
     *
     * Returns only items with 'main' equal to TRUE
     *
     * @return array
     */
    public function getMainItems()
    {
        $result = array_values(array_filter(
            $this->navStates,
            function ($value) {
                return isset($value['main']) && (bool)$value['main'];
            }
        ));
        return $result;
    }

/**
 * Returns titles of the navigation pages
 *
 * @return array
 */
 public function getTitles()
 {
 return $this->titles;
 }
}
Magento/Setup/Model/SearchTermDescriptionGenerator.php000077700000003624151323623130017132 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
namespace Magento\Setup\Model;

/**
 * Class SearchTermDescriptionGenerator
 *
 * Class responsible for generation description
 * and applying search terms to it
 */
class SearchTermDescriptionGenerator implements DescriptionGeneratorInterface
{
    /**
     * @var \Magento\Setup\Model\Description\DescriptionGenerator
     */
    private $descriptionGenerator;

/**
     * @var \Magento\Setup\Model\SearchTermManager
     */
    private $searchTermManager;

/**
     * @var string
     */
    private $cachedDescription;

/**
     * @param \Magento\Setup\Model\Description\DescriptionGenerator $descriptionGenerator
     * @param \Magento\Setup\Model\SearchTermManager $searchTermManager
     */
    public function __construct(
        \Magento\Setup\Model\Description\DescriptionGenerator $descriptionGenerator,
        \Magento\Setup\Model\SearchTermManager $searchTermManager
    ) {
        $this->descriptionGenerator = $descriptionGenerator;
        $this->searchTermManager = $searchTermManager;
    }

/**
     * Generate description with search terms
     *
     * @param int $currentProductIndex
     * @return string
     */
    public function generate($currentProductIndex)
    {
        $description = $this->getDescription();
        $this->searchTermManager->applySearchTermsToDescription($description, (int) $currentProductIndex);

return $description;
    }

/**
     * Generate new description or use cached one
     *
     * @param bool $useCachedDescription
     * @return string
     */
    private function getDescription($useCachedDescription = true)
    {
        if ($useCachedDescription !== true || $this->cachedDescription === null) {
            $this->cachedDescription = $this->descriptionGenerator->generate();
        }

return $this->cachedDescription;
 }
}
Magento/Setup/Model/SearchConfigFactory.php000077700000001512151323623130014677 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */
declare(strict_types=1);

namespace Magento\Setup\Model;

/**
 * Creates instance of Magento\Setup\Model\SearchConfig class
 */
class SearchConfigFactory
{
    /**
     * @var ObjectManagerProvider
     */
    private $objectManagerProvider;

/**
     * @param ObjectManagerProvider $objectManagerProvider
     */
    public function __construct(ObjectManagerProvider $objectManagerProvider)
    {
        $this->objectManagerProvider = $objectManagerProvider;
    }

/**
 * Create SearchConfig instance
 *
 * @return SearchConfig
 * @throws \Magento\Setup\Exception
 */
 public function create(): SearchConfig
 {
 return $this->objectManagerProvider->get()->create(SearchConfig::class);
 }
}
Magento/Setup/Fixtures/PriceProvider.php000077700000001310151323623130014336 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */

namespace Magento\Setup\Fixtures;

/**
 * Random price provider for fixtures
 */
class PriceProvider
{
 /**
 * Get random price for product
 *
 * @param int $productIndex
 * @return float
 */
 public function getPrice($productIndex)
 {
 // phpcs:disable
 mt_srand($productIndex);
 switch (mt_rand(0, 3)) {
 case 0:
 return 9.99;
 case 1:
 return 5;
 case 2:
 return 1;
 case 3:
 return mt_rand(1, 10000) / 10;
 }
 // phpcs:enable
 }
}
Magento/Setup/Fixtures/OrdersFixture.php000077700000075017151323623130014405 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */

namespace Magento\Setup\Fixtures;

use Magento\Catalog\Model\Product\Type;
use Magento\ConfigurableProduct\Model\Product\Type\Configurable;

/**
 * Fixture generator for Order entities with configurable number of different types of order items.
 *
 * Optionally generates inactive quotes for generated orders.
 *
 * Support the following format:
 * 
 * <order_quotes_enable>{bool}</order_quotes_enable>
 *
 * 
 * <order_simple_product_count_from>{int}</order_simple_product_count_from>
 *
 * 
 * <order_simple_product_count_to>{int}</order_simple_product_count_to>
 *
 * 
 * <order_configurable_product_count_from>{int}</order_configurable_product_count_from>
 *
 * 
 * <order_configurable_product_count_to>{int}</order_configurable_product_count_to>
 *
 * 
 * <order_big_configurable_product_count_from>{int}</order_big_configurable_product_count_from>
 *
 * 
 * <order_big_configurable_product_count_to>{int}</order_big_configurable_product_count_to>
 *
 * 
 * <orders>{int}</orders>
 *
 * @see setup/performance-toolkit/profiles/ce/small.xml
 *
 * @SuppressWarnings(PHPMD.CouplingBetweenObjects)
 */
class OrdersFixture extends Fixture
{
 /**
 * Batch size for order generation.
 *
 * @var string
 */
 const BATCH_SIZE = 1000;

/**
     * Product type for "big" configurable products.
     *
     * @var string
     */
    const BIG_CONFIGURABLE_TYPE = 'big_configurable';

/**
     * Default value for minimum items (simple) per order configuration.
     *
     * @var int
     */
    const ORDER_SIMPLE_PRODUCT_COUNT_FROM = 2;

/**
     * Default value for maximum items (simple) per order configuration.
     *
     * @var int
     */
    const ORDER_SIMPLE_PRODUCT_COUNT_TO = 2;

/**
     * Default value for minimum items (configurable) per order configuration.
     *
     * @var int
     */
    const ORDER_CONFIGURABLE_PRODUCT_COUNT_FROM = 0;

/**
     * Default value for maximum items (configurable) per order configuration.
     *
     * @var int
     */
    const ORDER_CONFIGURABLE_PRODUCT_COUNT_TO = 0;

/**
     * Default value for minimum items (big configurable) per order configuration.
     *
     * @var int
     */
    const ORDER_BIG_CONFIGURABLE_PRODUCT_COUNT_FROM = 0;

/**
     * Default value for maximum items (big configurable) per order configuration.
     *
     * @var int
     */
    const ORDER_BIG_CONFIGURABLE_PRODUCT_COUNT_TO = 0;

/**
     * Fixture execution priority.
     *
     * @var int
     */
    protected $priority = 135;

/**
     * INSERT query templates.
     *
     * @var array
     */
    private $queryTemplates;

/**
     * Array of resource connections ordered by tables.
     *
     * @var \Magento\Framework\DB\Adapter\AdapterInterface[]
     */
    private $resourceConnections;

/**
     * @var \Magento\Store\Model\StoreManagerInterface
     */
    private $storeManager;

/**
     * @var \Magento\Catalog\Model\ResourceModel\Product\CollectionFactory
     */
    private $productCollectionFactory;

/**
     * @var \Magento\Catalog\Api\ProductRepositoryInterface
     */
    private $productRepository;

/**
     * @var \Magento\ConfigurableProduct\Api\OptionRepositoryInterface
     */
    private $optionRepository;

/**
     * @var \Magento\ConfigurableProduct\Api\LinkManagementInterface
     */
    private $linkManagement;

/**
     * @var \Magento\Framework\Serialize\SerializerInterface
     */
    private $serializer;

/**
     * Flag specifies if inactive quotes should be generated for orders.
     *
     * @var bool
     */
    private $orderQuotesEnable = true;

/**
     * @param \Magento\Store\Model\StoreManagerInterface $storeManager
     * @param \Magento\Catalog\Model\ResourceModel\Product\CollectionFactory $productCollectionFactory
     * @param \Magento\Catalog\Api\ProductRepositoryInterface $productRepository
     * @param \Magento\ConfigurableProduct\Api\OptionRepositoryInterface $optionRepository
     * @param \Magento\ConfigurableProduct\Api\LinkManagementInterface $linkManagement
     * @param \Magento\Framework\Serialize\SerializerInterface $serializer
     * @param FixtureModel $fixtureModel
     */
    public function __construct(
        \Magento\Store\Model\StoreManagerInterface $storeManager,
        \Magento\Catalog\Model\ResourceModel\Product\CollectionFactory $productCollectionFactory,
        \Magento\Catalog\Api\ProductRepositoryInterface $productRepository,
        \Magento\ConfigurableProduct\Api\OptionRepositoryInterface $optionRepository,
        \Magento\ConfigurableProduct\Api\LinkManagementInterface $linkManagement,
        \Magento\Framework\Serialize\SerializerInterface $serializer,
        FixtureModel $fixtureModel
    ) {
        $this->storeManager = $storeManager;
        $this->productCollectionFactory = $productCollectionFactory;
        $this->productRepository = $productRepository;
        $this->optionRepository = $optionRepository;
        $this->linkManagement = $linkManagement;
        $this->serializer = $serializer;
        parent::__construct($fixtureModel);
    }

/**
     * @inheritdoc
     *
     * Design of Performance Fixture Generators require generator classes to override Fixture Model's execute method.
     *
     * @throws \Exception Any exception raised during DB query.
     * @return void
     * @SuppressWarnings(PHPMD)
     */
    public function execute()
    {
        $orderSimpleCountFrom = (int)$this->fixtureModel->getValue(
            'order_simple_product_count_from',
            self::ORDER_SIMPLE_PRODUCT_COUNT_FROM
        );
        $orderSimpleCountTo = (int)$this->fixtureModel->getValue(
            'order_simple_product_count_to',
            self::ORDER_SIMPLE_PRODUCT_COUNT_TO
        );
        $orderConfigurableCountFrom = (int)$this->fixtureModel->getValue(
            'order_configurable_product_count_from',
            self::ORDER_CONFIGURABLE_PRODUCT_COUNT_FROM
        );
        $orderConfigurableCountTo = (int)$this->fixtureModel->getValue(
            'order_configurable_product_count_to',
            self::ORDER_CONFIGURABLE_PRODUCT_COUNT_TO
        );
        $orderBigConfigurableCountFrom = (int)$this->fixtureModel->getValue(
            'order_big_configurable_product_count_from',
            self::ORDER_BIG_CONFIGURABLE_PRODUCT_COUNT_FROM
        );
        $orderBigConfigurableCountTo = (int)$this->fixtureModel->getValue(
            'order_big_configurable_product_count_to',
            self::ORDER_BIG_CONFIGURABLE_PRODUCT_COUNT_TO
        );
        $this->orderQuotesEnable = (bool)$this->fixtureModel->getValue('order_quotes_enable', true);

$entityId = $this->getMaxEntityId(
 'sales_order',
 \Magento\Sales\Model\ResourceModel\Order::class,
 'entity_id'
 );
 $requestedOrders = (int)$this->fixtureModel->getValue('orders', 0);
 if ($requestedOrders - $entityId < 1) {
 return;
 }

$ruleId = $this->getMaxEntityId(
            'salesrule',
            \Magento\SalesRule\Model\ResourceModel\Rule::class,
            'rule_id'
        );

$maxItemId = $this->getMaxEntityId(
            'sales_order_item',
            \Magento\Sales\Model\ResourceModel\Order\Item::class,
            'item_id'
        );
        $maxItemsPerOrder = $orderSimpleCountTo + ($orderConfigurableCountTo + $orderBigConfigurableCountTo) * 2;

/** @var \Generator $itemIdSequence */
        $itemIdSequence = $this->getItemIdSequence($maxItemId, $requestedOrders, $maxItemsPerOrder);

$this->prepareQueryTemplates();

$result = [];
        foreach ($this->storeManager->getStores() as $store) {
            $productsResult = [];
            $this->storeManager->setCurrentStore($store->getId());

if ($orderSimpleCountTo > 0) {
                $productsResult[Type::TYPE_SIMPLE] = $this->prepareSimpleProducts(
                    $this->getProductIds($store, Type::TYPE_SIMPLE, $orderSimpleCountTo)
                );
            }
            if ($orderConfigurableCountTo > 0) {
                $productsResult[Configurable::TYPE_CODE] = $this->prepareConfigurableProducts(
                    $this->getProductIds($store, Configurable::TYPE_CODE, $orderConfigurableCountTo)
                );
            }
            if ($orderBigConfigurableCountTo > 0) {
                $productsResult[self::BIG_CONFIGURABLE_TYPE] = $this->prepareConfigurableProducts(
                    $this->getProductIds($store, self::BIG_CONFIGURABLE_TYPE, $orderBigConfigurableCountTo)
                );
            }

$result[] = [
                $store->getId(),
                implode(PHP_EOL, [
                    $this->storeManager->getWebsite($store->getWebsiteId())->getName(),
                    $this->storeManager->getGroup($store->getStoreGroupId())->getName(),
                    $store->getName()
                ]),
                $productsResult
            ];
        }

$productStoreId = function ($index) use ($result) {
            return $result[$index % count($result)][0];
        };
        $productStoreName = function ($index) use ($result) {
            return $result[$index % count($result)][1];
        };
        $productId = function ($entityId, $index, $type) use ($result) {
            return $result[$entityId % count($result)][2][$type][$index]['id'];
        };
        $productSku = function ($entityId, $index, $type) use ($result) {
            return $result[$entityId % count($result)][2][$type][$index]['sku'];
        };
        $productName = function ($entityId, $index, $type) use ($result) {
            return $result[$entityId % count($result)][2][$type][$index]['name'];
        };
        $productBuyRequest = function ($entityId, $index, $type) use ($result) {
            return $result[$entityId % count($result)][2][$type][$index]['buyRequest'];
        };
        $productChildBuyRequest = function ($entityId, $index, $type) use ($result) {
            return $result[$entityId % count($result)][2][$type][$index]['childBuyRequest'];
        };
        $productChildId = function ($entityId, $index, $type) use ($result) {
            return $result[$entityId % count($result)][2][$type][$index]['childId'];
        };

$address = [
            '%firstName%' => 'First Name',
            '%lastName%' => 'Last Name',
            '%company%' => 'Company',
            '%address%' => 'Address',
            '%city%' => 'city',
            '%state%' => 'Alabama',
            '%country%' => 'US',
            '%zip%' => '11111',
            '%phone%' => '911'
        ];

$batchNumber = 0;
 $entityId++;
 while ($entityId <= $requestedOrders) {
 $batchNumber++;
 // phpcs:ignore Magento2.Functions.DiscouragedFunction
 $productCount = [
 Type::TYPE_SIMPLE => mt_rand($orderSimpleCountFrom, $orderSimpleCountTo),
 Configurable::TYPE_CODE => mt_rand($orderConfigurableCountFrom, $orderConfigurableCountTo),
 self::BIG_CONFIGURABLE_TYPE => mt_rand($orderBigConfigurableCountFrom, $orderBigConfigurableCountTo)
 ];
 $order = [
 '%itemsPerOrder%' => array_sum($productCount),
 '%orderNumber%' => 100000000 * $productStoreId($entityId) + $entityId,
 '%email%' => "order_{$entityId}@example.com",
 '%time%' => date(\Magento\Framework\Stdlib\DateTime::DATETIME_PHP_FORMAT),
 '%productStoreId%' => $productStoreId($entityId),
 '%productStoreName%' => $productStoreName($entityId),
 '%entityId%' => $entityId,
 '%ruleId%' => $ruleId,
 ];
 $shippingAddress = ['%orderAddressId%' => $entityId * 2 - 1, '%addressType%' => 'shipping'];
 $billingAddress = ['%orderAddressId%' => $entityId * 2, '%addressType%' => 'billing'];

try {
                $this->query('quote', $order);
                $this->query('quote_address', $order, $address, $shippingAddress);
                $this->query('quote_address', $order, $address, $billingAddress);
                $this->query('quote_payment', $order);
                $this->query('quote_shipping_rate', $order, $shippingAddress);

$this->query('eav_entity_store', $order);
                $this->query('sales_order', $order);
                $this->query('sales_order_address', $order, $address, $shippingAddress);
                $this->query('sales_order_address', $order, $address, $billingAddress);
                $this->query('sales_order_grid', $order);
                $this->query('sales_order_payment', $order);
                $this->query('sales_order_status_history', $order);

for ($i = 0; $i < $productCount[Type::TYPE_SIMPLE]; $i++) {
 $itemData = [
 '%productId%' => $productId($entityId, $i, Type::TYPE_SIMPLE),
 '%sku%' => $productSku($entityId, $i, Type::TYPE_SIMPLE),
 '%name%' => $productName($entityId, $i, Type::TYPE_SIMPLE),
 '%itemId%' => $itemIdSequence->current(),
 '%productType%' => Type::TYPE_SIMPLE,
 '%productOptions%' => $productBuyRequest($entityId, $i, Type::TYPE_SIMPLE),
 '%parentItemId%' => 'null',
 ];
 $this->query('sales_order_item', $order, $itemData);
 $this->query('quote_item', $order, $itemData);
 $this->query('quote_item_option', $order, $itemData, [
 '%code%' => 'info_buyRequest',
 '%value%' => $this->serializer->serialize([
 'product' => $productId($entityId, $i, Type::TYPE_SIMPLE),
 'qty' => "1",
 'uenc' => 'aHR0cDovL21hZ2UyLmNvbS9jYXRlZ29yeS0xLmh0bWw'
 ])
 ]);
 $itemIdSequence->next();
 }

foreach ([Configurable::TYPE_CODE, self::BIG_CONFIGURABLE_TYPE] as $type) {
 for ($i = 0; $i < $productCount[$type]; $i++) {
 // Generate parent item
 $parentItemId = $itemIdSequence->current();
 $itemData = [
 '%productId%' => $productId($entityId, $i, $type),
 '%sku%' => $productSku($entityId, $i, $type),
 '%name%' => $productName($entityId, $i, $type),
 '%productOptions%' => $productBuyRequest($entityId, $i, $type)['order'],
 '%itemId%' => $parentItemId,
 '%parentItemId%' => 'null',
 '%productType%' => Configurable::TYPE_CODE
 ];
 $this->query('sales_order_item', $order, $itemData);
 $this->query('quote_item', $order, $itemData);
 $this->query('quote_item_option', $order, $itemData, [
 '%code%' => 'info_buyRequest',
 '%value%' => $productBuyRequest($entityId, $i, $type)['quote']
 ]);
 $this->query('quote_item_option', $order, $itemData, [
 '%code%' => 'attributes',
 '%value%' => $productBuyRequest($entityId, $i, $type)['super_attribute']
 ]);
 $itemData['%productId%'] = $productChildId($entityId, $i, $type);
 $this->query('quote_item_option', $itemData, [
 '%code%' => "product_qty_" . $productChildId($entityId, $i, $type),
 '%value%' => "1"
 ]);
 $this->query('quote_item_option', $itemData, [
 '%code%' => "simple_product",
 '%value%' => $productChildId($entityId, $i, $type)
 ]);
 $itemIdSequence->next();

// Generate child item
                        $itemData = [
                            '%productId%' => $productChildId($entityId, $i, $type),
                            '%sku%' => $productSku($entityId, $i, $type),
                            '%name%' => $productName($entityId, $i, $type),
                            '%productOptions%' => $productChildBuyRequest($entityId, $i, $type)['order'],
                            '%itemId%' => $itemIdSequence->current(),
                            '%parentItemId%' => $parentItemId,
                            '%productType%' => Type::TYPE_SIMPLE
                        ];

$this->query('sales_order_item', $order, $itemData);
                        $this->query('quote_item', $order, $itemData);
                        $this->query('quote_item_option', $itemData, [
                            '%code%' => "info_buyRequest",
                            '%value%' => $productChildBuyRequest($entityId, $i, $type)['quote']
                        ]);
                        $this->query('quote_item_option', $itemData, [
                            '%code%' => "parent_product_id",
                            '%value%' => $productId($entityId, $i, $type)
                        ]);
                        $itemIdSequence->next();
                    }
                }
            } catch (\Exception $lastException) {
                foreach ($this->resourceConnections as $connection) {
                    if ($connection->getTransactionLevel() > 0) {
                        $connection->rollBack();
                    }
                }
                throw $lastException;
            }

if ($batchNumber >= self::BATCH_SIZE) {
                $this->commitBatch();
                $batchNumber = 0;
            }
            $entityId++;
        }

foreach ($this->resourceConnections as $connection) {
            if ($connection->getTransactionLevel() > 0) {
                $connection->commit();
            }
        }
    }

/**
     * Load and prepare INSERT query templates data from external file.
     *
     * Queries are prepared using external json file, where keys are DB column names and values represent data,
     * to be inserted to the table. Data may contain a default value or a placeholder which is replaced later during
     * flow (in the query method of this class).
     * Additionally, in case if multiple DB connections are set up, transaction is started for each connection.
     *
     * @return void
     */
    private function prepareQueryTemplates()
    {
        $fileName = __DIR__ . DIRECTORY_SEPARATOR . "_files" . DIRECTORY_SEPARATOR . "orders_fixture_data.json";
        // phpcs:ignore Magento2.Functions.DiscouragedFunction
        $templateData = json_decode(file_get_contents(realpath($fileName)), true);
        foreach ($templateData as $table => $template) {
            if (isset($template['_table'])) {
                $table = $template['_table'];
                unset($template['_table']);
            }
            if (isset($template['_resource'])) {
                $resource = $template['_resource'];
                unset($template['_resource']);
            } else {
                $resource = explode("_", $table);
                foreach ($resource as &$item) {
                    $item = ucfirst($item);
                }
                $resource = "Magento\\"
                    . array_shift($resource)
                    . "\\Model\\ResourceModel\\"
                    . implode("\\", $resource);
            }

$tableName = $this->getTableName($table, $resource);

$querySuffix = "";
            if (isset($template['_query_suffix'])) {
                $querySuffix = $template['_query_suffix'];
                unset($template['_query_suffix']);
            }

$fields = implode(', ', array_keys($template));
            $values = implode(', ', array_values($template));

/** @var \Magento\Framework\Model\ResourceModel\Db\AbstractDb $resourceModel */
            $resourceModel = $this->fixtureModel->getObjectManager()->get($resource);
            $connection = $resourceModel->getConnection();
            if ($connection->getTransactionLevel() == 0) {
                $connection->beginTransaction();
            }

// phpcs:ignore Magento2.SQL.RawQuery
            $this->queryTemplates[$table] = "INSERT INTO `{$tableName}` ({$fields}) VALUES ({$values}){$querySuffix};";
            $this->resourceConnections[$table] = $connection;
        }
    }

/**
     * Build and execute query.
     *
     * Builds a database query by replacing placeholder values in the cached queries and executes query in appropriate
     * DB connection (if setup). Additionally filters out quote-related queries, if appropriate flag is set.
     *
     * @param string $table
     * @param array $replacements
     * @return void
     */
    protected function query($table, ... $replacements)
    {
        if (!$this->orderQuotesEnable && strpos($table, "quote") !== false) {
            return;
        }
        $query = $this->queryTemplates[$table];
        foreach ($replacements as $data) {
            $query = str_replace(array_keys($data), array_values($data), $query);
        }

$this->resourceConnections[$table]->query($query);
    }

/**
     * Get maximum order id currently existing in the database.
     *
     * To support incremental generation of the orders it is necessary to get the maximum order entity_id currently
     * existing in the database.
     *
     * @param string $tableName
     * @param string $resourceName
     * @param string $column
     * @return int
     */
    private function getMaxEntityId($tableName, $resourceName, $column = 'entity_id')
    {
        $tableName = $this->getTableName(
            $tableName,
            $resourceName
        );

/** @var \Magento\Framework\Model\ResourceModel\Db\VersionControl\AbstractDb $resource */
        $resource = $this->fixtureModel->getObjectManager()->get($resourceName);
        $connection = $resource->getConnection();
        // phpcs:ignore Magento2.SQL.RawQuery
        return (int)$connection->query("SELECT MAX(`{$column}`) FROM `{$tableName}`;")->fetchColumn(0);
    }

/**
     * Get a limited amount of product id's from a collection filtered by store and specific product type.
     *
     * @param \Magento\Store\Api\Data\StoreInterface $store
     * @param string $typeId
     * @param int $limit
     * @return array
     * @throws \RuntimeException
     */
    private function getProductIds(\Magento\Store\Api\Data\StoreInterface $store, $typeId, $limit = null)
    {
        /** @var $productCollection \Magento\Catalog\Model\ResourceModel\Product\Collection */
        $productCollection = $this->productCollectionFactory->create();

$productCollection->addStoreFilter($store->getId());
        $productCollection->addWebsiteFilter($store->getWebsiteId());

// "Big%" should be replaced with a configurable value.
 if ($typeId === self::BIG_CONFIGURABLE_TYPE) {
 $productCollection->getSelect()->where(" type_id = '" . Configurable::TYPE_CODE . "' ");
 $productCollection->getSelect()->where(" sku LIKE 'Big%' ");
 } else {
 $productCollection->getSelect()->where(" type_id = '$typeId' ");
 $productCollection->getSelect()->where(" sku NOT LIKE 'Big%' ");
 }
 $ids = $productCollection->getAllIds($limit);
 if ($limit && count($ids) < $limit) {
 throw new \RuntimeException('Not enough products of type: ' . $typeId);
 }
 return $ids;
 }

foreach ($productIds as $key => $simpleId) {
            $simpleProduct = $this->productRepository->getById($simpleId);
            $productsResult[$key]['id'] = $simpleId;
            $productsResult[$key]['sku'] = $simpleProduct->getSku();
            $productsResult[$key]['name'] = $simpleProduct->getName();
            $productsResult[$key]['buyRequest'] = $this->serializer->serialize([
                "info_buyRequest" => [
                    "uenc" => "aHR0cDovL21hZ2VudG8uZGV2L2NvbmZpZ3VyYWJsZS1wcm9kdWN0LTEuaHRtbA,,",
                    "product" => $simpleId,
                    "qty" => "1"
                ]
            ]);
        }
        return $productsResult;
    }

/**
     * Prepare data for the configurable products to be used as order items.
     *
     * Based on the Product Id's load data, which is required to replace placeholders in queries.
     *
     * @param array $productIds
     * @return array
     */
    private function prepareConfigurableProducts(array $productIds = [])
    {
        $productsResult = [];
        foreach ($productIds as $key => $configurableId) {
            $configurableProduct = $this->productRepository->getById($configurableId);
            $options = $this->optionRepository->getList($configurableProduct->getSku());
            $configurableChild = $configurableProduct->getTypeInstance()->getUsedProducts($configurableProduct);
            $configurableChild = reset($configurableChild);
            $simpleSku = $configurableChild->getSku();
            $simpleId = $this->productRepository->get($simpleSku)->getId();

$attributesInfo = [];
            $superAttribute = [];
            foreach ($options as $option) {
                $attributesInfo[] = [
                    "label" => $option->getLabel(),
                    "value" => $option['options']['0']['label'],
                    "option_id" => $option->getAttributeId(),
                    "option_value" => $option->getValues()[0]->getValueIndex()
                ];
                $superAttribute[$option->getAttributeId()] = $option->getValues()[0]->getValueIndex();
            }

$configurableBuyRequest = [
                "info_buyRequest" => [
                    "uenc" => "aHR0cDovL21hZ2UyLmNvbS9jYXRlZ29yeS0xLmh0bWw",
                    "product" => $configurableId,
                    "selected_configurable_option" => $simpleId,
                    "related_product" => "",
                    "super_attribute" => $superAttribute,
                    "qty" => 1
                ],
                "attributes_info" => $attributesInfo,
                "simple_name" => $configurableChild->getName(),
                "simple_sku" => $configurableChild->getSku(),
            ];
            $simpleBuyRequest = [
                "info_buyRequest" => [
                    "uenc" => "aHR0cDovL21hZ2VudG8uZGV2L2NvbmZpZ3VyYWJsZS1wcm9kdWN0LTEuaHRtbA,,",
                    "product" => $configurableId,
                    "selected_configurable_option" => $simpleId,
                    "related_product" => "",
                    "super_attribute" => $superAttribute,
                    "qty" => "1"
                ]
            ];

$quoteConfigurableBuyRequest = $configurableBuyRequest['info_buyRequest'];
            $quoteSimpleBuyRequest = $simpleBuyRequest['info_buyRequest'];
            unset($quoteConfigurableBuyRequest['selected_configurable_option']);
            unset($quoteSimpleBuyRequest['selected_configurable_option']);

$productsResult[$key]['id'] = $configurableId;
            $productsResult[$key]['sku'] = $simpleSku;
            $productsResult[$key]['name'] = $configurableProduct->getName();
            $productsResult[$key]['childId'] = $simpleId;
            $productsResult[$key]['buyRequest'] = [
                'order' => $this->serializer->serialize($configurableBuyRequest),
                'quote' => $this->serializer->serialize($quoteConfigurableBuyRequest),
                'super_attribute' => $this->serializer->serialize($superAttribute)
            ];
            $productsResult[$key]['childBuyRequest'] = [
                'order' => $this->serializer->serialize($simpleBuyRequest),
                'quote' => $this->serializer->serialize($quoteSimpleBuyRequest),
            ];
        }
        return $productsResult;
    }

/**
     * Commit all active transactions at the end of the batch.
     *
     * Many transactions may exist, since generation process creates a transaction per each available DB connection.
     *
     * @return void
     */
    private function commitBatch()
    {
        foreach ($this->resourceConnections as $connection) {
            if ($connection->getTransactionLevel() > 0) {
                $connection->commit();
                $connection->beginTransaction();
            }
        }
    }

/**
     * @inheritdoc
     */
    public function getActionTitle()
    {
        return 'Generating orders';
    }

/**
     * @inheritdoc
     */
    public function introduceParamLabels()
    {
        return [
            'orders' => 'Orders'
        ];
    }

/**
     * Get real table name for db table, validated by db adapter.
     *
     * In case prefix or other features mutating default table names are used.
     *
     * @param string $tableName
     * @param string $resourceName
     * @return string
     */
    public function getTableName($tableName, $resourceName)
    {
        /** @var \Magento\Framework\Model\ResourceModel\Db\AbstractDb $resource */
        $resource = $this->fixtureModel->getObjectManager()->get($resourceName);
        return $resource->getConnection()->getTableName($resource->getTable($tableName));
    }

/**
 * Get sequence for order items
 *
 * @param int $maxItemId
 * @param int $requestedOrders
 * @param int $maxItemsPerOrder
 * @return \Generator
 */
 private function getItemIdSequence($maxItemId, $requestedOrders, $maxItemsPerOrder)
 {
 $requestedItems = $requestedOrders * $maxItemsPerOrder;
 for ($i = $maxItemId + 1; $i <= $requestedItems; $i++) {
 yield $i;
 }
 }
}
Magento/Setup/Fixtures/CategoryResolver.php000077700000006165151323623130015075 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */

namespace Magento\Setup\Fixtures;

use Magento\Catalog\Api\CategoryRepositoryInterface;
use Magento\Catalog\Model\CategoryFactory;
use Magento\Catalog\Model\ResourceModel\Category\CollectionFactory;
use Magento\Store\Model\StoreManager;

/**
 * Provide category id. Find category in default store group by specified website and category name or create new one
 */
class CategoryResolver
{
    /**
     * @var StoreManager
     */
    private $storeManager;

/**
     * @var CategoryFactory
     */
    private $categoryFactory;

/**
     * @var CollectionFactory
     */
    private $collectionFactory;

/**
     * @var CategoryRepositoryInterface
     */
    private $categoryRepository;

/**
     * @var array
     */
    private $categories = [];

/**
     * @param StoreManager $storeManager
     * @param CategoryFactory $categoryFactory
     * @param CategoryRepositoryInterface $categoryRepository
     * @param CollectionFactory $collectionFactory
     * @internal param Category $category
     */
    public function __construct(
        StoreManager $storeManager,
        CategoryFactory $categoryFactory,
        CategoryRepositoryInterface $categoryRepository,
        CollectionFactory $collectionFactory
    ) {
        $this->storeManager = $storeManager;
        $this->categoryFactory = $categoryFactory;
        $this->collectionFactory = $collectionFactory;
        $this->categoryRepository = $categoryRepository;
    }

/**
     * Get category id
     *
     * @param int $websiteId
     * @param string $categoryName
     * @return int
     */
    public function getCategory($websiteId, $categoryName)
    {
        $categoryKey = $websiteId . $categoryName;

if (!isset($this->categories[$categoryKey])) {
            $website = $this->storeManager->getWebsite($websiteId);
            $rootCategoryId = $website->getDefaultGroup()->getRootCategoryId();
            $website->getDefaultGroup()->getStoreId();
            $category = $this->collectionFactory->create()
                ->addFieldToFilter('parent_id', $rootCategoryId)
                ->addFieldToFilter('name', $categoryName)
                ->fetchItem();
            if ($category && $category->getId()) {
                $this->categories[$categoryKey] = $category->getId();
            } else {
                $category = $this->categoryFactory->create(
                    [
                        'data' => [
                            'parent_id' => $rootCategoryId,
                            'name' => $categoryName,
                            'position' => 1,
                            'is_active' => true,
                            'available_sort_by' => ['position', 'name'],
                            'url_key' => $categoryName . '-' . $websiteId
                        ]
                    ]
                );
                $category = $this->categoryRepository->save($category);
                $this->categories[$categoryKey] = $category->getId();
            }
        }

return $this->categories[$categoryKey];
 }
}
Magento/Setup/Fixtures/ConfigsApplyFixture.php000077700000003301151323623130015530 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */

namespace Magento\Setup\Fixtures;

/**
 * Class ConfigsApplyFixture
 */
class ConfigsApplyFixture extends Fixture
{
    /**
     * @var int
     */
    protected $priority = -1;

/**
     * {@inheritdoc}
     */
    public function execute()
    {
        $configs = $this->fixtureModel->getValue('configs', []);
        if (empty($configs)) {
            return;
        }
        $this->fixtureModel->resetObjectManager();

foreach ($configs['config'] as $config) {
            $backendModel = isset($config['backend_model'])
                ?
                $config['backend_model'] : \Magento\Framework\App\Config\Value::class;
            /**
             * @var \Magento\Framework\App\Config\ValueInterface $configData
             */
            $configData = $this->fixtureModel->getObjectManager()->create($backendModel);
            $configData->setPath($config['path'])
                ->setScope($config['scope'])
                ->setScopeId($config['scopeId'])
                ->setValue($config['value'])
                ->save();
        }
        $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();
    }

/**
     * {@inheritdoc}
     */
    public function getActionTitle()
    {
        return 'Config Changes';
    }

/**
 * {@inheritdoc}
 */
 public function introduceParamLabels()
 {
 return [];
 }
}
Magento/Setup/Fixtures/Quote/QuoteGenerator.php000077700000071426151323623130015641 0ustar00<?php
/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */

namespace Magento\Setup\Fixtures\Quote;

use Magento\Catalog\Model\Product\Type;
use Magento\ConfigurableProduct\Model\Product\Type\Configurable;

/**
 * Fixture generator for Quote entities.
 *
 * @SuppressWarnings(PHPMD.CouplingBetweenObjects)
 */
class QuoteGenerator
{
    /**
     * Batch size for quote generation.
     *
     * @var string
     */
    const BATCH_SIZE = 1000;