mirror of
https://github.com/pestphp/pest.git
synced 2026-09-05 06:13:35 +02:00
nuno maduro
390 lines
10 KiB
PHP
390 lines
10 KiB
PHP
<?php
|
|
|
|
declare(strict_types=1);
|
|
|
|
/*
|
|
* This file is part of PHPUnit.
|
|
*
|
|
* (c) Sebastian Bergmann <sebastian@phpunit.de>
|
|
*
|
|
* For the full copyright and license information, please view the LICENSE
|
|
* file that was distributed with this source code.
|
|
*/
|
|
|
|
namespace PHPUnit\Runner;
|
|
|
|
use PHPUnit\Framework\DataProviderTestSuite;
|
|
use PHPUnit\Framework\IterativeTestSuite;
|
|
use PHPUnit\Framework\Reorderable;
|
|
use PHPUnit\Framework\Test;
|
|
use PHPUnit\Framework\TestCase;
|
|
use PHPUnit\Framework\TestSuite;
|
|
use PHPUnit\Runner\TestRunHistory\NullTestRunHistory;
|
|
use PHPUnit\Runner\TestRunHistory\TestRunHistory;
|
|
use PHPUnit\Runner\TestRunHistory\TestRunHistoryId;
|
|
|
|
use function array_diff;
|
|
use function array_merge;
|
|
use function array_reverse;
|
|
use function array_splice;
|
|
use function assert;
|
|
use function count;
|
|
use function in_array;
|
|
use function max;
|
|
use function shuffle;
|
|
use function usort;
|
|
|
|
/**
|
|
* @internal This class is not covered by the backward compatibility promise for PHPUnit
|
|
*/
|
|
final class TestSuiteSorter
|
|
{
|
|
public const int ORDER_DEFAULT = 0;
|
|
|
|
public const int ORDER_RANDOMIZED = 1;
|
|
|
|
public const int ORDER_REVERSED = 2;
|
|
|
|
public const int ORDER_DEFECTS_FIRST = 3;
|
|
|
|
public const int ORDER_DURATION_ASCENDING = 4;
|
|
|
|
public const int ORDER_SIZE_ASCENDING = 5;
|
|
|
|
public const int ORDER_DURATION_DESCENDING = 6;
|
|
|
|
public const int ORDER_SIZE_DESCENDING = 7;
|
|
|
|
/**
|
|
* @var non-empty-array<non-empty-string, positive-int>
|
|
*/
|
|
private const array SIZE_SORT_WEIGHT = [
|
|
'small' => 1,
|
|
'medium' => 2,
|
|
'large' => 3,
|
|
'unknown' => 4,
|
|
];
|
|
|
|
/**
|
|
* @var array<string, int> Associative array of (string => DEFECT_SORT_WEIGHT) elements
|
|
*/
|
|
private array $defectSortOrder = [];
|
|
|
|
private readonly TestRunHistory $testRunHistory;
|
|
|
|
public function __construct(?TestRunHistory $testRunHistory = null)
|
|
{
|
|
$this->testRunHistory = $testRunHistory ?? new NullTestRunHistory;
|
|
}
|
|
|
|
/**
|
|
* @throws Exception
|
|
*/
|
|
public function reorderTestsInSuite(Test $suite, int $order, bool $resolveDependencies, int $orderDefects): void
|
|
{
|
|
$allowedOrders = [
|
|
self::ORDER_DEFAULT,
|
|
self::ORDER_REVERSED,
|
|
self::ORDER_RANDOMIZED,
|
|
self::ORDER_DURATION_ASCENDING,
|
|
self::ORDER_SIZE_ASCENDING,
|
|
self::ORDER_DURATION_DESCENDING,
|
|
self::ORDER_SIZE_DESCENDING,
|
|
];
|
|
|
|
if (! in_array($order, $allowedOrders, true)) {
|
|
// @codeCoverageIgnoreStart
|
|
throw new InvalidOrderException;
|
|
// @codeCoverageIgnoreEnd
|
|
}
|
|
|
|
$allowedOrderDefects = [
|
|
self::ORDER_DEFAULT,
|
|
self::ORDER_DEFECTS_FIRST,
|
|
];
|
|
|
|
if (! in_array($orderDefects, $allowedOrderDefects, true)) {
|
|
// @codeCoverageIgnoreStart
|
|
throw new InvalidOrderException;
|
|
// @codeCoverageIgnoreEnd
|
|
}
|
|
|
|
if ($suite instanceof IterativeTestSuite) {
|
|
return;
|
|
}
|
|
|
|
if ($suite instanceof TestSuite) {
|
|
foreach ($suite as $_suite) {
|
|
$this->reorderTestsInSuite($_suite, $order, $resolveDependencies, $orderDefects);
|
|
}
|
|
|
|
if ($orderDefects === self::ORDER_DEFECTS_FIRST) {
|
|
$this->addSuiteToDefectSortOrder($suite);
|
|
}
|
|
|
|
$this->sort($suite, $order, $resolveDependencies, $orderDefects);
|
|
}
|
|
}
|
|
|
|
private function sort(TestSuite $suite, int $order, bool $resolveDependencies, int $orderDefects): void
|
|
{
|
|
$tests = $suite->tests();
|
|
|
|
if ($tests === []) {
|
|
return;
|
|
}
|
|
|
|
if ($order === self::ORDER_REVERSED) {
|
|
$tests = $this->reverse($tests);
|
|
} elseif ($order === self::ORDER_RANDOMIZED) {
|
|
$tests = $this->randomize($tests);
|
|
} elseif ($order === self::ORDER_DURATION_ASCENDING) {
|
|
$tests = $this->sortByDuration($tests);
|
|
} elseif ($order === self::ORDER_DURATION_DESCENDING) {
|
|
$tests = $this->sortByDurationDescending($tests);
|
|
} elseif ($order === self::ORDER_SIZE_ASCENDING) {
|
|
$tests = $this->sortBySize($tests);
|
|
} elseif ($order === self::ORDER_SIZE_DESCENDING) {
|
|
$tests = $this->sortBySizeDescending($tests);
|
|
}
|
|
|
|
if ($orderDefects === self::ORDER_DEFECTS_FIRST) {
|
|
$tests = $this->sortDefectsFirst($tests);
|
|
}
|
|
|
|
if ($resolveDependencies && ! ($suite instanceof DataProviderTestSuite)) {
|
|
/** @noinspection PhpParamsInspection */
|
|
/** @phpstan-ignore argument.type */
|
|
$tests = $this->resolveDependencies($tests);
|
|
}
|
|
|
|
$suite->setTests($tests);
|
|
}
|
|
|
|
private function addSuiteToDefectSortOrder(TestSuite $suite): void
|
|
{
|
|
$max = 0;
|
|
|
|
foreach ($suite->tests() as $test) {
|
|
assert($test instanceof Reorderable);
|
|
|
|
$sortId = $test->sortId();
|
|
|
|
if (! isset($this->defectSortOrder[$sortId])) {
|
|
$this->defectSortOrder[$sortId] = $this->testRunHistory->status(TestRunHistoryId::fromReorderable($test))->sortWeight();
|
|
}
|
|
|
|
$max = max($max, $this->defectSortOrder[$sortId]);
|
|
}
|
|
|
|
$this->defectSortOrder[$suite->sortId()] = $max;
|
|
}
|
|
|
|
/**
|
|
* @param list<Test> $tests
|
|
* @return list<Test>
|
|
*/
|
|
private function reverse(array $tests): array
|
|
{
|
|
return array_reverse($tests);
|
|
}
|
|
|
|
/**
|
|
* @param list<Test> $tests
|
|
* @return list<Test>
|
|
*/
|
|
private function randomize(array $tests): array
|
|
{
|
|
shuffle($tests);
|
|
|
|
return $tests;
|
|
}
|
|
|
|
/**
|
|
* @param list<Test> $tests
|
|
* @return list<Test>
|
|
*/
|
|
private function sortDefectsFirst(array $tests): array
|
|
{
|
|
usort(
|
|
$tests,
|
|
fn (Test $left, Test $right) => $this->cmpDefectPriorityAndTime($left, $right),
|
|
);
|
|
|
|
return $tests;
|
|
}
|
|
|
|
/**
|
|
* @param list<Test> $tests
|
|
* @return list<Test>
|
|
*/
|
|
private function sortByDuration(array $tests): array
|
|
{
|
|
usort(
|
|
$tests,
|
|
fn (Test $left, Test $right) => $this->cmpDuration($left, $right),
|
|
);
|
|
|
|
return $tests;
|
|
}
|
|
|
|
/**
|
|
* @param list<Test> $tests
|
|
* @return list<Test>
|
|
*/
|
|
private function sortByDurationDescending(array $tests): array
|
|
{
|
|
usort(
|
|
$tests,
|
|
fn (Test $left, Test $right) => $this->cmpDuration($right, $left),
|
|
);
|
|
|
|
return $tests;
|
|
}
|
|
|
|
/**
|
|
* @param list<Test> $tests
|
|
* @return list<Test>
|
|
*/
|
|
private function sortBySize(array $tests): array
|
|
{
|
|
usort(
|
|
$tests,
|
|
fn (Test $left, Test $right) => $this->cmpSize($left, $right),
|
|
);
|
|
|
|
return $tests;
|
|
}
|
|
|
|
/**
|
|
* @param list<Test> $tests
|
|
* @return list<Test>
|
|
*/
|
|
private function sortBySizeDescending(array $tests): array
|
|
{
|
|
usort(
|
|
$tests,
|
|
fn (Test $left, Test $right) => $this->cmpSize($right, $left),
|
|
);
|
|
|
|
return $tests;
|
|
}
|
|
|
|
private function cmpDefectPriorityAndTime(Test $a, Test $b): int
|
|
{
|
|
assert($a instanceof Reorderable);
|
|
assert($b instanceof Reorderable);
|
|
|
|
$priorityA = $this->defectSortOrder[$a->sortId()] ?? 0;
|
|
$priorityB = $this->defectSortOrder[$b->sortId()] ?? 0;
|
|
|
|
return $priorityB <=> $priorityA;
|
|
}
|
|
|
|
private function cmpDuration(Test $a, Test $b): int
|
|
{
|
|
return $this->durationWeight($a) <=> $this->durationWeight($b);
|
|
}
|
|
|
|
private function durationWeight(Test $test): float
|
|
{
|
|
if ($test instanceof TestSuite) {
|
|
$sum = 0.0;
|
|
|
|
foreach ($test->tests() as $inner) {
|
|
$sum += $this->durationWeight($inner);
|
|
}
|
|
|
|
return $sum;
|
|
}
|
|
|
|
if ($test instanceof Reorderable) {
|
|
return $this->testRunHistory->time(TestRunHistoryId::fromReorderable($test));
|
|
}
|
|
|
|
return 0.0;
|
|
}
|
|
|
|
private function cmpSize(Test $a, Test $b): int
|
|
{
|
|
return $this->sizeWeight($a) <=> $this->sizeWeight($b);
|
|
}
|
|
|
|
/**
|
|
* @return positive-int
|
|
*/
|
|
private function sizeWeight(Test $test): int
|
|
{
|
|
if ($test instanceof TestCase || $test instanceof DataProviderTestSuite) {
|
|
return self::SIZE_SORT_WEIGHT[$test->size()->asString()];
|
|
}
|
|
|
|
if ($test instanceof TestSuite) {
|
|
$max = 0;
|
|
|
|
foreach ($test->tests() as $inner) {
|
|
$weight = $this->sizeWeight($inner);
|
|
|
|
if ($weight > $max) {
|
|
$max = $weight;
|
|
}
|
|
}
|
|
|
|
if ($max > 0) {
|
|
return $max;
|
|
}
|
|
}
|
|
|
|
return self::SIZE_SORT_WEIGHT['unknown'];
|
|
}
|
|
|
|
/**
|
|
* @param list<TestCase> $tests
|
|
* @return list<TestCase>
|
|
*/
|
|
private function resolveDependencies(array $tests): array
|
|
{
|
|
if (! $this->anyTestHasDependencies($tests)) {
|
|
return $tests;
|
|
}
|
|
|
|
$newTestOrder = [];
|
|
$i = 0;
|
|
$provided = [];
|
|
|
|
while ($tests !== [] && $i < count($tests)) {
|
|
if (array_diff($tests[$i]->requires(), $provided) === []) {
|
|
$provided = array_merge($provided, $tests[$i]->provides());
|
|
$newTestOrder = array_merge($newTestOrder, array_splice($tests, $i, 1));
|
|
$i = 0;
|
|
} else {
|
|
$i++;
|
|
}
|
|
}
|
|
|
|
return array_merge($newTestOrder, $tests);
|
|
}
|
|
|
|
/**
|
|
* @param iterable<Test> $tests
|
|
*/
|
|
private function anyTestHasDependencies(iterable $tests): bool
|
|
{
|
|
foreach ($tests as $test) {
|
|
if ($test instanceof TestSuite) {
|
|
if ($this->anyTestHasDependencies($test->tests())) {
|
|
return true;
|
|
}
|
|
|
|
continue;
|
|
}
|
|
|
|
if ($test instanceof TestCase && $test->requires() !== []) {
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
}
|