SuiteGenerator.php

Go to the documentation of this file.

<?php
namespace Magento\FunctionalTestingFramework\Suite;

use Magento\FunctionalTestingFramework\Exceptions\TestReferenceException;
use Magento\FunctionalTestingFramework\Exceptions\XmlException;
use Magento\FunctionalTestingFramework\Suite\Generators\GroupClassGenerator;
use Magento\FunctionalTestingFramework\Suite\Handlers\SuiteObjectHandler;
use Magento\FunctionalTestingFramework\Suite\Objects\SuiteObject;
use Magento\FunctionalTestingFramework\Test\Handlers\TestObjectHandler;
use Magento\FunctionalTestingFramework\Util\Filesystem\DirSetupUtil;
use Magento\FunctionalTestingFramework\Util\Logger\LoggingUtil;
use Magento\FunctionalTestingFramework\Util\Manifest\BaseTestManifest;
use Magento\FunctionalTestingFramework\Util\TestGenerator;
use Symfony\Component\Yaml\Yaml;

class SuiteGenerator
{
    const YAML_CODECEPTION_DIST_FILENAME = 'codeception.dist.yml';
    const YAML_CODECEPTION_CONFIG_FILENAME = 'codeception.yml';
    const YAML_GROUPS_TAG = 'groups';
    const YAML_EXTENSIONS_TAG = 'extensions';
    const YAML_ENABLED_TAG = 'enabled';
    const YAML_COPYRIGHT_TEXT =
        "# Copyright © Magento, Inc. All rights reserved.\n# See COPYING.txt for license details.\n";

    private static $SUITE_GENERATOR_INSTANCE;

    private $groupClassGenerator;

    private function __construct()
    {
        $this->groupClassGenerator = new GroupClassGenerator();
    }

    public static function getInstance()
    {
        if (!self::$SUITE_GENERATOR_INSTANCE) {
            // clear any previous configurations before any generation occurs.
            self::clearPreviousGroupPreconditions();
            self::clearPreviousSessionConfigEntries();
            self::$SUITE_GENERATOR_INSTANCE = new SuiteGenerator();
        }

        return self::$SUITE_GENERATOR_INSTANCE;
    }

    public function generateAllSuites($testManifest)
    {
        $suites = $testManifest->getSuiteConfig();

        foreach ($suites as $suiteName => $suiteContent) {
            $firstElement = array_values($suiteContent)[0];

            // if the first element is a string we know that we simply have an array of tests
            if (is_string($firstElement)) {
                $this->generateSuiteFromTest($suiteName, $suiteContent);
            }

            // if our first element is an array we know that we have split the suites
            if (is_array($firstElement)) {
                $this->generateSplitSuiteFromTest($suiteName, $suiteContent);
            }
        }
    }

    public function generateSuite($suiteName)
    {
        $this->generateSuiteFromTest($suiteName, []);
    }

    private function generateSuiteFromTest($suiteName, $tests = [], $originalSuiteName = null)
    {
        $relativePath = TestGenerator::GENERATED_DIR . DIRECTORY_SEPARATOR . $suiteName;
        $fullPath = TESTS_MODULE_PATH . DIRECTORY_SEPARATOR . $relativePath . DIRECTORY_SEPARATOR;

        DirSetupUtil::createGroupDir($fullPath);

        $relevantTests = [];
        if (!empty($tests)) {
            $this->validateTestsReferencedInSuite($suiteName, $tests, $originalSuiteName);
            foreach ($tests as $testName) {
                $relevantTests[$testName] = TestObjectHandler::getInstance()->getObject($testName);
            }
        } else {
            $relevantTests = SuiteObjectHandler::getInstance()->getObject($suiteName)->getTests();
        }

        $this->generateRelevantGroupTests($suiteName, $relevantTests);
        $groupNamespace = $this->generateGroupFile($suiteName, $relevantTests, $originalSuiteName);

        $this->appendEntriesToConfig($suiteName, $fullPath, $groupNamespace);
        LoggingUtil::getInstance()->getLogger(SuiteGenerator::class)->info(
            "suite generated",
            ['suite' => $suiteName, 'relative_path' => $relativePath]
        );
    }

    private function validateTestsReferencedInSuite($suiteName, $testsReferenced, $originalSuiteName)
    {
        $suiteRef = $originalSuiteName ?? $suiteName;
        $possibleTestRef = SuiteObjectHandler::getInstance()->getObject($suiteRef)->getTests();
        $errorMsg = "Cannot reference tests whcih are not declared as part of suite.";

        $invalidTestRef = array_diff($testsReferenced, array_keys($possibleTestRef));

        if (!empty($invalidTestRef)) {
            throw new TestReferenceException($errorMsg, ['suite' => $suiteRef, 'test' => $invalidTestRef]);
        }
    }

    private function generateSplitSuiteFromTest($suiteName, $suiteContent)
    {
        foreach ($suiteContent as $suiteSplitName => $tests) {
            $this->generateSuiteFromTest($suiteSplitName, $tests, $suiteName);
        }
    }

    private function generateGroupFile($suiteName, $tests, $originalSuiteName)
    {
        // if there's an original suite name we know that this test came from a split group.
        if ($originalSuiteName) {
            // create the new suite object
            $originalSuite = SuiteObjectHandler::getInstance()->getObject($originalSuiteName);
            $suiteObject = new SuiteObject(
                $suiteName,
                $tests,
                [],
                $originalSuite->getHooks()
            );
        } else {
            $suiteObject = SuiteObjectHandler::getInstance()->getObject($suiteName);
            // we have to handle the case when there is a custom configuration for an existing suite.
            if (count($suiteObject->getTests()) != count($tests)) {
                return $this->generateGroupFile($suiteName, $tests, $suiteName);
            }
        }

        if (!$suiteObject->requiresGroupFile()) {
            // if we do not require a group file we don't need a namespace
            return null;
        }

        // if the suite requires a group file, generate it and set the namespace
        return $this->groupClassGenerator->generateGroupClass($suiteObject);
    }

    private function appendEntriesToConfig($suiteName, $suitePath, $groupNamespace)
    {
        $relativeSuitePath = substr($suitePath, strlen(TESTS_BP));
        $relativeSuitePath = ltrim($relativeSuitePath, DIRECTORY_SEPARATOR);

        $ymlArray = self::getYamlFileContents();
        if (!array_key_exists(self::YAML_GROUPS_TAG, $ymlArray)) {
            $ymlArray[self::YAML_GROUPS_TAG]= [];
        }

        if ($groupNamespace) {
            $ymlArray[self::YAML_EXTENSIONS_TAG][self::YAML_ENABLED_TAG][] = $groupNamespace;
        }
        $ymlArray[self::YAML_GROUPS_TAG][$suiteName] = [$relativeSuitePath];

        $ymlText = self::YAML_COPYRIGHT_TEXT . Yaml::dump($ymlArray, 10);
        file_put_contents(self::getYamlConfigFilePath() . self::YAML_CODECEPTION_CONFIG_FILENAME, $ymlText);
    }

    private static function clearPreviousSessionConfigEntries()
    {
        $ymlArray = self::getYamlFileContents();
        $newYmlArray = $ymlArray;
        // if the yaml entries haven't already been cleared
        if (array_key_exists(self::YAML_EXTENSIONS_TAG, $ymlArray)) {
            foreach ($ymlArray[self::YAML_EXTENSIONS_TAG][self::YAML_ENABLED_TAG] as $key => $entry) {
                if (preg_match('/(Group\\\\.*)/', $entry)) {
                    unset($newYmlArray[self::YAML_EXTENSIONS_TAG][self::YAML_ENABLED_TAG][$key]);
                }
            }

            // needed for proper yml file generation based on indices
            $newYmlArray[self::YAML_EXTENSIONS_TAG][self::YAML_ENABLED_TAG] =
                array_values($newYmlArray[self::YAML_EXTENSIONS_TAG][self::YAML_ENABLED_TAG]);
        }

        if (array_key_exists(self::YAML_GROUPS_TAG, $newYmlArray)) {
            unset($newYmlArray[self::YAML_GROUPS_TAG]);
        }

        $ymlText = self::YAML_COPYRIGHT_TEXT . Yaml::dump($newYmlArray, 10);
        file_put_contents(self::getYamlConfigFilePath() . self::YAML_CODECEPTION_CONFIG_FILENAME, $ymlText);
    }

    private function generateRelevantGroupTests($path, $tests)
    {
        $testGenerator = TestGenerator::getInstance($path, $tests);
        $testGenerator->createAllTestFiles(null, []);
    }

    private static function clearPreviousGroupPreconditions()
    {
        $groupFilePath = GroupClassGenerator::getGroupDirPath();
        array_map('unlink', glob("$groupFilePath*.php"));
    }

    private static function getYamlFileContents()
    {
        $configYmlFile = self::getYamlConfigFilePath() . self::YAML_CODECEPTION_CONFIG_FILENAME;
        $defaultConfigYmlFile = self::getYamlConfigFilePath() . self::YAML_CODECEPTION_DIST_FILENAME;

        $ymlContents = null;
        if (file_exists($configYmlFile)) {
            $ymlContents = file_get_contents($configYmlFile);
        } else {
            $ymlContents = file_get_contents($defaultConfigYmlFile);
        }

        return Yaml::parse($ymlContents) ?? [];
    }

    private static function getYamlConfigFilePath()
    {
        return TESTS_BP . DIRECTORY_SEPARATOR;
    }
}