/**
* Get Components info action
*
* @return \Zend\View\Model\JsonModel
* @throws \RuntimeException
* @SuppressWarnings(PHPMD.NPathComplexity)
*/
public function componentsAction()
{
$lastSyncData = $this->updatePackagesCache->getPackagesForUpdate();
$components = $this->composerInformation->getInstalledMagentoPackages();
$allModules = $this->getAllModules();
$components = array_replace_recursive($components, $allModules);
foreach ($components as $component) {
$components[$component['name']]['update'] = false;
$components[$component['name']]['uninstall'] = false;
$components[$component['name']]['moduleName'] = $this->packageInfo->getModuleName($component['name']);
if ($this->composerInformation->isPackageInComposerJson($component['name'])) {
if ($component['type'] !== \Magento\Framework\Composer\ComposerInformation::METAPACKAGE_PACKAGE_TYPE) {
$components[$component['name']]['uninstall'] = true;
}
if (isset($lastSyncData['packages'][$component['name']]['latestVersion']) && version_compare($lastSyncData['packages'][$component['name']]['latestVersion'], $component['version'], '>')) {
$components[$component['name']]['update'] = true;
}
}
if ($component['type'] === \Magento\Framework\Composer\ComposerInformation::MODULE_PACKAGE_TYPE) {
$components[$component['name']]['enable'] = $this->enabledModuleList->has($components[$component['name']]['moduleName']);
$components[$component['name']]['disable'] = !$components[$component['name']]['enable'];
} else {
$components[$component['name']]['enable'] = false;
$components[$component['name']]['disable'] = false;
}
$componentNameParts = explode('/', $component['name']);
$components[$component['name']]['vendor'] = $componentNameParts[0];
}
$packagesForInstall = $this->marketplaceManager->getPackagesForInstall();
$lastSyncData = $this->formatLastSyncData($packagesForInstall, $lastSyncData);
return new \Zend\View\Model\JsonModel(['success' => true, 'components' => array_values($components), 'total' => count($components), 'lastSyncData' => $lastSyncData]);
}
/**
* Run Composer dependency check for uninstall
*
* @param array $packages
* @return array
* @throws \RuntimeException
*/
public function runUninstallReadinessCheck(array $packages)
{
try {
$packagesAndTypes = $this->composerInfo->getRootRequiredPackageTypesByName();
$dependencies = $this->packageDependencyChecker->checkDependencies($packages, true);
$messages = [];
$themes = [];
foreach ($packages as $package) {
if (!isset($packagesAndTypes[$package])) {
throw new \RuntimeException('Package ' . $package . ' not found in the system.');
}
switch ($packagesAndTypes[$package]) {
case ComposerInformation::METAPACKAGE_PACKAGE_TYPE:
unset($dependencies[$package]);
break;
case ComposerInformation::THEME_PACKAGE_TYPE:
$themes[] = $package;
break;
}
if (!empty($dependencies[$package])) {
$messages[] = $package . " has the following dependent package(s): " . implode(', ', $dependencies[$package]);
}
}
if (!empty($themes)) {
$messages = array_merge($messages, $this->themeDependencyChecker->checkChildThemeByPackagesName($themes));
}
if (!empty($messages)) {
throw new \RuntimeException(implode(PHP_EOL, $messages));
}
return ['success' => true];
} catch (\RuntimeException $e) {
$message = str_replace(PHP_EOL, '<br/>', htmlspecialchars($e->getMessage()));
return ['success' => false, 'error' => $message];
}
}
/**
* @param array $packageList
* @param string $expectedVersion
* @dataProvider testGetVersionGitInstallationDataProvider
*/
public function testGetVersion($packageList, $expectedVersion)
{
$this->composerInformationMock->expects($this->any())->method('getSystemPackages')->willReturn($packageList);
$productVersion = $this->productMetadata->getVersion();
$this->assertNotEmpty($productVersion, 'Empty product version');
$this->assertEquals($expectedVersion, $productVersion);
}
/**
* @param string $packageName
* @param boolean $expected
* @dataProvider isMagentoRootDataProvider
*/
public function testIsMagentoRoot($packageName, $expected)
{
$rootPackageMock = $this->getMockForAbstractClass(\Composer\Package\RootPackageInterface::class);
$this->composerMock->expects($this->once())->method('getPackage')->willReturn($rootPackageMock);
$rootPackageMock->method('getName')->willReturn($packageName);
$this->assertEquals($expected, $this->composerInformation->isMagentoRoot());
}
public function testRunUninstallReadinessCheckWithError()
{
$packages = ['verndor/module' => 'magento2-module', 'verndor/theme' => 'magento2-theme', 'verndor/metapackage' => 'metapackage', 'verndor/language' => 'magento2-language'];
$this->composerInfo->expects($this->once())->method('getRootRequiredPackageTypesByName')->willReturn($packages);
$this->packageDependencyChecker->expects($this->once())->method('checkDependencies')->with(array_keys($packages))->willReturn([]);
$this->themeDependencyChecker->expects($this->once())->method('checkChildThemeByPackagesName')->with(['verndor/theme'])->willReturn(['Error message']);
$result = $this->uninstallDependencyCheck->runUninstallReadinessCheck(array_keys($packages));
$this->assertEquals(['success' => false, 'error' => 'Error message'], $result);
}
public function testComponentsActionWithError()
{
$this->composerInformation->expects($this->once())->method('getInstalledMagentoPackages')->will($this->throwException(new \Exception("Test error message")));
$jsonModel = $this->controller->componentsAction();
$this->assertInstanceOf('Zend\\View\\Model\\JsonModel', $jsonModel);
$variables = $jsonModel->getVariables();
$this->assertArrayHasKey('responseType', $variables);
$this->assertEquals(ResponseTypeInterface::RESPONSE_TYPE_ERROR, $variables['responseType']);
}
/**
* @covers \Magento\Setup\Controller\Connect::saveAuthJsonAction
*/
public function testSaveAuthJsonActionWithError()
{
$this->connectManager->expects($this->once())->method('checkCredentialsAction')->will($this->throwException(new \Exception()));
$this->composerInformation->expects($this->never())->method('saveAuthJson');
$jsonModel = $this->controller->saveAuthJsonAction();
$this->assertInstanceOf('\\Zend\\View\\Model\\JsonModel', $jsonModel);
$variables = $jsonModel->getVariables();
$this->assertArrayHasKey('success', $variables);
$this->assertArrayHasKey('message', $variables);
$this->assertFalse($variables['success']);
}
/**
* Retrieve list of sample data packages from suggests
*
* @return array
*/
public function getSampleDataPackages()
{
$installExtensions = [];
$suggests = $this->composerInformation->getSuggestedPackages();
$suggests = array_merge($suggests, $this->getSuggestsFromModules());
foreach ($suggests as $name => $version) {
if (strpos($version, self::SAMPLE_DATA_SUGGEST) === 0) {
$installExtensions[$name] = substr($version, strlen(self::SAMPLE_DATA_SUGGEST));
}
}
return $installExtensions;
}
public function testGetPackagesForUpdate()
{
$packageName = 'magento/module-store';
$this->setupDirectory('testSkeleton');
/** @var \Magento\Setup\Model\UpdatePackagesCache $updatePackagesCache */
$updatePackagesCache = $this->objectManager->create('Magento\\Setup\\Model\\UpdatePackagesCache', ['applicationFactory' => new MagentoComposerApplicationFactory($this->composerJsonFinder, $this->directoryList), 'filesystem' => $this->filesystem, 'dateTime' => new DateTime(), 'composerInformation' => $this->composerInformation]);
$requiredPackages = $this->composerInformation->getInstalledMagentoPackages();
$this->assertArrayHasKey($packageName, $requiredPackages);
$this->assertTrue($updatePackagesCache->syncPackagesForUpdate());
$packagesForUpdate = $updatePackagesCache->getPackagesForUpdate();
$this->assertArrayHasKey('packages', $packagesForUpdate);
$this->assertArrayHasKey($packageName, $packagesForUpdate['packages']);
$this->assertTrue(version_compare($packagesForUpdate['packages'][$packageName]['latestVersion'], $requiredPackages[$packageName]['version'], '>'));
}
/**
* @param string $ceCurrentVersion
* @param array $expectedResult
*
* @dataProvider getAllowedEnterpriseVersionsDataProvider
*/
public function testGetAllowedEnterpriseVersions($ceCurrentVersion, $expectedResult)
{
$this->composerAppFactory->expects($this->once())
->method('createInfoCommand')
->willReturn($this->infoCommand);
$this->systemPackage = new SystemPackage($this->composerAppFactory, $this->composerInformation);
$this->infoCommand->expects($this->once())
->method('run')
->with('magento/product-enterprise-edition')
->willReturn(['available_versions' => ['1.0.0', '1.0.1', '1.0.2']]);
$require = $this->getMock('\Composer\Package\Link', [], [], '', false);
$constraintMock = $this->getMock('\Composer\Package\LinkConstraint\VersionConstraint', [], [], '', false);
$constraintMock->expects($this->any())->method('getPrettyString')
->willReturn('1.0.1');
$require->expects($this->any())
->method('getConstraint')
->willReturn($constraintMock);
$this->composerInformation->expects($this->any())
->method('getPackageRequirements')
->willReturn(['magento/product-community-edition' => $require]);
$this->assertEquals(
$expectedResult,
$this->systemPackage->getAllowedEnterpriseVersions($ceCurrentVersion)
);
}
/**
* Execute uninstall on a component
*
* @param array $component
* @return void
* @throw \RuntimeException
*/
private function executeComponent(array $component)
{
if (!isset($component[self::COMPONENT_NAME])) {
$this->status->toggleUpdateError(true);
throw new \RuntimeException('Job parameter format is incorrect');
}
$componentName = $component[self::COMPONENT_NAME];
$installedPackages = $this->composerInformation->getInstalledMagentoPackages();
if (isset($installedPackages[$componentName]['type'])) {
$type = $installedPackages[$componentName]['type'];
} else {
$this->status->toggleUpdateError(true);
throw new \RuntimeException('Component type not set');
}
if (!in_array($type, [self::COMPONENT_MODULE, self::COMPONENT_THEME, self::COMPONENT_LANGUAGE, self::COMPONENT])) {
$this->status->toggleUpdateError(true);
throw new \RuntimeException('Unknown component type');
}
switch ($type) {
case self::COMPONENT_MODULE:
$dataOption = isset($this->params[self::DATA_OPTION]) && $this->params[self::DATA_OPTION] === 'true';
$this->moduleUninstall->uninstall($this->output, $componentName, $dataOption);
break;
case self::COMPONENT_THEME:
$this->themeUninstall->uninstall($this->output, $componentName);
break;
}
}
public function testComponentsAction()
{
$objectManager = $this->getMock('Magento\\Framework\\ObjectManagerInterface', [], [], '', false);
$this->objectManagerProvider->expects($this->once())->method('get')->willReturn($objectManager);
$objectManager->expects($this->any())->method('get')->willReturnMap([['Magento\\Framework\\Module\\PackageInfoFactory', $this->packageInfoFactoryMock], ['Magento\\Framework\\Module\\FullModuleList', $this->fullModuleListMock], ['Magento\\Framework\\Module\\ModuleList', $this->enabledModuleListMock]]);
$this->packageInfoFactoryMock->expects($this->once())->method('create')->willReturn($this->packageInfo);
$this->fullModuleListMock->expects($this->once())->method('getNames')->willReturn(['magento/sample-module1']);
$this->packageInfo->expects($this->once())->method('getModuleName')->willReturn('Sample_Module');
$this->packageInfo->expects($this->exactly(2))->method('getPackageName')->willReturn($this->componentData['magento/sample-module-one']['name']);
$this->packageInfo->expects($this->exactly(2))->method('getVersion')->willReturn($this->componentData['magento/sample-module-one']['version']);
$this->enabledModuleListMock->expects($this->once())->method('has')->willReturn(true);
$this->composerInformationMock->expects($this->once())->method('getInstalledMagentoPackages')->willReturn($this->componentData);
$this->composerInformationMock->expects($this->once())->method('isPackageInComposerJson')->willReturn(true);
$this->packagesAuth->expects($this->once())->method('getAuthJsonData')->willReturn(['username' => 'someusername', 'password' => 'somepassword']);
$this->packagesData->expects($this->once())->method('syncPackagesData')->willReturn($this->lastSyncData);
$jsonModel = $this->controller->componentsAction();
$this->assertInstanceOf('Zend\\View\\Model\\JsonModel', $jsonModel);
$variables = $jsonModel->getVariables();
$this->assertArrayHasKey('success', $variables);
$this->assertTrue($variables['success']);
$expected = [['name' => 'magento/sample-module-one', 'type' => 'magento2-module', 'version' => '1.0.0', 'update' => false, 'uninstall' => true, 'vendor' => 'magento', 'moduleName' => 'Sample_Module', 'enable' => true, 'disable' => false]];
$this->assertEquals($expected, $variables['components']);
$this->assertArrayHasKey('total', $variables);
$this->assertEquals(1, $variables['total']);
$this->assertEquals($this->lastSyncData, $variables['lastSyncData']);
}
/**
* @expectedException \RuntimeException
* @expectedExceptionMessage error
*/
public function testExecuteUpdateFails()
{
$this->updater->expects($this->once())->method('createUpdaterTask')->willReturn('error');
$this->composerInformation->expects($this->once())->method('getInstalledMagentoPackages')->willReturn(['vendor/language-a' => ['type' => JobComponentUninstall::COMPONENT_LANGUAGE]]);
$this->job = new JobComponentUninstall($this->composerInformation, $this->moduleUninstallHelper, $this->themeUninstallHelper, $this->objectManagerProvider, $this->output, $this->quence, $this->status, $this->updater, 'setup:component:uninstall', ['components' => [[JobComponentUninstall::COMPONENT_NAME => 'vendor/language-a']]]);
$this->job->execute();
}
/**
* 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,
],
];
}
/**
* Retrieve all available versions for a package
*
* @param string $package
* @return array
* @throws \RuntimeException
*/
private function getPackageAvailableVersions($package)
{
$magentoRepositories = $this->composerInformation->getRootRepositories();
// Check we have only one repo.magento.com repository
if (count($magentoRepositories) === 1 && strpos($magentoRepositories[0], $this->packagesAuth->getCredentialBaseUrl())) {
$packagesJsonData = $this->getPackagesJson();
if ($packagesJsonData) {
$packagesJsonData = json_decode($packagesJsonData, true);
} else {
$packagesJsonData['packages'] = [];
}
if (isset($packagesJsonData['packages'][$package])) {
$packageVersions = $packagesJsonData['packages'][$package];
uksort($packageVersions, 'version_compare');
$packageVersions = array_reverse($packageVersions);
return array_keys($packageVersions);
}
} else {
$versionsPattern = '/^versions\\s*\\:\\s(.+)$/m';
$commandParams = [self::PARAM_COMMAND => self::COMPOSER_SHOW, self::PARAM_PACKAGE => $package, self::PARAM_AVAILABLE => true];
$applicationFactory = $this->objectManagerProvider->get()->get('Magento\\Framework\\Composer\\MagentoComposerApplicationFactory');
/** @var \Magento\Composer\MagentoComposerApplication $application */
$application = $applicationFactory->create();
$result = $application->runComposerCommand($commandParams);
$matches = [];
preg_match($versionsPattern, $result, $matches);
if (isset($matches[1])) {
return explode(', ', $matches[1]);
}
}
throw new \RuntimeException(sprintf('Couldn\'t get available versions for package %s', $package));
}
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());
}
/**
* Validates user input
*
* @param string $package
*
* @return bool
*/
private function validate($package)
{
$installedPackages = $this->composerInfo->getRootRequiredPackageTypesByName();
if (isset($installedPackages[$package]) && $installedPackages[$package] === 'magento2-language') {
return true;
}
return false;
}
public function testGetPackagesForUpdate()
{
$packageName = 'magento/module-store';
$this->setupDirectory('testSkeleton');
/** @var UpdatePackagesCache $updatePackagesCache|\PHPUnit_Framework_MockObject_MockObject */
$updatePackagesCache = $this->getMock('Magento\\Setup\\Model\\UpdatePackagesCache', [], [], '', false);
$packages = ['packages' => [$packageName => ['latestVersion' => '1000.100.200']]];
$updatePackagesCache->expects($this->once())->method('syncPackagesForUpdate')->willReturn(true);
$updatePackagesCache->expects($this->once())->method('getPackagesForUpdate')->willReturn($packages);
$requiredPackages = $this->composerInformation->getInstalledMagentoPackages();
$this->assertArrayHasKey($packageName, $requiredPackages);
$this->assertTrue($updatePackagesCache->syncPackagesForUpdate());
$packagesForUpdate = $updatePackagesCache->getPackagesForUpdate();
$this->assertArrayHasKey('packages', $packagesForUpdate);
$this->assertArrayHasKey($packageName, $packagesForUpdate['packages']);
$this->assertTrue(version_compare($packagesForUpdate['packages'][$packageName]['latestVersion'], $requiredPackages[$packageName]['version'], '>'));
}
public function testExecutePackageNoLanguage()
{
$dependencies['vendor/language-ua_ua'] = [];
$this->dependencyChecker->expects($this->once())->method('checkDependencies')->with(['vendor/language-ua_ua'])->willReturn($dependencies);
$this->composerInfo->expects($this->once())->method('getRootRequiredPackagesAndTypes')->willReturn(['vendor/language-ua_ua' => 'library']);
$this->remove->expects($this->never())->method('remove');
$this->cache->expects($this->never())->method('clean');
$this->tester->execute(['package' => ['vendor/language-ua_ua']]);
$this->assertContains('Package vendor/language-ua_ua is not a Magento language and will be skipped', $this->tester->getDisplay());
$this->assertContains('Nothing is removed.', $this->tester->getDisplay());
}
/**
* Retrieve list of unknown packages
*
* @param string[] $themePaths
* @return string[]
*/
protected function getUnknownPackages($themePaths)
{
$installedPackages = $this->composer->getRootRequiredPackages();
$result = [];
foreach ($themePaths as $themePath) {
if (array_search($this->themePackageInfo->getPackageName($themePath), $installedPackages) === false) {
$result[] = $themePath;
}
}
return $result;
}
/**
* Get Components info action
*
* @return \Zend\View\Model\JsonModel
* @throws \RuntimeException
*/
public function componentsAction()
{
$objectManager = $this->objectManagerProvider->get();
$enabledModuleList = $objectManager->get('Magento\\Framework\\Module\\ModuleList');
$this->fullModuleList = $objectManager->get('Magento\\Framework\\Module\\FullModuleList');
$this->packageInfo = $objectManager->get('Magento\\Framework\\Module\\PackageInfoFactory')->create();
$lastSyncData = [];
$authDetails = $this->packagesAuth->getAuthJsonData();
if ($authDetails) {
$lastSyncData = $this->packagesData->syncPackagesData();
}
$components = $this->composerInformation->getInstalledMagentoPackages();
$allModules = $this->getAllModules();
$components = array_replace_recursive($components, $allModules);
foreach ($components as $component) {
$components[$component['name']]['update'] = false;
$components[$component['name']]['uninstall'] = false;
$components[$component['name']]['moduleName'] = $this->packageInfo->getModuleName($component['name']);
if ($this->composerInformation->isPackageInComposerJson($component['name'])) {
if ($component['type'] !== \Magento\Framework\Composer\ComposerInformation::METAPACKAGE_PACKAGE_TYPE) {
$components[$component['name']]['uninstall'] = true;
}
if (isset($lastSyncData['packages'][$component['name']]['latestVersion']) && version_compare($lastSyncData['packages'][$component['name']]['latestVersion'], $component['version'], '>')) {
$components[$component['name']]['update'] = true;
}
}
if ($component['type'] === \Magento\Framework\Composer\ComposerInformation::MODULE_PACKAGE_TYPE) {
$components[$component['name']]['enable'] = $enabledModuleList->has($components[$component['name']]['moduleName']);
$components[$component['name']]['disable'] = !$components[$component['name']]['enable'];
} else {
$components[$component['name']]['enable'] = false;
$components[$component['name']]['disable'] = false;
}
$componentNameParts = explode('/', $component['name']);
$components[$component['name']]['vendor'] = $componentNameParts[0];
}
return new \Zend\View\Model\JsonModel(['success' => true, 'components' => array_values($components), 'total' => count($components), 'lastSyncData' => $lastSyncData]);
}
/**
* Get Components from composer info command
*
* @return JsonModel
* @throws \RuntimeException
*/
public function componentsAction()
{
try {
$components = $this->composerInformation->getInstalledMagentoPackages();
foreach ($components as $component) {
if (!$this->composerInformation->isPackageInComposerJson($component['name'])) {
unset($components[$component['name']]);
continue;
}
$componentNameParts = explode('/', $component['name']);
$packageInfo = $this->infoCommand->run($component['name']);
if (!$packageInfo) {
throw new \RuntimeException('Package info not found for ' . $component['name']);
}
if ($packageInfo[InfoCommand::NEW_VERSIONS]) {
$currentVersion = $packageInfo[InfoCommand::CURRENT_VERSION];
$components[$component['name']]['version'] = $currentVersion;
$versions = [];
foreach ($packageInfo[InfoCommand::NEW_VERSIONS] as $version) {
$versions[] = ['id' => $version, 'name' => $version];
}
$versions[] = ['id' => $packageInfo[InfoCommand::CURRENT_VERSION], 'name' => $packageInfo[InfoCommand::CURRENT_VERSION]];
$versions[0]['name'] .= ' (latest)';
$versions[count($versions) - 1]['name'] .= ' (current)';
$components[$component['name']]['vendor'] = $componentNameParts[0];
$components[$component['name']]['updates'] = $versions;
$components[$component['name']]['dropdownId'] = 'dd_' . $component['name'];
$components[$component['name']]['checkboxId'] = 'cb_' . $component['name'];
} else {
unset($components[$component['name']]);
}
}
return new JsonModel(['components' => array_values($components), 'total' => count($components), 'responseType' => ResponseTypeInterface::RESPONSE_TYPE_SUCCESS]);
} catch (\Exception $e) {
return new JsonModel(['responseType' => ResponseTypeInterface::RESPONSE_TYPE_ERROR]);
}
}
public function testComponentsAction()
{
$this->fullModuleListMock->expects($this->once())
->method('getNames')
->willReturn(['magento/sample-module1']);
$this->packageInfo->expects($this->once())
->method('getModuleName')
->willReturn('Sample_Module');
$this->packageInfo->expects($this->exactly(2))
->method('getPackageName')
->willReturn($this->componentData['magento/sample-module-one']['name']);
$this->packageInfo->expects($this->exactly(2))
->method('getVersion')
->willReturn($this->componentData['magento/sample-module-one']['version']);
$this->enabledModuleListMock->expects($this->once())
->method('has')
->willReturn(true);
$this->composerInformationMock->expects($this->once())
->method('getInstalledMagentoPackages')
->willReturn($this->componentData);
$this->composerInformationMock->expects($this->once())
->method('isPackageInComposerJson')
->willReturn(true);
$this->updatePackagesCacheMock->expects($this->once())
->method('getPackagesForUpdate')
->willReturn($this->lastSyncData);
$jsonModel = $this->controller->componentsAction();
$this->assertInstanceOf('Zend\View\Model\JsonModel', $jsonModel);
$variables = $jsonModel->getVariables();
$this->assertArrayHasKey('success', $variables);
$this->assertTrue($variables['success']);
$expected = [[
'name' => 'magento/sample-module-one',
'type' => 'magento2-module',
'version' => '1.0.0',
'update' => false,
'uninstall' => true,
'vendor' => 'magento',
'moduleName' => 'Sample_Module',
'enable' => true,
'disable' => false
]];
$this->assertEquals($expected, $variables['components']);
$this->assertArrayHasKey('total', $variables);
$this->assertEquals(1, $variables['total']);
$this->assertEquals($this->lastSyncData, $variables['lastSyncData']);
}
/**
* @param string $currentCE
* @param array $enterpriseVersions
* @param string $maxVersion
* @return array
*/
public function filterEeVersions($currentCE, $enterpriseVersions, $maxVersion)
{
$eeVersions = [];
foreach ($enterpriseVersions['available_versions'] as $version) {
$requires = $this->composerInfo->getPackageRequirements('magento/product-enterprise-edition', $version);
if (array_key_exists('magento/product-community-edition', $requires)) {
/** @var \Composer\Package\Link $ceRequire */
$ceRequire = $requires['magento/product-community-edition'];
if (version_compare($ceRequire->getConstraint()->getPrettyString(), $currentCE, '>=')) {
$name = 'Version ' . $version . ' EE';
if ($maxVersion == $version) {
$name .= ' (latest)';
}
$eeVersions[] = ['id' => $version, 'name' => $name];
}
}
}
return $eeVersions;
}
/**
* Validate given full theme paths
*
* @param string[] $themePaths
* @return string[]
*/
private function validate($themePaths)
{
$messages = [];
$unknownPackages = [];
$unknownThemes = [];
$installedPackages = $this->composer->getRootRequiredPackages();
foreach ($themePaths as $themePath) {
if (array_search($this->getPackageName($themePath), $installedPackages) === false) {
$unknownPackages[] = $themePath;
}
if (!$this->themeCollection->hasTheme($this->themeCollection->getThemeByFullPath($themePath))) {
$unknownThemes[] = $themePath;
}
}
$unknownPackages = array_diff($unknownPackages, $unknownThemes);
if (!empty($unknownPackages)) {
$text = count($unknownPackages) > 1 ? ' are not installed Composer packages' : ' is not an installed Composer package';
$messages[] = '<error>' . implode(', ', $unknownPackages) . $text . '</error>';
}
if (!empty($unknownThemes)) {
$messages[] = '<error>Unknown theme(s): ' . implode(', ', $unknownThemes) . '</error>';
}
return $messages;
}
/**
* Validate list of modules against installed composer packages and return error messages
*
* @param string[] $modules
* @return string[]
*/
protected function validate(array $modules)
{
$messages = [];
$unknownPackages = [];
$unknownModules = [];
$installedPackages = $this->composer->getRootRequiredPackages();
foreach ($modules as $module) {
if (array_search($this->packageInfo->getPackageName($module), $installedPackages) === false) {
$unknownPackages[] = $module;
}
if (!$this->fullModuleList->has($module)) {
$unknownModules[] = $module;
}
}
$unknownPackages = array_diff($unknownPackages, $unknownModules);
if (!empty($unknownPackages)) {
$text = count($unknownPackages) > 1 ? ' are not installed composer packages' : ' is not an installed composer package';
$messages[] = '<error>' . implode(', ', $unknownPackages) . $text . '</error>';
}
if (!empty($unknownModules)) {
$messages[] = '<error>Unknown module(s): ' . implode(', ', $unknownModules) . '</error>';
}
return $messages;
}