ParallelGroupSorter.php

Go to the documentation of this file.

<?php
namespace Magento\FunctionalTestingFramework\Util\Sorter;

use Magento\FunctionalTestingFramework\Exceptions\TestFrameworkException;
use Magento\FunctionalTestingFramework\Test\Handlers\TestObjectHandler;

class ParallelGroupSorter
{
    private $suiteConfig = [];

    public function __construct()
    {
        // empty constructor
    }

    public function getTestsGroupedBySize($suiteConfiguration, $testNameToSize, $time)
    {
        // we must have the lines argument in order to create the test groups
        if ($time == 0) {
            throw new TestFrameworkException(
                "Please provide the argument '--time' to the robo command in order to".
                " generate grouped tests manifests for a parallel execution"
            );
        }

        $testGroups = [];
        $splitSuiteNamesToTests = $this->createGroupsWithinSuites($suiteConfiguration, $time);
        $splitSuiteNamesToSize = $this->getSuiteToSize($splitSuiteNamesToTests);
        arsort($testNameToSize);
        arsort($splitSuiteNamesToSize);

        $testNameToSizeForUse = $testNameToSize;
        $nodeNumber = 1;

        foreach ($splitSuiteNamesToSize as $testName => $testSize) {
            $testGroups[$nodeNumber] = [$testName => $testSize];
            $nodeNumber++;
        }

        foreach ($testNameToSize as $testName => $testSize) {
            if (!array_key_exists($testName, $testNameToSizeForUse)) {
                // skip tests which have already been added to a group
                continue;
            }

            $testGroup = $this->createTestGroup($time, $testName, $testSize, $testNameToSizeForUse);
            $testGroups[$nodeNumber] = $testGroup;

            // unset the test which have been used.
            $testNameToSizeForUse = array_diff_key($testNameToSizeForUse, $testGroup);
            $nodeNumber++;
        }

        return $testGroups;
    }

    public function getResultingSuiteConfig()
    {
        if (empty($this->suiteConfig)) {
            return null;
        }

        return $this->suiteConfig;
    }

    private function createTestGroup($timeMaximum, $testName, $testSize, $testNameToSizeForUse)
    {
        $group[$testName] = $testSize;

        if ($testSize < $timeMaximum) {
            while (array_sum($group) < $timeMaximum && !empty($testNameToSizeForUse)) {
                $groupSize = array_sum($group);
                $lineGoal = $timeMaximum - $groupSize;

                $testNameForUse = $this->getClosestLineCount($testNameToSizeForUse, $lineGoal);
                if ($testNameToSizeForUse[$testNameForUse] < $lineGoal) {
                    $testSizeForUse = $testNameToSizeForUse[$testNameForUse];
                    $group[$testNameForUse] = $testSizeForUse;
                }

                unset($testNameToSizeForUse[$testNameForUse]);
            }
        }

        return $group;
    }

    private function getClosestLineCount($testGroup, $desiredValue)
    {
        $winner = key($testGroup);
        $closestThreshold = $desiredValue;
        foreach ($testGroup as $testName => $testValue) {
            // find the difference between the desired value and test candidate for the group
            $testThreshold =  $desiredValue - $testValue;

            // if we see that the gap between the desired value is non-negative and lower than the current closest make
            // the test the winner.
            if ($closestThreshold > $testThreshold && $testThreshold > 0) {
                $closestThreshold = $testThreshold;
                $winner = $testName;
            }
        }

        return $winner;
    }

    private function createGroupsWithinSuites($suiteConfiguration, $lineLimit)
    {
        $suiteNameToTestSize = $this->getSuiteNameToTestSize($suiteConfiguration);
        $suiteNameToSize = $this->getSuiteToSize($suiteNameToTestSize);

        // divide the suites up within the array
        $suitesForResize = array_filter($suiteNameToSize, function ($val) use ($lineLimit) {
            return $val > $lineLimit;
        });

        // remove the suites for resize from the original list
        $remainingSuites = array_diff_key($suiteNameToTestSize, $suitesForResize);

        foreach ($remainingSuites as $remainingSuite => $tests) {
            $this->addSuiteToConfig($remainingSuite, null, $tests);
        }

        $resultingGroups = [];
        foreach ($suitesForResize as $suiteName => $suiteSize) {
            $resultingGroups = array_merge(
                $resultingGroups,
                $this->splitTestSuite($suiteName, $suiteNameToTestSize[$suiteName], $lineLimit)
            );
        }

        // merge the resulting divisions with the appropriately sized suites
        return array_merge($remainingSuites, $resultingGroups);
    }

    private function getSuiteNameToTestSize($suiteConfiguration)
    {
        $suiteNameToTestSize = [];
        foreach ($suiteConfiguration as $suite => $test) {
            foreach ($test as $testName) {
                $suiteNameToTestSize[$suite][$testName] = TestObjectHandler::getInstance()
                    ->getObject($testName)
                    ->getEstimatedDuration();
            }
        }

        return $suiteNameToTestSize;
    }

    private function getSuiteToSize($suiteNamesToTests)
    {
        $suiteNamesToSize = [];
        foreach ($suiteNamesToTests as $name => $tests) {
            $size = array_sum($tests);
            $suiteNamesToSize[$name] = $size;
        }

        return $suiteNamesToSize;
    }

    private function splitTestSuite($suiteName, $tests, $maxTime)
    {
        arsort($tests);
        $splitSuites = [];
        $availableTests = $tests;
        $splitCount = 0;

        foreach ($tests as $test => $size) {
            if (!array_key_exists($test, $availableTests)) {
                continue;
            }

            $group = $this->createTestGroup($maxTime, $test, $size, $availableTests);
            $splitSuites["{$suiteName}_${splitCount}"] = $group;
            $this->addSuiteToConfig($suiteName, "{$suiteName}_${splitCount}", $group);

            $availableTests = array_diff_key($availableTests, $group);
            $splitCount++;
        }

        return $splitSuites;
    }

    private function addSuiteToConfig($originalSuiteName, $newSuiteName, $tests)
    {
        if ($newSuiteName == null) {
            $this->suiteConfig[$originalSuiteName] = array_keys($tests);
            return;
        }

        $this->suiteConfig[$originalSuiteName][$newSuiteName] = array_keys($tests);
    }
}