mirror of
https://github.com/pestphp/pest.git
synced 2026-04-21 06:27:28 +02:00
Compare commits
24 Commits
4.x
...
e63a886f98
| Author | SHA1 | Date | |
|---|---|---|---|
| e63a886f98 | |||
| 8dd650fd05 | |||
| fbca346d7c | |||
| 3f13bca0f7 | |||
| d3acb1c56a | |||
| e601e6df31 | |||
| 6fdbca1226 | |||
| 54359b895f | |||
| 44c04bfce1 | |||
| 271c680d3c | |||
| 4a1d8d27b8 | |||
| 0f6924984c | |||
| 668ca9f5de | |||
| f659a45311 | |||
| 12c1da29ee | |||
| fa27c8daef | |||
| f0a08f0503 | |||
| 2c040c5b1f | |||
| a9ce1fd739 | |||
| 3533356262 | |||
| 4aa41d0b14 | |||
| e4ed60085c | |||
| e2b119655d | |||
| fcf5baf0a9 |
21
.github/workflows/static.yml
vendored
21
.github/workflows/static.yml
vendored
@ -2,25 +2,21 @@ name: Static Analysis
|
||||
|
||||
on:
|
||||
push:
|
||||
branches: [4.x]
|
||||
branches: [5.x]
|
||||
pull_request:
|
||||
schedule:
|
||||
- cron: '0 9 * * *'
|
||||
- cron: '0 0 * * *'
|
||||
|
||||
concurrency:
|
||||
group: static-${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}
|
||||
cancel-in-progress: true
|
||||
|
||||
permissions:
|
||||
contents: read
|
||||
|
||||
jobs:
|
||||
static:
|
||||
if: github.event_name != 'schedule' || github.repository == 'pestphp/pest'
|
||||
name: Static Tests
|
||||
|
||||
runs-on: ubuntu-latest
|
||||
timeout-minutes: 15
|
||||
strategy:
|
||||
fail-fast: true
|
||||
matrix:
|
||||
@ -33,7 +29,7 @@ jobs:
|
||||
- name: Setup PHP
|
||||
uses: shivammathur/setup-php@v2
|
||||
with:
|
||||
php-version: 8.3
|
||||
php-version: 8.4
|
||||
tools: composer:v2
|
||||
coverage: none
|
||||
extensions: sockets
|
||||
@ -44,13 +40,13 @@ jobs:
|
||||
run: echo "dir=$(composer config cache-files-dir)" >> $GITHUB_OUTPUT
|
||||
|
||||
- name: Cache Composer dependencies
|
||||
uses: actions/cache@v5
|
||||
uses: actions/cache@v4
|
||||
with:
|
||||
path: ${{ steps.composer-cache.outputs.dir }}
|
||||
key: static-php-8.3-${{ matrix.dependency-version }}-composer-${{ hashFiles('**/composer.json', '**/composer.lock') }}
|
||||
key: static-php-8.4-${{ matrix.dependency-version }}-composer-${{ hashFiles('**/composer.json') }}
|
||||
restore-keys: |
|
||||
static-php-8.3-${{ matrix.dependency-version }}-composer-
|
||||
static-php-8.3-composer-
|
||||
static-php-8.4-${{ matrix.dependency-version }}-composer-
|
||||
static-php-8.4-composer-
|
||||
|
||||
- name: Install Dependencies
|
||||
run: composer update --${{ matrix.dependency-version }} --no-interaction --no-progress --ansi
|
||||
@ -64,5 +60,8 @@ jobs:
|
||||
- name: Type Coverage
|
||||
run: composer test:type:coverage
|
||||
|
||||
- name: Refacto
|
||||
run: composer test:refacto
|
||||
|
||||
- name: Style
|
||||
run: composer test:lint
|
||||
|
||||
19
.github/workflows/tests.yml
vendored
19
.github/workflows/tests.yml
vendored
@ -2,34 +2,25 @@ name: Tests
|
||||
|
||||
on:
|
||||
push:
|
||||
branches: [4.x]
|
||||
branches: [5.x]
|
||||
pull_request:
|
||||
schedule:
|
||||
- cron: '0 9 * * *'
|
||||
|
||||
concurrency:
|
||||
group: tests-${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}
|
||||
cancel-in-progress: true
|
||||
|
||||
permissions:
|
||||
contents: read
|
||||
|
||||
jobs:
|
||||
tests:
|
||||
if: github.event_name != 'schedule' || github.repository == 'pestphp/pest'
|
||||
|
||||
runs-on: ${{ matrix.os }}
|
||||
timeout-minutes: 15
|
||||
strategy:
|
||||
fail-fast: true
|
||||
matrix:
|
||||
os: [ubuntu-latest, macos-latest] # windows-latest
|
||||
symfony: ['7.4', '8.0']
|
||||
php: ['8.3', '8.4', '8.5']
|
||||
symfony: ['8.0']
|
||||
php: ['8.4', '8.5']
|
||||
dependency_version: [prefer-stable]
|
||||
exclude:
|
||||
- php: '8.3'
|
||||
symfony: '8.0'
|
||||
|
||||
name: PHP ${{ matrix.php }} - Symfony ^${{ matrix.symfony }} - ${{ matrix.os }} - ${{ matrix.dependency_version }}
|
||||
|
||||
@ -51,10 +42,10 @@ jobs:
|
||||
run: echo "dir=$(composer config cache-files-dir)" >> $GITHUB_OUTPUT
|
||||
|
||||
- name: Cache Composer dependencies
|
||||
uses: actions/cache@v5
|
||||
uses: actions/cache@v4
|
||||
with:
|
||||
path: ${{ steps.composer-cache.outputs.dir }}
|
||||
key: ${{ matrix.os }}-php-${{ matrix.php }}-symfony-${{ matrix.symfony }}-composer-${{ hashFiles('**/composer.json', '**/composer.lock') }}
|
||||
key: ${{ matrix.os }}-php-${{ matrix.php }}-symfony-${{ matrix.symfony }}-composer-${{ hashFiles('**/composer.json') }}
|
||||
restore-keys: |
|
||||
${{ matrix.os }}-php-${{ matrix.php }}-symfony-${{ matrix.symfony }}-composer-
|
||||
${{ matrix.os }}-php-${{ matrix.php }}-composer-
|
||||
|
||||
11
bin/pest
11
bin/pest
@ -10,7 +10,6 @@ use Pest\TestCaseMethodFilters\AssigneeTestCaseFilter;
|
||||
use Pest\TestCaseMethodFilters\IssueTestCaseFilter;
|
||||
use Pest\TestCaseMethodFilters\NotesTestCaseFilter;
|
||||
use Pest\TestCaseMethodFilters\PrTestCaseFilter;
|
||||
use Pest\TestCaseMethodFilters\FlakyTestCaseFilter;
|
||||
use Pest\TestCaseMethodFilters\TodoTestCaseFilter;
|
||||
use Pest\TestSuite;
|
||||
use Symfony\Component\Console\Input\ArgvInput;
|
||||
@ -24,7 +23,6 @@ use Symfony\Component\Console\Output\ConsoleOutput;
|
||||
|
||||
$dirty = false;
|
||||
$todo = false;
|
||||
$flaky = false;
|
||||
$notes = false;
|
||||
|
||||
foreach ($arguments as $key => $value) {
|
||||
@ -59,11 +57,6 @@ use Symfony\Component\Console\Output\ConsoleOutput;
|
||||
unset($arguments[$key]);
|
||||
}
|
||||
|
||||
if ($value === '--flaky') {
|
||||
$flaky = true;
|
||||
unset($arguments[$key]);
|
||||
}
|
||||
|
||||
if ($value === '--notes') {
|
||||
$notes = true;
|
||||
unset($arguments[$key]);
|
||||
@ -157,10 +150,6 @@ use Symfony\Component\Console\Output\ConsoleOutput;
|
||||
$testSuite->tests->addTestCaseMethodFilter(new TodoTestCaseFilter);
|
||||
}
|
||||
|
||||
if ($flaky) {
|
||||
$testSuite->tests->addTestCaseMethodFilter(new FlakyTestCaseFilter);
|
||||
}
|
||||
|
||||
if ($notes) {
|
||||
$testSuite->tests->addTestCaseMethodFilter(new NotesTestCaseFilter);
|
||||
}
|
||||
|
||||
@ -17,20 +17,20 @@
|
||||
}
|
||||
],
|
||||
"require": {
|
||||
"php": "^8.3.0",
|
||||
"brianium/paratest": "^7.20.0",
|
||||
"php": "^8.4",
|
||||
"brianium/paratest": "^7.22.1",
|
||||
"nunomaduro/collision": "^8.9.3",
|
||||
"nunomaduro/termwind": "^2.4.0",
|
||||
"pestphp/pest-plugin": "^4.0.0",
|
||||
"pestphp/pest-plugin-arch": "^4.0.2",
|
||||
"pestphp/pest-plugin-mutate": "^4.0.1",
|
||||
"pestphp/pest-plugin-profanity": "^4.2.1",
|
||||
"phpunit/phpunit": "^12.5.23",
|
||||
"symfony/process": "^7.4.8|^8.0.8"
|
||||
"pestphp/pest-plugin": "^5.0.0",
|
||||
"pestphp/pest-plugin-arch": "^5.0.0",
|
||||
"pestphp/pest-plugin-mutate": "^5.0.0",
|
||||
"pestphp/pest-plugin-profanity": "^5.0.0",
|
||||
"phpunit/phpunit": "^13.1.0",
|
||||
"symfony/process": "^8.1.0"
|
||||
},
|
||||
"conflict": {
|
||||
"filp/whoops": "<2.18.3",
|
||||
"phpunit/phpunit": ">12.5.23",
|
||||
"phpunit/phpunit": ">13.1.0",
|
||||
"sebastian/exporter": "<7.0.0",
|
||||
"webmozart/assert": "<1.11.0"
|
||||
},
|
||||
@ -50,18 +50,15 @@
|
||||
"Tests\\Fixtures\\Arch\\": "tests/Fixtures/Arch",
|
||||
"Tests\\": "tests/PHPUnit/"
|
||||
},
|
||||
"classmap": [
|
||||
"tests/Fixtures/Arch/ToBeCasedCorrectly/IncorrectCasing/incorrectCasing.php"
|
||||
],
|
||||
"files": [
|
||||
"tests/Autoload.php"
|
||||
]
|
||||
},
|
||||
"require-dev": {
|
||||
"mrpunyapal/peststan": "^0.2.5",
|
||||
"pestphp/pest-dev-tools": "^4.1.0",
|
||||
"pestphp/pest-plugin-browser": "^4.3.1",
|
||||
"pestphp/pest-plugin-type-coverage": "^4.0.4",
|
||||
"nunomaduro/pao": "0.x-dev",
|
||||
"pestphp/pest-dev-tools": "^5.0.0",
|
||||
"pestphp/pest-plugin-browser": "^5.0.0",
|
||||
"pestphp/pest-plugin-type-coverage": "^5.0.0",
|
||||
"psy/psysh": "^0.12.22"
|
||||
},
|
||||
"minimum-stability": "dev",
|
||||
@ -77,14 +74,10 @@
|
||||
"bin/pest"
|
||||
],
|
||||
"scripts": {
|
||||
"lint": [
|
||||
"rector",
|
||||
"pint --parallel"
|
||||
],
|
||||
"test:lint": [
|
||||
"rector --dry-run",
|
||||
"pint --parallel --test"
|
||||
],
|
||||
"refacto": "rector",
|
||||
"lint": "pint --parallel",
|
||||
"test:refacto": "rector --dry-run",
|
||||
"test:lint": "pint --parallel --test",
|
||||
"test:profanity": "php bin/pest --profanity --compact",
|
||||
"test:type:check": "phpstan analyse --ansi --memory-limit=-1 --debug",
|
||||
"test:type:coverage": "php -d memory_limit=-1 bin/pest --type-coverage --min=100",
|
||||
@ -94,6 +87,7 @@
|
||||
"test:integration": "php bin/pest --group=integration -v",
|
||||
"update:snapshots": "REBUILD_SNAPSHOTS=true php bin/pest --update-snapshots",
|
||||
"test": [
|
||||
"@test:refacto",
|
||||
"@test:lint",
|
||||
"@test:type:check",
|
||||
"@test:type:coverage",
|
||||
|
||||
@ -1,39 +1,6 @@
|
||||
<?php
|
||||
|
||||
/*
|
||||
* BSD 3-Clause License
|
||||
*
|
||||
* Copyright (c) 2001-2023, Sebastian Bergmann
|
||||
* All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions are met:
|
||||
*
|
||||
* 1. Redistributions of source code must retain the above copyright notice, this
|
||||
* list of conditions and the following disclaimer.
|
||||
*
|
||||
* 2. Redistributions in binary form must reproduce the above copyright notice,
|
||||
* this list of conditions and the following disclaimer in the documentation
|
||||
* and/or other materials provided with the distribution.
|
||||
*
|
||||
* 3. Neither the name of the copyright holder nor the names of its
|
||||
* contributors may be used to endorse or promote products derived from
|
||||
* this software without specific prior written permission.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
|
||||
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
|
||||
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
|
||||
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
||||
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
|
||||
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
|
||||
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
|
||||
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
declare(strict_types=1);
|
||||
|
||||
/*
|
||||
* This file is part of PHPUnit.
|
||||
*
|
||||
|
||||
@ -1,388 +0,0 @@
|
||||
<?php
|
||||
|
||||
/*
|
||||
* BSD 3-Clause License
|
||||
*
|
||||
* Copyright (c) 2001-2023, Sebastian Bergmann
|
||||
* All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions are met:
|
||||
*
|
||||
* 1. Redistributions of source code must retain the above copyright notice, this
|
||||
* list of conditions and the following disclaimer.
|
||||
*
|
||||
* 2. Redistributions in binary form must reproduce the above copyright notice,
|
||||
* this list of conditions and the following disclaimer in the documentation
|
||||
* and/or other materials provided with the distribution.
|
||||
*
|
||||
* 3. Neither the name of the copyright holder nor the names of its
|
||||
* contributors may be used to endorse or promote products derived from
|
||||
* this software without specific prior written permission.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
|
||||
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
|
||||
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
|
||||
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
||||
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
|
||||
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
|
||||
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
|
||||
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
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\Reorderable;
|
||||
use PHPUnit\Framework\Test;
|
||||
use PHPUnit\Framework\TestCase;
|
||||
use PHPUnit\Framework\TestSuite;
|
||||
use PHPUnit\Runner\ResultCache\NullResultCache;
|
||||
use PHPUnit\Runner\ResultCache\ResultCache;
|
||||
use PHPUnit\Runner\ResultCache\ResultCacheId;
|
||||
|
||||
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 = 4;
|
||||
|
||||
public const int ORDER_SIZE = 5;
|
||||
|
||||
/**
|
||||
* @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 ResultCache $cache;
|
||||
|
||||
public function __construct(?ResultCache $cache = null)
|
||||
{
|
||||
$this->cache = $cache ?? new NullResultCache;
|
||||
}
|
||||
|
||||
/**
|
||||
* @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,
|
||||
self::ORDER_SIZE,
|
||||
];
|
||||
|
||||
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 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
|
||||
{
|
||||
if ($suite->tests() === []) {
|
||||
return;
|
||||
}
|
||||
|
||||
if ($order === self::ORDER_REVERSED) {
|
||||
$suite->setTests($this->reverse($suite->tests()));
|
||||
} elseif ($order === self::ORDER_RANDOMIZED) {
|
||||
$suite->setTests($this->randomize($suite->tests()));
|
||||
} elseif ($order === self::ORDER_DURATION) {
|
||||
$suite->setTests($this->sortByDuration($suite->tests()));
|
||||
} elseif ($order === self::ORDER_SIZE) {
|
||||
$suite->setTests($this->sortBySize($suite->tests()));
|
||||
}
|
||||
|
||||
if ($orderDefects === self::ORDER_DEFECTS_FIRST) {
|
||||
$suite->setTests($this->sortDefectsFirst($suite->tests()));
|
||||
}
|
||||
|
||||
if ($resolveDependencies && ! ($suite instanceof DataProviderTestSuite)) {
|
||||
$tests = $suite->tests();
|
||||
|
||||
/** @noinspection PhpParamsInspection */
|
||||
/** @phpstan-ignore argument.type */
|
||||
$suite->setTests($this->resolveDependencies($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->cache->status(ResultCacheId::fromReorderable($test))->asInt();
|
||||
$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 sortBySize(array $tests): array
|
||||
{
|
||||
usort(
|
||||
$tests,
|
||||
fn (Test $left, Test $right) => $this->cmpSize($left, $right),
|
||||
);
|
||||
|
||||
return $tests;
|
||||
}
|
||||
|
||||
/**
|
||||
* Comparator callback function to sort tests for "reach failure as fast as possible".
|
||||
*
|
||||
* 1. sort tests by defect weight defined in self::DEFECT_SORT_WEIGHT
|
||||
* 2. when tests are equally defective, sort the fastest to the front
|
||||
* 3. do not reorder successful 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;
|
||||
|
||||
if ($priorityA !== $priorityB) {
|
||||
// Sort defect weight descending
|
||||
return $priorityB <=> $priorityA;
|
||||
}
|
||||
|
||||
if ($priorityA > 0 || $priorityB > 0) {
|
||||
return $this->cmpDuration($a, $b);
|
||||
}
|
||||
|
||||
// do not change execution order
|
||||
return 0;
|
||||
}
|
||||
|
||||
/**
|
||||
* Compares test duration for sorting tests by duration ascending.
|
||||
*/
|
||||
private function cmpDuration(Test $a, Test $b): int
|
||||
{
|
||||
if (! ($a instanceof Reorderable && $b instanceof Reorderable)) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
return $this->cache->time(ResultCacheId::fromReorderable($a)) <=> $this->cache->time(ResultCacheId::fromReorderable($b));
|
||||
}
|
||||
|
||||
/**
|
||||
* Compares test size for sorting tests small->medium->large->unknown.
|
||||
*/
|
||||
private function cmpSize(Test $a, Test $b): int
|
||||
{
|
||||
$sizeA = ($a instanceof TestCase || $a instanceof DataProviderTestSuite)
|
||||
? $a->size()->asString()
|
||||
: 'unknown';
|
||||
$sizeB = ($b instanceof TestCase || $b instanceof DataProviderTestSuite)
|
||||
? $b->size()->asString()
|
||||
: 'unknown';
|
||||
|
||||
return self::SIZE_SORT_WEIGHT[$sizeA] <=> self::SIZE_SORT_WEIGHT[$sizeB];
|
||||
}
|
||||
|
||||
/**
|
||||
* Reorder Tests within a TestCase in such a way as to resolve as many dependencies as possible.
|
||||
* The algorithm will leave the tests in original running order when it can.
|
||||
* For more details see the documentation for test dependencies.
|
||||
*
|
||||
* Short description of algorithm:
|
||||
* 1. Pick the next Test from remaining tests to be checked for dependencies.
|
||||
* 2. If the test has no dependencies: mark done, start again from the top
|
||||
* 3. If the test has dependencies but none left to do: mark done, start again from the top
|
||||
* 4. When we reach the end add any leftover tests to the end. These will be marked 'skipped' during execution.
|
||||
*
|
||||
* @param array<TestCase> $tests
|
||||
* @return array<TestCase>
|
||||
*/
|
||||
private function resolveDependencies(array $tests): array
|
||||
{
|
||||
// Pest: Fast-path. If no test in this suite declares dependencies, the
|
||||
// original O(N^2) algorithm is wasted work — it would splice each test
|
||||
// one-by-one back into the same order. The check deliberately walks
|
||||
// TestCase instances directly instead of calling TestSuite::requires(),
|
||||
// because the latter lazily builds TestSuite::provides() via
|
||||
// ExecutionOrderDependency::mergeUnique, which is O(N^2) in the total
|
||||
// number of tests. With thousands of tests that single call alone can
|
||||
// burn several seconds before the sort even begins. Reading the
|
||||
// cached TestCase::$dependencies property stays O(N) and costs nothing
|
||||
// when no test uses `->depends()` / PHPUnit `@depends`.
|
||||
if (! $this->anyTestHasDependencies($tests)) {
|
||||
return $tests;
|
||||
}
|
||||
|
||||
$newTestOrder = [];
|
||||
$i = 0;
|
||||
$provided = [];
|
||||
|
||||
do {
|
||||
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++;
|
||||
}
|
||||
} while ($tests !== [] && ($i < count($tests)));
|
||||
|
||||
return array_merge($newTestOrder, $tests);
|
||||
}
|
||||
|
||||
/**
|
||||
* Cheaply determines whether any test in the tree declares @depends.
|
||||
*
|
||||
* Walks `TestSuite` containers recursively and inspects each `TestCase`
|
||||
* directly so it never triggers `TestSuite::provides()`, which is O(N^2)
|
||||
* in the total number of aggregated 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;
|
||||
}
|
||||
}
|
||||
@ -1,5 +1,11 @@
|
||||
parameters:
|
||||
ignoreErrors:
|
||||
-
|
||||
message: '#^Parameter \#1 of callable callable\(Pest\\Expectation\<string\|null\>\)\: Pest\\Arch\\Contracts\\ArchExpectation expects Pest\\Expectation\<string\|null\>, Pest\\Expectation\<string\|null\> given\.$#'
|
||||
identifier: argument.type
|
||||
count: 1
|
||||
path: src/ArchPresets/AbstractPreset.php
|
||||
|
||||
-
|
||||
message: '#^Trait Pest\\Concerns\\Expectable is used zero times and is not analysed\.$#'
|
||||
identifier: trait.unused
|
||||
@ -18,6 +24,12 @@ parameters:
|
||||
count: 1
|
||||
path: src/Concerns/Testable.php
|
||||
|
||||
-
|
||||
message: '#^Loose comparison using \!\= between \(Closure\|null\) and false will always evaluate to false\.$#'
|
||||
identifier: notEqual.alwaysFalse
|
||||
count: 1
|
||||
path: src/Expectation.php
|
||||
|
||||
-
|
||||
message: '#^Method Pest\\Expectation\:\:and\(\) should return Pest\\Expectation\<TAndValue\> but returns \(Pest\\Expectation&TAndValue\)\|Pest\\Expectation\<TAndValue of mixed\>\.$#'
|
||||
identifier: return.type
|
||||
@ -90,12 +102,78 @@ parameters:
|
||||
count: 1
|
||||
path: src/PendingCalls/TestCall.php
|
||||
|
||||
-
|
||||
message: '#^Parameter \#1 \$argv of class Symfony\\Component\\Console\\Input\\ArgvInput constructor expects list\<string\>\|null, array\<int, string\> given\.$#'
|
||||
identifier: argument.type
|
||||
count: 1
|
||||
path: src/Plugins/Parallel.php
|
||||
|
||||
-
|
||||
message: '#^Parameter \#13 \$testRunnerTriggeredDeprecationEvents of class PHPUnit\\TestRunner\\TestResult\\TestResult constructor expects list\<PHPUnit\\Event\\TestRunner\\DeprecationTriggered\>, array given\.$#'
|
||||
identifier: argument.type
|
||||
count: 1
|
||||
path: src/Plugins/Parallel/Paratest/WrapperRunner.php
|
||||
|
||||
-
|
||||
message: '#^Parameter \#14 \$testRunnerTriggeredWarningEvents of class PHPUnit\\TestRunner\\TestResult\\TestResult constructor expects list\<PHPUnit\\Event\\TestRunner\\WarningTriggered\>, array given\.$#'
|
||||
identifier: argument.type
|
||||
count: 1
|
||||
path: src/Plugins/Parallel/Paratest/WrapperRunner.php
|
||||
|
||||
-
|
||||
message: '#^Parameter \#15 \$errors of class PHPUnit\\TestRunner\\TestResult\\TestResult constructor expects list\<PHPUnit\\TestRunner\\TestResult\\Issues\\Issue\>, array given\.$#'
|
||||
identifier: argument.type
|
||||
count: 1
|
||||
path: src/Plugins/Parallel/Paratest/WrapperRunner.php
|
||||
|
||||
-
|
||||
message: '#^Parameter \#16 \$deprecations of class PHPUnit\\TestRunner\\TestResult\\TestResult constructor expects list\<PHPUnit\\TestRunner\\TestResult\\Issues\\Issue\>, array given\.$#'
|
||||
identifier: argument.type
|
||||
count: 1
|
||||
path: src/Plugins/Parallel/Paratest/WrapperRunner.php
|
||||
|
||||
-
|
||||
message: '#^Parameter \#17 \$notices of class PHPUnit\\TestRunner\\TestResult\\TestResult constructor expects list\<PHPUnit\\TestRunner\\TestResult\\Issues\\Issue\>, array given\.$#'
|
||||
identifier: argument.type
|
||||
count: 1
|
||||
path: src/Plugins/Parallel/Paratest/WrapperRunner.php
|
||||
|
||||
-
|
||||
message: '#^Parameter \#18 \$warnings of class PHPUnit\\TestRunner\\TestResult\\TestResult constructor expects list\<PHPUnit\\TestRunner\\TestResult\\Issues\\Issue\>, array given\.$#'
|
||||
identifier: argument.type
|
||||
count: 1
|
||||
path: src/Plugins/Parallel/Paratest/WrapperRunner.php
|
||||
|
||||
-
|
||||
message: '#^Parameter \#19 \$phpDeprecations of class PHPUnit\\TestRunner\\TestResult\\TestResult constructor expects list\<PHPUnit\\TestRunner\\TestResult\\Issues\\Issue\>, array given\.$#'
|
||||
identifier: argument.type
|
||||
count: 1
|
||||
path: src/Plugins/Parallel/Paratest/WrapperRunner.php
|
||||
|
||||
-
|
||||
message: '#^Parameter \#20 \$phpNotices of class PHPUnit\\TestRunner\\TestResult\\TestResult constructor expects list\<PHPUnit\\TestRunner\\TestResult\\Issues\\Issue\>, array given\.$#'
|
||||
identifier: argument.type
|
||||
count: 1
|
||||
path: src/Plugins/Parallel/Paratest/WrapperRunner.php
|
||||
|
||||
-
|
||||
message: '#^Parameter \#21 \$phpWarnings of class PHPUnit\\TestRunner\\TestResult\\TestResult constructor expects list\<PHPUnit\\TestRunner\\TestResult\\Issues\\Issue\>, array given\.$#'
|
||||
identifier: argument.type
|
||||
count: 1
|
||||
path: src/Plugins/Parallel/Paratest/WrapperRunner.php
|
||||
|
||||
-
|
||||
message: '#^Parameter \#4 \$testErroredEvents of class PHPUnit\\TestRunner\\TestResult\\TestResult constructor expects list\<PHPUnit\\Event\\Test\\AfterLastTestMethodErrored\|PHPUnit\\Event\\Test\\BeforeFirstTestMethodErrored\|PHPUnit\\Event\\Test\\Errored\>, array given\.$#'
|
||||
identifier: argument.type
|
||||
count: 1
|
||||
path: src/Plugins/Parallel/Paratest/WrapperRunner.php
|
||||
|
||||
-
|
||||
message: '#^Parameter \#5 \$testFailedEvents of class PHPUnit\\TestRunner\\TestResult\\TestResult constructor expects list\<PHPUnit\\Event\\Test\\Failed\>, array given\.$#'
|
||||
identifier: argument.type
|
||||
count: 1
|
||||
path: src/Plugins/Parallel/Paratest/WrapperRunner.php
|
||||
|
||||
-
|
||||
message: '#^Parameter \#7 \$testSuiteSkippedEvents of class PHPUnit\\TestRunner\\TestResult\\TestResult constructor expects list\<PHPUnit\\Event\\TestSuite\\Skipped\>, array given\.$#'
|
||||
identifier: argument.type
|
||||
|
||||
@ -1,5 +0,0 @@
|
||||
services:
|
||||
-
|
||||
class: Pest\PHPStan\HigherOrderExpectationTypeExtension
|
||||
tags:
|
||||
- phpstan.broker.expressionTypeResolverExtension
|
||||
@ -1,7 +1,5 @@
|
||||
includes:
|
||||
- phpstan-baseline.neon
|
||||
- phpstan-pest-extension.neon
|
||||
- vendor/mrpunyapal/peststan/extension.neon
|
||||
|
||||
parameters:
|
||||
level: 7
|
||||
@ -9,3 +7,6 @@ parameters:
|
||||
- src
|
||||
|
||||
reportUnmatchedIgnoredErrors: false
|
||||
|
||||
ignoreErrors:
|
||||
- "#type mixed is not subtype of native#"
|
||||
|
||||
@ -53,7 +53,7 @@ abstract class AbstractPreset // @pest-arch-ignore-line
|
||||
/**
|
||||
* Runs the given callback for each namespace.
|
||||
*
|
||||
* @param callable(Expectation<string>): ArchExpectation ...$callbacks
|
||||
* @param callable(Expectation<string|null>): ArchExpectation ...$callbacks
|
||||
*/
|
||||
final public function eachUserNamespace(callable ...$callbacks): void
|
||||
{
|
||||
|
||||
@ -69,7 +69,6 @@ final class Laravel extends AbstractPreset
|
||||
->toHaveSuffix('Request');
|
||||
|
||||
$this->expectations[] = expect('App\Http\Requests')
|
||||
->classes()
|
||||
->toExtend('Illuminate\Foundation\Http\FormRequest');
|
||||
|
||||
$this->expectations[] = expect('App\Http\Requests')
|
||||
@ -119,7 +118,6 @@ final class Laravel extends AbstractPreset
|
||||
->toHaveMethod('handle');
|
||||
|
||||
$this->expectations[] = expect('App\Notifications')
|
||||
->classes()
|
||||
->toExtend('Illuminate\Notifications\Notification');
|
||||
|
||||
$this->expectations[] = expect('App')
|
||||
@ -130,7 +128,6 @@ final class Laravel extends AbstractPreset
|
||||
->toHaveSuffix('ServiceProvider');
|
||||
|
||||
$this->expectations[] = expect('App\Providers')
|
||||
->classes()
|
||||
->toExtend('Illuminate\Support\ServiceProvider');
|
||||
|
||||
$this->expectations[] = expect('App\Providers')
|
||||
|
||||
@ -21,7 +21,6 @@ final class BootOverrides implements Bootstrapper
|
||||
'Runner/Filter/NameFilterIterator.php',
|
||||
'Runner/ResultCache/DefaultResultCache.php',
|
||||
'Runner/TestSuiteLoader.php',
|
||||
'Runner/TestSuiteSorter.php',
|
||||
'TextUI/Command/Commands/WarmCodeCoverageCacheCommand.php',
|
||||
'TextUI/Output/Default/ProgressPrinter/Subscriber/TestSkippedSubscriber.php',
|
||||
'TextUI/TestSuiteFilterProcessor.php',
|
||||
|
||||
@ -14,8 +14,6 @@ use Pest\Support\Reflection;
|
||||
use Pest\Support\Shell;
|
||||
use Pest\TestSuite;
|
||||
use PHPUnit\Framework\Attributes\PostCondition;
|
||||
use PHPUnit\Framework\IncompleteTest;
|
||||
use PHPUnit\Framework\SkippedTest;
|
||||
use PHPUnit\Framework\TestCase;
|
||||
use ReflectionException;
|
||||
use ReflectionFunction;
|
||||
@ -330,80 +328,7 @@ trait Testable
|
||||
$arguments = $this->__resolveTestArguments($args);
|
||||
$this->__ensureDatasetArgumentNameAndNumberMatches($arguments);
|
||||
|
||||
$method = TestSuite::getInstance()->tests->get(self::$__filename)->getMethod($this->name());
|
||||
|
||||
if ($method->flakyTries === null) {
|
||||
return $this->__callClosure($closure, $arguments);
|
||||
}
|
||||
|
||||
$lastException = null;
|
||||
$initialProperties = get_object_vars($this);
|
||||
|
||||
for ($attempt = 1; $attempt <= $method->flakyTries; $attempt++) {
|
||||
try {
|
||||
return $this->__callClosure($closure, $arguments);
|
||||
} catch (Throwable $e) {
|
||||
if ($e instanceof SkippedTest
|
||||
|| $e instanceof IncompleteTest
|
||||
|| $this->__isExpectedException($e)) {
|
||||
throw $e;
|
||||
}
|
||||
|
||||
$lastException = $e;
|
||||
|
||||
if ($attempt < $method->flakyTries) {
|
||||
if ($this->__snapshotChanges !== []) {
|
||||
throw $e;
|
||||
}
|
||||
|
||||
$this->tearDown();
|
||||
|
||||
Closure::bind(fn (): array => $this->mockObjects = [], $this, TestCase::class)();
|
||||
|
||||
foreach (array_keys(array_diff_key(get_object_vars($this), $initialProperties)) as $property) {
|
||||
unset($this->{$property});
|
||||
}
|
||||
|
||||
$hasOutputExpectation = Closure::bind(fn (): bool => is_string($this->outputExpectedString) || is_string($this->outputExpectedRegex), $this, TestCase::class)();
|
||||
|
||||
if ($hasOutputExpectation) {
|
||||
ob_clean();
|
||||
}
|
||||
|
||||
$this->setUp();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
throw $lastException;
|
||||
}
|
||||
|
||||
/**
|
||||
* Determines if the given exception matches PHPUnit's expected exception.
|
||||
*/
|
||||
private function __isExpectedException(Throwable $e): bool
|
||||
{
|
||||
$read = fn (string $property): mixed => Closure::bind(fn () => $this->{$property}, $this, TestCase::class)();
|
||||
|
||||
$expectedClass = $read('expectedException');
|
||||
|
||||
if ($expectedClass !== null) {
|
||||
return $e instanceof $expectedClass;
|
||||
}
|
||||
|
||||
$expectedMessage = $read('expectedExceptionMessage');
|
||||
|
||||
if ($expectedMessage !== null) {
|
||||
return str_contains($e->getMessage(), (string) $expectedMessage);
|
||||
}
|
||||
|
||||
$expectedCode = $read('expectedExceptionCode');
|
||||
|
||||
if ($expectedCode !== null) {
|
||||
return $e->getCode() === $expectedCode;
|
||||
}
|
||||
|
||||
return false;
|
||||
return $this->__callClosure($closure, $arguments);
|
||||
}
|
||||
|
||||
/**
|
||||
@ -425,8 +350,7 @@ trait Testable
|
||||
}
|
||||
|
||||
$underlyingTest = Reflection::getFunctionVariable($this->__test, 'closure');
|
||||
$testParameterTypesByName = Reflection::getFunctionArguments($underlyingTest);
|
||||
$testParameterTypes = array_values($testParameterTypesByName);
|
||||
$testParameterTypes = array_values(Reflection::getFunctionArguments($underlyingTest));
|
||||
|
||||
if (count($arguments) !== 1) {
|
||||
foreach ($arguments as $argumentIndex => $argumentValue) {
|
||||
@ -434,11 +358,7 @@ trait Testable
|
||||
continue;
|
||||
}
|
||||
|
||||
$parameterType = is_string($argumentIndex)
|
||||
? $testParameterTypesByName[$argumentIndex]
|
||||
: $testParameterTypes[$argumentIndex];
|
||||
|
||||
if (in_array($parameterType, [Closure::class, 'callable', 'mixed'])) {
|
||||
if (in_array($testParameterTypes[$argumentIndex], [Closure::class, 'callable', 'mixed'])) {
|
||||
continue;
|
||||
}
|
||||
|
||||
@ -464,7 +384,7 @@ trait Testable
|
||||
return [$boundDatasetResult];
|
||||
}
|
||||
|
||||
return $boundDatasetResult;
|
||||
return array_values($boundDatasetResult);
|
||||
}
|
||||
|
||||
/**
|
||||
|
||||
@ -33,7 +33,7 @@ final readonly class Configuration
|
||||
*/
|
||||
public function in(string ...$targets): UsesCall
|
||||
{
|
||||
return (new UsesCall($this->filename, []))->in(...$targets);
|
||||
return new UsesCall($this->filename, [])->in(...$targets);
|
||||
}
|
||||
|
||||
/**
|
||||
@ -60,7 +60,7 @@ final readonly class Configuration
|
||||
*/
|
||||
public function group(string ...$groups): UsesCall
|
||||
{
|
||||
return (new UsesCall($this->filename, []))->group(...$groups);
|
||||
return new UsesCall($this->filename, [])->group(...$groups);
|
||||
}
|
||||
|
||||
/**
|
||||
@ -68,7 +68,7 @@ final readonly class Configuration
|
||||
*/
|
||||
public function only(): void
|
||||
{
|
||||
(new BeforeEachCall(TestSuite::getInstance(), $this->filename))->only();
|
||||
new BeforeEachCall(TestSuite::getInstance(), $this->filename)->only();
|
||||
}
|
||||
|
||||
/**
|
||||
|
||||
@ -18,7 +18,6 @@ use Pest\Arch\Expectations\ToOnlyUse;
|
||||
use Pest\Arch\Expectations\ToUse;
|
||||
use Pest\Arch\Expectations\ToUseNothing;
|
||||
use Pest\Arch\PendingArchExpectation;
|
||||
use Pest\Arch\Support\Composer;
|
||||
use Pest\Arch\Support\FileLineFinder;
|
||||
use Pest\Concerns\Extendable;
|
||||
use Pest\Concerns\Pipeable;
|
||||
@ -238,7 +237,7 @@ final class Expectation
|
||||
if ($callbacks[$index] instanceof Closure) {
|
||||
$callbacks[$index](new self($value), new self($key));
|
||||
} else {
|
||||
(new self($value))->toEqual($callbacks[$index]);
|
||||
new self($value)->toEqual($callbacks[$index]);
|
||||
}
|
||||
|
||||
$index = isset($callbacks[$index + 1]) ? $index + 1 : 0;
|
||||
@ -670,41 +669,6 @@ final class Expectation
|
||||
throw InvalidExpectation::fromMethods(['toHavePrivateMethods']);
|
||||
}
|
||||
|
||||
/**
|
||||
* Asserts that the given expectation target is cased correctly.
|
||||
*/
|
||||
public function toBeCasedCorrectly(): ArchExpectation
|
||||
{
|
||||
return Targeted::make(
|
||||
$this,
|
||||
function (ObjectDescription $object): bool {
|
||||
if (! isset($object->reflectionClass)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
$realPath = realpath($object->path);
|
||||
|
||||
if ($realPath === false) {
|
||||
return false;
|
||||
}
|
||||
|
||||
foreach (Composer::allNamespacesWithDirectories() as $directory => $namespace) {
|
||||
if (str_starts_with($realPath, $directory)) {
|
||||
$relativePath = substr($realPath, strlen($directory) + 1);
|
||||
$relativePath = explode('.', $relativePath)[0];
|
||||
$classFromPath = $namespace.'\\'.str_replace(DIRECTORY_SEPARATOR, '\\', $relativePath);
|
||||
|
||||
return $classFromPath === $object->reflectionClass->getName();
|
||||
}
|
||||
}
|
||||
|
||||
return false;
|
||||
},
|
||||
'to be cased correctly',
|
||||
FileLineFinder::where(fn (string $line): bool => str_contains($line, 'class')),
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* Asserts that the given expectation target is enum.
|
||||
*/
|
||||
@ -819,22 +783,7 @@ final class Expectation
|
||||
return false;
|
||||
}
|
||||
|
||||
$currentClass = $object->reflectionClass;
|
||||
$usedTraits = [];
|
||||
|
||||
do {
|
||||
$classTraits = $currentClass->getTraits();
|
||||
foreach ($classTraits as $traitReflection) {
|
||||
$usedTraits[$traitReflection->getName()] = $traitReflection->getName();
|
||||
|
||||
$nestedTraits = $traitReflection->getTraits();
|
||||
foreach ($nestedTraits as $nestedTrait) {
|
||||
$usedTraits[$nestedTrait->getName()] = $nestedTrait->getName();
|
||||
}
|
||||
}
|
||||
} while ($currentClass = $currentClass->getParentClass());
|
||||
|
||||
if (! array_key_exists($trait, $usedTraits)) {
|
||||
if (! in_array($trait, $object->reflectionClass->getTraitNames(), true)) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
@ -915,15 +864,7 @@ final class Expectation
|
||||
|
||||
return Targeted::make(
|
||||
$this,
|
||||
function (ObjectDescription $object) use ($interfaces): bool {
|
||||
foreach ($interfaces as $interface) {
|
||||
if (! isset($object->reflectionClass) || ! $object->reflectionClass->implementsInterface($interface)) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
return true;
|
||||
},
|
||||
fn (ObjectDescription $object): bool => array_all($interfaces, fn (string $interface): bool => isset($object->reflectionClass) && $object->reflectionClass->implementsInterface($interface)),
|
||||
"to implement '".implode("', '", $interfaces)."'",
|
||||
FileLineFinder::where(fn (string $line): bool => str_contains($line, 'class')),
|
||||
);
|
||||
@ -1138,8 +1079,8 @@ final class Expectation
|
||||
$this,
|
||||
fn (ObjectDescription $object): bool => isset($object->reflectionClass)
|
||||
&& $object->reflectionClass->isEnum()
|
||||
&& (new ReflectionEnum($object->name))->isBacked() // @phpstan-ignore-line
|
||||
&& (string) (new ReflectionEnum($object->name))->getBackingType() === $backingType, // @phpstan-ignore-line
|
||||
&& new ReflectionEnum($object->name)->isBacked() // @phpstan-ignore-line
|
||||
&& (string) new ReflectionEnum($object->name)->getBackingType() === $backingType, // @phpstan-ignore-line
|
||||
'to be '.$backingType.' backed enum',
|
||||
FileLineFinder::where(fn (string $line): bool => str_contains($line, 'class')),
|
||||
);
|
||||
|
||||
@ -576,15 +576,7 @@ final readonly class OppositeExpectation
|
||||
|
||||
return Targeted::make(
|
||||
$original,
|
||||
function (ObjectDescription $object) use ($traits): bool {
|
||||
foreach ($traits as $trait) {
|
||||
if (isset($object->reflectionClass) && in_array($trait, $object->reflectionClass->getTraitNames(), true)) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
return true;
|
||||
},
|
||||
fn (ObjectDescription $object): bool => array_all($traits, fn (string $trait): bool => ! (isset($object->reflectionClass) && in_array($trait, $object->reflectionClass->getTraitNames(), true))),
|
||||
"not to use traits '".implode("', '", $traits)."'",
|
||||
FileLineFinder::where(fn (string $line): bool => str_contains($line, 'class')),
|
||||
);
|
||||
@ -604,15 +596,7 @@ final readonly class OppositeExpectation
|
||||
|
||||
return Targeted::make(
|
||||
$original,
|
||||
function (ObjectDescription $object) use ($interfaces): bool {
|
||||
foreach ($interfaces as $interface) {
|
||||
if (isset($object->reflectionClass) && $object->reflectionClass->implementsInterface($interface)) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
return true;
|
||||
},
|
||||
fn (ObjectDescription $object): bool => array_all($interfaces, fn (string $interface): bool => ! (isset($object->reflectionClass) && $object->reflectionClass->implementsInterface($interface))),
|
||||
"not to implement '".implode("', '", $interfaces)."'",
|
||||
FileLineFinder::where(fn (string $line): bool => str_contains($line, 'class')),
|
||||
);
|
||||
@ -814,13 +798,11 @@ final readonly class OppositeExpectation
|
||||
|
||||
$exporter = Exporter::default();
|
||||
|
||||
$toString = fn (mixed $argument): string => $exporter->shortenedExport($argument);
|
||||
|
||||
throw new ExpectationFailedException(sprintf(
|
||||
'Expecting %s not %s %s.',
|
||||
$toString($this->original->value),
|
||||
$exporter->shortenedExport($this->original->value),
|
||||
strtolower((string) preg_replace('/(?<!\ )[A-Z]/', ' $0', $name)),
|
||||
implode(' ', array_map(fn (mixed $argument): string => $toString($argument), $arguments)),
|
||||
implode(' ', array_map(fn (mixed $argument): string => $exporter->export($argument), $arguments)),
|
||||
));
|
||||
}
|
||||
|
||||
@ -852,8 +834,8 @@ final readonly class OppositeExpectation
|
||||
$original,
|
||||
fn (ObjectDescription $object): bool => isset($object->reflectionClass) === false
|
||||
|| ! $object->reflectionClass->isEnum()
|
||||
|| ! (new \ReflectionEnum($object->name))->isBacked() // @phpstan-ignore-line
|
||||
|| (string) (new \ReflectionEnum($object->name))->getBackingType() !== $backingType, // @phpstan-ignore-line
|
||||
|| ! new \ReflectionEnum($object->name)->isBacked() // @phpstan-ignore-line
|
||||
|| (string) new \ReflectionEnum($object->name)->getBackingType() !== $backingType, // @phpstan-ignore-line
|
||||
'not to be '.$backingType.' backed enum',
|
||||
FileLineFinder::where(fn (string $line): bool => str_contains($line, 'class')),
|
||||
);
|
||||
|
||||
@ -116,8 +116,8 @@ final class TestCaseFactory
|
||||
$relativePath = (string) preg_replace('|%[a-fA-F0-9][a-fA-F0-9]|', '', $relativePath);
|
||||
// Remove escaped quote sequences (maintain namespace)
|
||||
$relativePath = str_replace(array_map(fn (string $quote): string => sprintf('\\%s', $quote), ['\'', '"']), '', $relativePath);
|
||||
// Limit to Unicode letters and numbers.
|
||||
$relativePath = (string) preg_replace('/[^\p{L}\p{N}\\\\]/u', '', $relativePath);
|
||||
// Limit to A-Z, a-z, 0-9, '_', '-'.
|
||||
$relativePath = (string) preg_replace('/[^A-Za-z0-9\\\\]/', '', $relativePath);
|
||||
|
||||
$classFQN = 'P\\'.$relativePath;
|
||||
|
||||
@ -197,7 +197,7 @@ final class TestCaseFactory
|
||||
|
||||
if (
|
||||
$method->closure instanceof \Closure &&
|
||||
(new \ReflectionFunction($method->closure))->isStatic()
|
||||
new \ReflectionFunction($method->closure)->isStatic()
|
||||
) {
|
||||
|
||||
throw new TestClosureMustNotBeStatic($method);
|
||||
|
||||
@ -50,11 +50,6 @@ final class TestCaseMethodFactory
|
||||
*/
|
||||
public int $repetitions = 1;
|
||||
|
||||
/**
|
||||
* The test's number of flaky retry tries.
|
||||
*/
|
||||
public ?int $flakyTries = null;
|
||||
|
||||
/**
|
||||
* Determines if the test is a "todo".
|
||||
*/
|
||||
|
||||
@ -4,6 +4,7 @@ declare(strict_types=1);
|
||||
|
||||
use Pest\Browser\Api\ArrayablePendingAwaitablePage;
|
||||
use Pest\Browser\Api\PendingAwaitablePage;
|
||||
use Pest\Concerns\Expectable;
|
||||
use Pest\Configuration;
|
||||
use Pest\Exceptions\AfterAllWithinDescribe;
|
||||
use Pest\Exceptions\BeforeAllWithinDescribe;
|
||||
@ -47,7 +48,7 @@ if (! function_exists('beforeAll')) {
|
||||
function beforeAll(Closure $closure): void
|
||||
{
|
||||
if (DescribeCall::describing() !== []) {
|
||||
$filename = Backtrace::testFile();
|
||||
$filename = Backtrace::file();
|
||||
|
||||
throw new BeforeAllWithinDescribe($filename);
|
||||
}
|
||||
@ -60,11 +61,13 @@ if (! function_exists('beforeEach')) {
|
||||
/**
|
||||
* Runs the given closure before each test in the current file.
|
||||
*
|
||||
* @param-closure-this TestCall $closure
|
||||
* @param-closure-this TestCase $closure
|
||||
*
|
||||
* @return HigherOrderTapProxy<Expectable|TestCall|TestCase>|Expectable|TestCall|TestCase|mixed
|
||||
*/
|
||||
function beforeEach(?Closure $closure = null): BeforeEachCall
|
||||
{
|
||||
$filename = Backtrace::testFile();
|
||||
$filename = Backtrace::file();
|
||||
|
||||
return new BeforeEachCall(TestSuite::getInstance(), $filename, $closure);
|
||||
}
|
||||
@ -89,6 +92,8 @@ if (! function_exists('describe')) {
|
||||
* Adds the given closure as a group of tests. The first argument
|
||||
* is the group description; the second argument is a closure
|
||||
* that contains the group tests.
|
||||
*
|
||||
* @return HigherOrderTapProxy<Expectable|TestCall|TestCase>|Expectable|TestCall|TestCase|mixed
|
||||
*/
|
||||
function describe(string $description, Closure $tests): DescribeCall
|
||||
{
|
||||
@ -107,7 +112,7 @@ if (! function_exists('uses')) {
|
||||
*/
|
||||
function uses(string ...$classAndTraits): UsesCall
|
||||
{
|
||||
$filename = Backtrace::testFile();
|
||||
$filename = Backtrace::file();
|
||||
|
||||
return new UsesCall($filename, array_values($classAndTraits));
|
||||
}
|
||||
@ -119,7 +124,7 @@ if (! function_exists('pest')) {
|
||||
*/
|
||||
function pest(): Configuration
|
||||
{
|
||||
return new Configuration(Backtrace::testFile());
|
||||
return new Configuration(Backtrace::file());
|
||||
}
|
||||
}
|
||||
|
||||
@ -129,9 +134,9 @@ if (! function_exists('test')) {
|
||||
* is the test description; the second argument is
|
||||
* a closure that contains the test expectations.
|
||||
*
|
||||
* @param-closure-this TestCall $closure
|
||||
* @param-closure-this TestCase $closure
|
||||
*
|
||||
* @return ($description is string ? TestCall : HigherOrderTapProxy|TestCall)
|
||||
* @return Expectable|TestCall|TestCase|mixed
|
||||
*/
|
||||
function test(?string $description = null, ?Closure $closure = null): HigherOrderTapProxy|TestCall
|
||||
{
|
||||
@ -151,23 +156,34 @@ if (! function_exists('it')) {
|
||||
* is the test description; the second argument is
|
||||
* a closure that contains the test expectations.
|
||||
*
|
||||
* @param-closure-this TestCall $closure
|
||||
* @param-closure-this TestCase $closure
|
||||
*
|
||||
* @return Expectable|TestCall|TestCase|mixed
|
||||
*/
|
||||
function it(string $description, ?Closure $closure = null): TestCall
|
||||
{
|
||||
$description = sprintf('it %s', $description);
|
||||
|
||||
return test($description, $closure);
|
||||
/** @var TestCall $test */
|
||||
$test = test($description, $closure);
|
||||
|
||||
return $test;
|
||||
}
|
||||
}
|
||||
|
||||
if (! function_exists('todo')) {
|
||||
/**
|
||||
* Creates a new test that is marked as "todo".
|
||||
*
|
||||
* @return Expectable|TestCall|TestCase|mixed
|
||||
*/
|
||||
function todo(string $description): TestCall
|
||||
{
|
||||
return test($description)->todo();
|
||||
$test = test($description);
|
||||
|
||||
assert($test instanceof TestCall);
|
||||
|
||||
return $test->todo();
|
||||
}
|
||||
}
|
||||
|
||||
@ -175,11 +191,13 @@ if (! function_exists('afterEach')) {
|
||||
/**
|
||||
* Runs the given closure after each test in the current file.
|
||||
*
|
||||
* @param-closure-this TestCall $closure
|
||||
* @param-closure-this TestCase $closure
|
||||
*
|
||||
* @return Expectable|HigherOrderTapProxy<Expectable|TestCall|TestCase>|TestCall|mixed
|
||||
*/
|
||||
function afterEach(?Closure $closure = null): AfterEachCall
|
||||
{
|
||||
$filename = Backtrace::testFile();
|
||||
$filename = Backtrace::file();
|
||||
|
||||
return new AfterEachCall(TestSuite::getInstance(), $filename, $closure);
|
||||
}
|
||||
@ -192,7 +210,7 @@ if (! function_exists('afterAll')) {
|
||||
function afterAll(Closure $closure): void
|
||||
{
|
||||
if (DescribeCall::describing() !== []) {
|
||||
$filename = Backtrace::testFile();
|
||||
$filename = Backtrace::file();
|
||||
|
||||
throw new AfterAllWithinDescribe($filename);
|
||||
}
|
||||
@ -209,7 +227,7 @@ if (! function_exists('covers')) {
|
||||
*/
|
||||
function covers(array|string ...$classesOrFunctions): void
|
||||
{
|
||||
$filename = Backtrace::testFile();
|
||||
$filename = Backtrace::file();
|
||||
|
||||
$beforeEachCall = (new BeforeEachCall(TestSuite::getInstance(), $filename));
|
||||
|
||||
@ -238,7 +256,7 @@ if (! function_exists('mutates')) {
|
||||
*/
|
||||
function mutates(array|string ...$targets): void
|
||||
{
|
||||
$filename = Backtrace::testFile();
|
||||
$filename = Backtrace::file();
|
||||
|
||||
$beforeEachCall = (new BeforeEachCall(TestSuite::getInstance(), $filename));
|
||||
$beforeEachCall->group('__pest_mutate_only');
|
||||
|
||||
@ -14,7 +14,6 @@ use InvalidArgumentException;
|
||||
use JsonSerializable;
|
||||
use Pest\Exceptions\InvalidExpectationValue;
|
||||
use Pest\Matchers\Any;
|
||||
use Pest\Plugins\Snapshot;
|
||||
use Pest\Support\Arr;
|
||||
use Pest\Support\Exporter;
|
||||
use Pest\Support\NullClosure;
|
||||
@ -852,31 +851,18 @@ final class Expectation
|
||||
default => InvalidExpectationValue::expected('array|object|string'),
|
||||
};
|
||||
|
||||
if (! $snapshots->has()) {
|
||||
if ($snapshots->has()) {
|
||||
[$filename, $content] = $snapshots->get();
|
||||
|
||||
Assert::assertSame(
|
||||
strtr($content, ["\r\n" => "\n", "\r" => "\n"]),
|
||||
strtr($string, ["\r\n" => "\n", "\r" => "\n"]),
|
||||
$message === '' ? "Failed asserting that the string value matches its snapshot ($filename)." : $message
|
||||
);
|
||||
} else {
|
||||
$filename = $snapshots->save($string);
|
||||
|
||||
TestSuite::getInstance()->registerSnapshotChange("Snapshot created at [$filename]");
|
||||
} else {
|
||||
[$filename, $content] = $snapshots->get();
|
||||
|
||||
$normalizedContent = strtr($content, ["\r\n" => "\n", "\r" => "\n"]);
|
||||
$normalizedString = strtr($string, ["\r\n" => "\n", "\r" => "\n"]);
|
||||
|
||||
if (Snapshot::$updateSnapshots && $normalizedContent !== $normalizedString) {
|
||||
$snapshots->save($string);
|
||||
|
||||
TestSuite::getInstance()->registerSnapshotChange("Snapshot updated at [$filename]");
|
||||
} else {
|
||||
if (Snapshot::$updateSnapshots) {
|
||||
TestSuite::getInstance()->registerSnapshotChange("Snapshot unchanged at [$filename]");
|
||||
}
|
||||
|
||||
Assert::assertSame(
|
||||
$normalizedContent,
|
||||
$normalizedString,
|
||||
$message === '' ? "Failed asserting that the string value matches its snapshot ($filename)." : $message
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
return $this;
|
||||
@ -936,7 +922,7 @@ final class Expectation
|
||||
|
||||
if ($exception instanceof Closure) {
|
||||
$callback = $exception;
|
||||
$parameters = (new ReflectionFunction($exception))->getParameters();
|
||||
$parameters = new ReflectionFunction($exception)->getParameters();
|
||||
|
||||
if (count($parameters) !== 1) {
|
||||
throw new InvalidArgumentException('The given closure must have a single parameter type-hinted as the class string.');
|
||||
|
||||
@ -1,57 +0,0 @@
|
||||
<?php
|
||||
|
||||
declare(strict_types=1);
|
||||
|
||||
namespace Pest\PHPStan;
|
||||
|
||||
use Pest\Expectations\HigherOrderExpectation;
|
||||
use PhpParser\Node\Expr;
|
||||
use PhpParser\Node\Expr\PropertyFetch;
|
||||
use PhpParser\Node\Identifier;
|
||||
use PHPStan\Analyser\Scope;
|
||||
use PHPStan\Reflection\ReflectionProvider;
|
||||
use PHPStan\Type\ExpressionTypeResolverExtension;
|
||||
use PHPStan\Type\ObjectType;
|
||||
use PHPStan\Type\Type;
|
||||
|
||||
/**
|
||||
* Prevents native declared properties of HigherOrderExpectation (like $original,
|
||||
* $expectation, $opposite, $shouldReset) from being incorrectly resolved as
|
||||
* higher-order value property accesses by downstream ExpressionTypeResolverExtensions.
|
||||
*
|
||||
* This extension must be registered BEFORE the peststan HigherOrderExpectationTypeExtension.
|
||||
*
|
||||
* @internal
|
||||
*/
|
||||
final readonly class HigherOrderExpectationTypeExtension implements ExpressionTypeResolverExtension
|
||||
{
|
||||
public function __construct(
|
||||
private ReflectionProvider $reflectionProvider,
|
||||
) {}
|
||||
|
||||
public function getType(Expr $expr, Scope $scope): ?Type
|
||||
{
|
||||
if (! $expr instanceof PropertyFetch || ! $expr->name instanceof Identifier) {
|
||||
return null;
|
||||
}
|
||||
|
||||
$varType = $scope->getType($expr->var);
|
||||
|
||||
if (! (new ObjectType(HigherOrderExpectation::class))->isSuperTypeOf($varType)->yes()) {
|
||||
return null;
|
||||
}
|
||||
|
||||
if (! $this->reflectionProvider->hasClass(HigherOrderExpectation::class)) {
|
||||
return null;
|
||||
}
|
||||
|
||||
$propertyName = $expr->name->name;
|
||||
$classReflection = $this->reflectionProvider->getClass(HigherOrderExpectation::class);
|
||||
|
||||
if (! $classReflection->hasNativeProperty($propertyName)) {
|
||||
return null;
|
||||
}
|
||||
|
||||
return $varType->getProperty($propertyName, $scope)->getReadableType();
|
||||
}
|
||||
}
|
||||
@ -5,6 +5,7 @@ declare(strict_types=1);
|
||||
namespace Pest\PendingCalls;
|
||||
|
||||
use Closure;
|
||||
use Pest\Support\Backtrace;
|
||||
use Pest\Support\Description;
|
||||
use Pest\TestSuite;
|
||||
|
||||
@ -52,11 +53,7 @@ final class DescribeCall
|
||||
*/
|
||||
public function __destruct()
|
||||
{
|
||||
// Ensure BeforeEachCall destructs before creating tests
|
||||
// by moving to local scope and clearing the reference
|
||||
$beforeEach = $this->currentBeforeEachCall;
|
||||
$this->currentBeforeEachCall = null;
|
||||
unset($beforeEach); // Trigger destructor immediately
|
||||
unset($this->currentBeforeEachCall);
|
||||
|
||||
self::$describing[] = $this->description;
|
||||
|
||||
@ -74,13 +71,12 @@ final class DescribeCall
|
||||
*/
|
||||
public function __call(string $name, array $arguments): self
|
||||
{
|
||||
if (! $this->currentBeforeEachCall instanceof BeforeEachCall) {
|
||||
$this->currentBeforeEachCall = new BeforeEachCall(TestSuite::getInstance(), $this->filename);
|
||||
$filename = Backtrace::file();
|
||||
|
||||
$this->currentBeforeEachCall->describing = array_merge(
|
||||
DescribeCall::describing(),
|
||||
[$this->description]
|
||||
);
|
||||
if (! $this->currentBeforeEachCall instanceof BeforeEachCall) {
|
||||
$this->currentBeforeEachCall = new BeforeEachCall(TestSuite::getInstance(), $filename);
|
||||
|
||||
$this->currentBeforeEachCall->describing[] = $this->description;
|
||||
}
|
||||
|
||||
$this->currentBeforeEachCall->{$name}(...$arguments);
|
||||
|
||||
@ -412,20 +412,6 @@ final class TestCall // @phpstan-ignore-line
|
||||
return $this;
|
||||
}
|
||||
|
||||
/**
|
||||
* Marks the test as flaky, retrying it up to the given number of times.
|
||||
*/
|
||||
public function flaky(int $tries = 3): self
|
||||
{
|
||||
if ($tries < 1) {
|
||||
throw new InvalidArgumentException('The number of tries must be greater than 0.');
|
||||
}
|
||||
|
||||
$this->testCaseMethod->flakyTries = $tries;
|
||||
|
||||
return $this;
|
||||
}
|
||||
|
||||
/**
|
||||
* Marks the test as "todo".
|
||||
*/
|
||||
|
||||
@ -53,9 +53,7 @@ final class UsesCall
|
||||
$this->targets = [$filename];
|
||||
}
|
||||
|
||||
/**
|
||||
* @deprecated Use `pest()->printer()->compact()` instead.
|
||||
*/
|
||||
#[\Deprecated(message: 'Use `pest()->printer()->compact()` instead.')]
|
||||
public function compact(): self
|
||||
{
|
||||
DefaultPrinter::compact(true);
|
||||
|
||||
@ -6,7 +6,7 @@ namespace Pest;
|
||||
|
||||
function version(): string
|
||||
{
|
||||
return '4.6.3';
|
||||
return '5.0.0-rc.3';
|
||||
}
|
||||
|
||||
function testDirectory(string $file = ''): string
|
||||
|
||||
@ -23,8 +23,6 @@ final class Coverage implements AddsOutput, HandlesArguments
|
||||
|
||||
private const string EXACTLY_OPTION = 'exactly';
|
||||
|
||||
private const string ONLY_COVERED_OPTION = 'only-covered';
|
||||
|
||||
/**
|
||||
* Whether it should show the coverage or not.
|
||||
*/
|
||||
@ -45,11 +43,6 @@ final class Coverage implements AddsOutput, HandlesArguments
|
||||
*/
|
||||
public ?float $coverageExactly = null;
|
||||
|
||||
/**
|
||||
* Whether it should show only covered files.
|
||||
*/
|
||||
public bool $showOnlyCovered = false;
|
||||
|
||||
/**
|
||||
* Creates a new Plugin instance.
|
||||
*/
|
||||
@ -64,7 +57,7 @@ final class Coverage implements AddsOutput, HandlesArguments
|
||||
public function handleArguments(array $originals): array
|
||||
{
|
||||
$arguments = [...[''], ...array_values(array_filter($originals, function (string $original): bool {
|
||||
foreach ([self::COVERAGE_OPTION, self::MIN_OPTION, self::EXACTLY_OPTION, self::ONLY_COVERED_OPTION] as $option) {
|
||||
foreach ([self::COVERAGE_OPTION, self::MIN_OPTION, self::EXACTLY_OPTION] as $option) {
|
||||
if ($original === sprintf('--%s', $option)) {
|
||||
return true;
|
||||
}
|
||||
@ -87,7 +80,6 @@ final class Coverage implements AddsOutput, HandlesArguments
|
||||
$inputs[] = new InputOption(self::COVERAGE_OPTION, null, InputOption::VALUE_NONE);
|
||||
$inputs[] = new InputOption(self::MIN_OPTION, null, InputOption::VALUE_REQUIRED);
|
||||
$inputs[] = new InputOption(self::EXACTLY_OPTION, null, InputOption::VALUE_REQUIRED);
|
||||
$inputs[] = new InputOption(self::ONLY_COVERED_OPTION, null, InputOption::VALUE_NONE);
|
||||
|
||||
$input = new ArgvInput($arguments, new InputDefinition($inputs));
|
||||
if ((bool) $input->getOption(self::COVERAGE_OPTION)) {
|
||||
@ -128,10 +120,6 @@ final class Coverage implements AddsOutput, HandlesArguments
|
||||
$this->coverageExactly = (float) $exactlyOption;
|
||||
}
|
||||
|
||||
if ((bool) $input->getOption(self::ONLY_COVERED_OPTION)) {
|
||||
$this->showOnlyCovered = true;
|
||||
}
|
||||
|
||||
if ($_SERVER['COLLISION_PRINTER_COMPACT'] ?? false) {
|
||||
$this->compact = true;
|
||||
}
|
||||
@ -156,7 +144,7 @@ final class Coverage implements AddsOutput, HandlesArguments
|
||||
exit(1);
|
||||
}
|
||||
|
||||
$coverage = \Pest\Support\Coverage::report($this->output, $this->compact, $this->showOnlyCovered);
|
||||
$coverage = \Pest\Support\Coverage::report($this->output, $this->compact);
|
||||
$exitCode = (int) ($coverage < $this->coverageMin);
|
||||
|
||||
if ($exitCode === 0 && $this->coverageExactly !== null) {
|
||||
|
||||
@ -123,10 +123,6 @@ final readonly class Help implements HandlesArguments
|
||||
'arg' => '--update-snapshots',
|
||||
'desc' => 'Update snapshots for tests using the "toMatchSnapshot" expectation',
|
||||
],
|
||||
[
|
||||
'arg' => '--update-shards',
|
||||
'desc' => 'Update shards.json with test timing data for time-balanced sharding',
|
||||
],
|
||||
], ...$content['Execution']];
|
||||
|
||||
$content['Selection'] = [[
|
||||
@ -156,9 +152,6 @@ final readonly class Help implements HandlesArguments
|
||||
], [
|
||||
'arg' => '--dirty',
|
||||
'desc' => 'Only run tests that have uncommitted changes according to Git',
|
||||
], [
|
||||
'arg' => '--flaky',
|
||||
'desc' => 'Output to standard output tests marked as flaky',
|
||||
], ...$content['Selection']];
|
||||
|
||||
$content['Reporting'] = [...$content['Reporting'], ...[
|
||||
@ -174,12 +167,6 @@ final readonly class Help implements HandlesArguments
|
||||
], [
|
||||
'arg' => '--coverage --min',
|
||||
'desc' => 'Set the minimum required coverage percentage, and fail if not met',
|
||||
], [
|
||||
'arg' => '--coverage --exactly',
|
||||
'desc' => 'Set the exact required coverage percentage, and fail if not met',
|
||||
], [
|
||||
'arg' => '--coverage --only-covered',
|
||||
'desc' => 'Hide files with 0% coverage from the code coverage report',
|
||||
], ...$content['Code Coverage']];
|
||||
|
||||
$content['Mutation Testing'] = [[
|
||||
|
||||
@ -34,7 +34,7 @@ final class Parallel implements HandlesArguments
|
||||
/**
|
||||
* @var string[]
|
||||
*/
|
||||
private const array UNSUPPORTED_ARGUMENTS = ['--todo', '--todos', '--retry', '--notes', '--issue', '--pr', '--pull-request', '--flaky'];
|
||||
private const array UNSUPPORTED_ARGUMENTS = ['--todo', '--todos', '--retry', '--notes', '--issue', '--pr', '--pull-request'];
|
||||
|
||||
/**
|
||||
* Whether the given command line arguments indicate that the test suite should be run in parallel.
|
||||
@ -127,9 +127,7 @@ final class Parallel implements HandlesArguments
|
||||
$arguments
|
||||
);
|
||||
|
||||
$filteredArguments = $this->processTeamcityArguments($filteredArguments);
|
||||
|
||||
$exitCode = $this->paratestCommand()->run(new ArgvInput(array_values($filteredArguments)), new CleanConsoleOutput);
|
||||
$exitCode = $this->paratestCommand()->run(new ArgvInput($filteredArguments), new CleanConsoleOutput);
|
||||
|
||||
return CallsAddsOutput::execute($exitCode);
|
||||
}
|
||||
@ -178,13 +176,7 @@ final class Parallel implements HandlesArguments
|
||||
{
|
||||
$arguments = new ArgvInput;
|
||||
|
||||
foreach (self::UNSUPPORTED_ARGUMENTS as $unsupportedArgument) {
|
||||
if ($arguments->hasParameterOption($unsupportedArgument)) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
return false;
|
||||
return array_any(self::UNSUPPORTED_ARGUMENTS, fn (string|array $unsupportedArgument): bool => $arguments->hasParameterOption($unsupportedArgument));
|
||||
}
|
||||
|
||||
/**
|
||||
@ -199,18 +191,4 @@ final class Parallel implements HandlesArguments
|
||||
|
||||
return $this->popArgument('-p', $arguments);
|
||||
}
|
||||
|
||||
/**
|
||||
* @param string[] $arguments
|
||||
* @return string[]
|
||||
*/
|
||||
public function processTeamcityArguments(array $arguments): array
|
||||
{
|
||||
$argv = new ArgvInput;
|
||||
if ($argv->hasParameterOption('--teamcity')) {
|
||||
$arguments[] = '--teamcity';
|
||||
}
|
||||
|
||||
return $arguments;
|
||||
}
|
||||
}
|
||||
|
||||
@ -81,9 +81,7 @@ final class ResultPrinter
|
||||
public function flush(): void {}
|
||||
};
|
||||
|
||||
$this->compactPrinter = CompactPrinter::default(
|
||||
decorated: ! in_array('--colors=never', $_SERVER['argv'] ?? [], true),
|
||||
);
|
||||
$this->compactPrinter = CompactPrinter::default();
|
||||
|
||||
if (! $this->options->configuration->hasLogfileTeamcity()) {
|
||||
return;
|
||||
@ -94,13 +92,14 @@ final class ResultPrinter
|
||||
$this->teamcityLogFileHandle = $teamcityLogFileHandle;
|
||||
}
|
||||
|
||||
/** @param list<SplFileInfo> $teamcityFiles */
|
||||
public function printFeedback(
|
||||
SplFileInfo $progressFile,
|
||||
SplFileInfo $outputFile,
|
||||
?SplFileInfo $teamcityFile,
|
||||
array $teamcityFiles
|
||||
): void {
|
||||
if ($this->options->needsTeamcity && $teamcityFile instanceof SplFileInfo) {
|
||||
$teamcityProgress = $this->tailMultiple([$teamcityFile]);
|
||||
if ($this->options->needsTeamcity) {
|
||||
$teamcityProgress = $this->tailMultiple($teamcityFiles);
|
||||
|
||||
if ($this->teamcityLogFileHandle !== null) {
|
||||
fwrite($this->teamcityLogFileHandle, $teamcityProgress);
|
||||
@ -172,18 +171,8 @@ final class ResultPrinter
|
||||
|
||||
$state = (new StateGenerator)->fromPhpUnitTestResult($this->passedTests, $testResult);
|
||||
|
||||
if ($testResult->numberOfTestsRun() === 0 && $state->testSuiteTestsCount() === 0) {
|
||||
$this->output->writeln([
|
||||
'',
|
||||
' <fg=white;options=bold;bg=blue> INFO </> No tests found.',
|
||||
'',
|
||||
]);
|
||||
}
|
||||
|
||||
if (! isset($_SERVER['PEST_PARALLEL_NO_OUTPUT'])) {
|
||||
$this->compactPrinter->errors($state);
|
||||
$this->compactPrinter->recap($state, $testResult, $duration, $this->options);
|
||||
}
|
||||
$this->compactPrinter->errors($state);
|
||||
$this->compactPrinter->recap($state, $testResult, $duration, $this->options);
|
||||
}
|
||||
|
||||
private function printFeedbackItem(string $item): void
|
||||
|
||||
@ -7,7 +7,6 @@ namespace Pest\Plugins\Parallel\Paratest;
|
||||
use const DIRECTORY_SEPARATOR;
|
||||
|
||||
use NunoMaduro\Collision\Adapters\Phpunit\Support\ResultReflection;
|
||||
use ParaTest\Coverage\CoverageMerger;
|
||||
use ParaTest\JUnit\LogMerger;
|
||||
use ParaTest\JUnit\Writer;
|
||||
use ParaTest\Options;
|
||||
@ -25,11 +24,17 @@ use PHPUnit\TestRunner\TestResult\Facade as TestResultFacade;
|
||||
use PHPUnit\TestRunner\TestResult\TestResult;
|
||||
use PHPUnit\TextUI\Configuration\CodeCoverageFilterRegistry;
|
||||
use PHPUnit\Util\ExcludeList;
|
||||
use ReflectionProperty;
|
||||
use SebastianBergmann\CodeCoverage\Node\Builder;
|
||||
use SebastianBergmann\CodeCoverage\Serialization\Merger;
|
||||
use SebastianBergmann\CodeCoverage\StaticAnalysis\FileAnalyser;
|
||||
use SebastianBergmann\CodeCoverage\StaticAnalysis\ParsingSourceAnalyser;
|
||||
use SebastianBergmann\Timer\Timer;
|
||||
use SplFileInfo;
|
||||
use Symfony\Component\Console\Output\OutputInterface;
|
||||
use Symfony\Component\Process\PhpExecutableFinder;
|
||||
|
||||
use function array_filter;
|
||||
use function array_merge;
|
||||
use function array_merge_recursive;
|
||||
use function array_shift;
|
||||
@ -39,7 +44,6 @@ use function dirname;
|
||||
use function file_get_contents;
|
||||
use function max;
|
||||
use function realpath;
|
||||
use function str_starts_with;
|
||||
use function unlink;
|
||||
use function unserialize;
|
||||
use function usleep;
|
||||
@ -232,7 +236,7 @@ final class WrapperRunner implements RunnerInterface
|
||||
$this->printer->printFeedback(
|
||||
$worker->progressFile,
|
||||
$worker->unexpectedOutputFile,
|
||||
$worker->teamcityFile ?? null,
|
||||
$this->teamcityFiles,
|
||||
);
|
||||
$worker->reset();
|
||||
}
|
||||
@ -448,10 +452,23 @@ final class WrapperRunner implements RunnerInterface
|
||||
|
||||
return;
|
||||
}
|
||||
$coverageMerger = new CoverageMerger($coverageManager->codeCoverage());
|
||||
foreach ($this->coverageFiles as $coverageFile) {
|
||||
$coverageMerger->addCoverageFromFile($coverageFile);
|
||||
$coverageFiles = [];
|
||||
foreach ($this->coverageFiles as $fileInfo) {
|
||||
$realPath = $fileInfo->getRealPath();
|
||||
if ($realPath !== false && $realPath !== '') {
|
||||
$coverageFiles[] = $realPath;
|
||||
}
|
||||
}
|
||||
$serializedCoverage = (new Merger)->merge($coverageFiles);
|
||||
|
||||
$report = (new Builder(new FileAnalyser(new ParsingSourceAnalyser, false, false)))->build(
|
||||
$serializedCoverage['codeCoverage'],
|
||||
$serializedCoverage['testResults'],
|
||||
$serializedCoverage['basePath'],
|
||||
);
|
||||
$codeCoverage = $coverageManager->codeCoverage();
|
||||
$codeCoverage->setTests($serializedCoverage['testResults']);
|
||||
(new ReflectionProperty(\SebastianBergmann\CodeCoverage\CodeCoverage::class, 'cachedReport'))->setValue($codeCoverage, $report);
|
||||
|
||||
$coverageManager->generateReports(
|
||||
$this->printer->printer,
|
||||
@ -492,61 +509,15 @@ final class WrapperRunner implements RunnerInterface
|
||||
*/
|
||||
private function getTestFiles(SuiteLoader $suiteLoader): array
|
||||
{
|
||||
/** @var array<string, null> $files */
|
||||
$files = [];
|
||||
/** @var array<string, non-empty-string> $files */
|
||||
$files = [
|
||||
...array_values(array_filter(
|
||||
$suiteLoader->tests,
|
||||
fn (string $filename): bool => ! str_ends_with($filename, "eval()'d code")
|
||||
)),
|
||||
...TestSuite::getInstance()->tests->getFilenames(),
|
||||
];
|
||||
|
||||
foreach (array_filter(
|
||||
$suiteLoader->tests,
|
||||
fn (string $filename): bool => ! str_ends_with($filename, "eval()'d code")
|
||||
) as $filename) {
|
||||
$resolved = realpath($filename) ?: $filename;
|
||||
$files[$resolved] = null;
|
||||
}
|
||||
|
||||
foreach (TestSuite::getInstance()->tests->getFilenames() as $filename) {
|
||||
if ($this->shouldIncludeBootstrappedTestFile($filename)) {
|
||||
$resolved = realpath($filename)
|
||||
?: realpath($this->options->cwd.DIRECTORY_SEPARATOR.$filename)
|
||||
?: $filename;
|
||||
$files[$resolved] = null;
|
||||
}
|
||||
}
|
||||
|
||||
return array_keys($files); // @phpstan-ignore-line
|
||||
}
|
||||
|
||||
private function shouldIncludeBootstrappedTestFile(string $filename): bool
|
||||
{
|
||||
if (! $this->options->configuration->hasCliArguments()) {
|
||||
return true;
|
||||
}
|
||||
|
||||
$resolvedFilename = realpath($filename);
|
||||
|
||||
if ($resolvedFilename === false) {
|
||||
$resolvedFilename = realpath($this->options->cwd.DIRECTORY_SEPARATOR.$filename);
|
||||
}
|
||||
|
||||
if ($resolvedFilename === false) {
|
||||
return false;
|
||||
}
|
||||
|
||||
foreach ($this->options->configuration->cliArguments() as $path) {
|
||||
$resolvedPath = realpath($path);
|
||||
|
||||
if ($resolvedPath === false) {
|
||||
continue;
|
||||
}
|
||||
|
||||
if ($resolvedFilename === $resolvedPath) {
|
||||
return true;
|
||||
}
|
||||
|
||||
if (is_dir($resolvedPath) && str_starts_with($resolvedFilename, $resolvedPath.DIRECTORY_SEPARATOR)) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
return false;
|
||||
return $files; // @phpstan-ignore-line
|
||||
}
|
||||
}
|
||||
|
||||
@ -62,12 +62,12 @@ final class CompactPrinter
|
||||
/**
|
||||
* Creates a new instance of the Compact Printer.
|
||||
*/
|
||||
public static function default(bool $decorated = true): self
|
||||
public static function default(): self
|
||||
{
|
||||
return new self(
|
||||
terminal(),
|
||||
new ConsoleOutput(decorated: $decorated),
|
||||
new Style(new ConsoleOutput(decorated: $decorated)),
|
||||
new ConsoleOutput(decorated: true),
|
||||
new Style(new ConsoleOutput(decorated: true)),
|
||||
terminal()->width() - 4,
|
||||
);
|
||||
}
|
||||
|
||||
@ -6,13 +6,7 @@ namespace Pest\Plugins;
|
||||
|
||||
use Pest\Contracts\Plugins\AddsOutput;
|
||||
use Pest\Contracts\Plugins\HandlesArguments;
|
||||
use Pest\Contracts\Plugins\Terminable;
|
||||
use Pest\Exceptions\InvalidOption;
|
||||
use Pest\Subscribers\EnsureShardTimingFinished;
|
||||
use Pest\Subscribers\EnsureShardTimingsAreCollected;
|
||||
use Pest\Subscribers\EnsureShardTimingStarted;
|
||||
use Pest\TestSuite;
|
||||
use PHPUnit\Event;
|
||||
use Symfony\Component\Console\Input\ArgvInput;
|
||||
use Symfony\Component\Console\Input\InputInterface;
|
||||
use Symfony\Component\Console\Output\OutputInterface;
|
||||
@ -21,7 +15,7 @@ use Symfony\Component\Process\Process;
|
||||
/**
|
||||
* @internal
|
||||
*/
|
||||
final class Shard implements AddsOutput, HandlesArguments, Terminable
|
||||
final class Shard implements AddsOutput, HandlesArguments
|
||||
{
|
||||
use Concerns\HandleArguments;
|
||||
|
||||
@ -39,40 +33,6 @@ final class Shard implements AddsOutput, HandlesArguments, Terminable
|
||||
*/
|
||||
private static ?array $shard = null;
|
||||
|
||||
/**
|
||||
* Whether to update the shards.json file.
|
||||
*/
|
||||
private static bool $updateShards = false;
|
||||
|
||||
/**
|
||||
* Whether time-balanced sharding was used.
|
||||
*/
|
||||
private static bool $timeBalanced = false;
|
||||
|
||||
/**
|
||||
* Whether the shards.json file is outdated.
|
||||
*/
|
||||
private static bool $shardsOutdated = false;
|
||||
|
||||
/**
|
||||
* Whether the test suite passed.
|
||||
*/
|
||||
private static bool $passed = false;
|
||||
|
||||
/**
|
||||
* Collected timings from workers or subscribers.
|
||||
*
|
||||
* @var array<string, float>|null
|
||||
*/
|
||||
private static ?array $collectedTimings = null;
|
||||
|
||||
/**
|
||||
* The canonical list of test classes from --list-tests.
|
||||
*
|
||||
* @var list<string>|null
|
||||
*/
|
||||
private static ?array $knownTests = null;
|
||||
|
||||
/**
|
||||
* Creates a new Plugin instance.
|
||||
*/
|
||||
@ -87,19 +47,6 @@ final class Shard implements AddsOutput, HandlesArguments, Terminable
|
||||
*/
|
||||
public function handleArguments(array $arguments): array
|
||||
{
|
||||
if ($this->hasArgument('--update-shards', $arguments)) {
|
||||
return $this->handleUpdateShards($arguments);
|
||||
}
|
||||
|
||||
if (Parallel::isWorker() && Parallel::getGlobal('UPDATE_SHARDS') === true) {
|
||||
self::$updateShards = true;
|
||||
|
||||
Event\Facade::instance()->registerSubscriber(new EnsureShardTimingStarted);
|
||||
Event\Facade::instance()->registerSubscriber(new EnsureShardTimingFinished);
|
||||
|
||||
return $arguments;
|
||||
}
|
||||
|
||||
if (! $this->hasArgument('--shard', $arguments)) {
|
||||
return $arguments;
|
||||
}
|
||||
@ -116,24 +63,7 @@ final class Shard implements AddsOutput, HandlesArguments, Terminable
|
||||
|
||||
/** @phpstan-ignore-next-line */
|
||||
$tests = $this->allTests($arguments);
|
||||
|
||||
$timings = $this->loadShardsFile();
|
||||
if ($timings !== null) {
|
||||
$knownTests = array_values(array_filter($tests, fn (string $test): bool => isset($timings[$test])));
|
||||
$newTests = array_values(array_diff($tests, $knownTests));
|
||||
|
||||
$partitions = $this->partitionByTime($knownTests, $timings, $total);
|
||||
|
||||
foreach ($newTests as $i => $test) {
|
||||
$partitions[$i % $total][] = $test;
|
||||
}
|
||||
|
||||
$testsToRun = $partitions[$index - 1] ?? [];
|
||||
self::$timeBalanced = true;
|
||||
self::$shardsOutdated = $newTests !== [];
|
||||
} else {
|
||||
$testsToRun = (array_chunk($tests, max(1, (int) ceil(count($tests) / $total))))[$index - 1] ?? [];
|
||||
}
|
||||
$testsToRun = (array_chunk($tests, max(1, (int) ceil(count($tests) / $total))))[$index - 1] ?? [];
|
||||
|
||||
self::$shard = [
|
||||
'index' => $index,
|
||||
@ -142,43 +72,9 @@ final class Shard implements AddsOutput, HandlesArguments, Terminable
|
||||
'testsCount' => count($tests),
|
||||
];
|
||||
|
||||
if ($testsToRun === []) {
|
||||
return $arguments;
|
||||
}
|
||||
|
||||
return [...$arguments, '--filter', $this->buildFilterArgument($testsToRun)];
|
||||
}
|
||||
|
||||
/**
|
||||
* Handles the --update-shards argument.
|
||||
*
|
||||
* @param array<int, string> $arguments
|
||||
* @return array<int, string>
|
||||
*/
|
||||
private function handleUpdateShards(array $arguments): array
|
||||
{
|
||||
if ($this->hasArgument('--shard', $arguments)) {
|
||||
throw new InvalidOption('The [--update-shards] option cannot be combined with [--shard].');
|
||||
}
|
||||
|
||||
$arguments = $this->popArgument('--update-shards', $arguments);
|
||||
|
||||
self::$updateShards = true;
|
||||
|
||||
/** @phpstan-ignore-next-line */
|
||||
self::$knownTests = $this->allTests($arguments);
|
||||
|
||||
if ($this->hasArgument('--parallel', $arguments) || $this->hasArgument('-p', $arguments)) {
|
||||
Parallel::setGlobal('UPDATE_SHARDS', true);
|
||||
Parallel::setGlobal('SHARD_RUN_ID', uniqid('pest-shard-', true));
|
||||
} else {
|
||||
Event\Facade::instance()->registerSubscriber(new EnsureShardTimingStarted);
|
||||
Event\Facade::instance()->registerSubscriber(new EnsureShardTimingFinished);
|
||||
}
|
||||
|
||||
return $arguments;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns all tests that the test suite would run.
|
||||
*
|
||||
@ -187,11 +83,11 @@ final class Shard implements AddsOutput, HandlesArguments, Terminable
|
||||
*/
|
||||
private function allTests(array $arguments): array
|
||||
{
|
||||
$output = (new Process([
|
||||
$output = new Process([
|
||||
'php',
|
||||
...$this->removeParallelArguments($arguments),
|
||||
'--list-tests',
|
||||
]))->setTimeout(120)->mustRun()->getOutput();
|
||||
])->mustRun()->getOutput();
|
||||
|
||||
preg_match_all('/ - (?:P\\\\)?(Tests\\\\[^:]+)::/', $output, $matches);
|
||||
|
||||
@ -220,22 +116,6 @@ final class Shard implements AddsOutput, HandlesArguments, Terminable
|
||||
*/
|
||||
public function addOutput(int $exitCode): int
|
||||
{
|
||||
self::$passed = $exitCode === 0;
|
||||
|
||||
if (self::$updateShards && self::$passed && ! Parallel::isWorker()) {
|
||||
self::$collectedTimings = $this->collectTimings();
|
||||
|
||||
$count = self::$knownTests !== null
|
||||
? count(array_intersect_key(self::$collectedTimings, array_flip(self::$knownTests)))
|
||||
: count(self::$collectedTimings);
|
||||
|
||||
$this->output->writeln(sprintf(
|
||||
' <fg=gray>Shards:</> <fg=default>shards.json updated with timings for %d test class%s.</>',
|
||||
$count,
|
||||
$count === 1 ? '' : 'es',
|
||||
));
|
||||
}
|
||||
|
||||
if (self::$shard === null) {
|
||||
return $exitCode;
|
||||
}
|
||||
@ -248,250 +128,17 @@ final class Shard implements AddsOutput, HandlesArguments, Terminable
|
||||
] = self::$shard;
|
||||
|
||||
$this->output->writeln(sprintf(
|
||||
' <fg=gray>Shard:</> <fg=default>%d of %d</> — %d file%s ran, out of %d%s.',
|
||||
' <fg=gray>Shard:</> <fg=default>%d of %d</> — %d file%s ran, out of %d.',
|
||||
$index,
|
||||
$total,
|
||||
$testsRan,
|
||||
$testsRan === 1 ? '' : 's',
|
||||
$testsCount,
|
||||
self::$timeBalanced ? ' <fg=gray>(time-balanced)</>' : '',
|
||||
));
|
||||
|
||||
if (self::$shardsOutdated) {
|
||||
$this->output->writeln(' <fg=yellow;options=bold>WARN</> <fg=default>The [tests/.pest/shards.json] file is out of date. Run [--update-shards] to update it.</>');
|
||||
}
|
||||
|
||||
return $exitCode;
|
||||
}
|
||||
|
||||
/**
|
||||
* Terminates the plugin.
|
||||
*/
|
||||
public function terminate(): void
|
||||
{
|
||||
if (! self::$updateShards) {
|
||||
return;
|
||||
}
|
||||
|
||||
if (Parallel::isWorker()) {
|
||||
$this->writeWorkerTimings();
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
if (! self::$passed) {
|
||||
return;
|
||||
}
|
||||
|
||||
$timings = self::$collectedTimings ?? $this->collectTimings();
|
||||
|
||||
if ($timings === []) {
|
||||
return;
|
||||
}
|
||||
|
||||
$this->writeTimings($timings);
|
||||
}
|
||||
|
||||
/**
|
||||
* Collects timings from subscribers or worker temp files.
|
||||
*
|
||||
* @return array<string, float>
|
||||
*/
|
||||
private function collectTimings(): array
|
||||
{
|
||||
$runId = Parallel::getGlobal('SHARD_RUN_ID');
|
||||
|
||||
if (is_string($runId)) {
|
||||
return $this->readWorkerTimings($runId);
|
||||
}
|
||||
|
||||
return EnsureShardTimingsAreCollected::timings();
|
||||
}
|
||||
|
||||
/**
|
||||
* Writes the current worker's timing data to a temp file.
|
||||
*/
|
||||
private function writeWorkerTimings(): void
|
||||
{
|
||||
$timings = EnsureShardTimingsAreCollected::timings();
|
||||
|
||||
if ($timings === []) {
|
||||
return;
|
||||
}
|
||||
|
||||
$runId = Parallel::getGlobal('SHARD_RUN_ID');
|
||||
|
||||
if (! is_string($runId)) {
|
||||
return;
|
||||
}
|
||||
|
||||
$path = sys_get_temp_dir().DIRECTORY_SEPARATOR.'__pest_sharding_'.$runId.'-'.getmypid().'.json';
|
||||
|
||||
file_put_contents($path, json_encode($timings, JSON_THROW_ON_ERROR));
|
||||
}
|
||||
|
||||
/**
|
||||
* Reads and merges timing data from all worker temp files.
|
||||
*
|
||||
* @return array<string, float>
|
||||
*/
|
||||
private function readWorkerTimings(string $runId): array
|
||||
{
|
||||
$pattern = sys_get_temp_dir().DIRECTORY_SEPARATOR.'__pest_sharding_'.$runId.'-*.json';
|
||||
$files = glob($pattern);
|
||||
|
||||
if ($files === false || $files === []) {
|
||||
return [];
|
||||
}
|
||||
|
||||
$merged = [];
|
||||
|
||||
foreach ($files as $file) {
|
||||
$contents = file_get_contents($file);
|
||||
|
||||
if ($contents === false) {
|
||||
continue;
|
||||
}
|
||||
|
||||
$timings = json_decode($contents, true);
|
||||
|
||||
if (is_array($timings)) {
|
||||
$merged = array_merge($merged, $timings);
|
||||
}
|
||||
|
||||
unlink($file);
|
||||
}
|
||||
|
||||
return $merged;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the path to shards.json.
|
||||
*/
|
||||
private function shardsPath(): string
|
||||
{
|
||||
$testSuite = TestSuite::getInstance();
|
||||
|
||||
return implode(DIRECTORY_SEPARATOR, [$testSuite->rootPath, $testSuite->testPath, '.pest', 'shards.json']);
|
||||
}
|
||||
|
||||
/**
|
||||
* Loads the timings from shards.json.
|
||||
*
|
||||
* @return array<string, float>|null
|
||||
*/
|
||||
private function loadShardsFile(): ?array
|
||||
{
|
||||
$path = $this->shardsPath();
|
||||
|
||||
if (! file_exists($path)) {
|
||||
return null;
|
||||
}
|
||||
|
||||
$contents = file_get_contents($path);
|
||||
|
||||
if ($contents === false) {
|
||||
throw new InvalidOption('The [tests/.pest/shards.json] file could not be read. Delete it or run [--update-shards] to regenerate.');
|
||||
}
|
||||
|
||||
$data = json_decode($contents, true);
|
||||
|
||||
if (! is_array($data) || ! isset($data['timings']) || ! is_array($data['timings'])) {
|
||||
throw new InvalidOption('The [tests/.pest/shards.json] file is corrupted. Delete it or run [--update-shards] to regenerate.');
|
||||
}
|
||||
|
||||
return $data['timings'];
|
||||
}
|
||||
|
||||
/**
|
||||
* Partitions tests across shards using the LPT (Longest Processing Time) algorithm.
|
||||
*
|
||||
* @param list<string> $tests
|
||||
* @param array<string, float> $timings
|
||||
* @return list<list<string>>
|
||||
*/
|
||||
private function partitionByTime(array $tests, array $timings, int $total): array
|
||||
{
|
||||
$knownTimings = array_filter(
|
||||
array_map(fn (string $test): ?float => $timings[$test] ?? null, $tests),
|
||||
fn (?float $t): bool => $t !== null,
|
||||
);
|
||||
|
||||
$median = $knownTimings !== [] ? $this->median(array_values($knownTimings)) : 1.0;
|
||||
|
||||
$testsWithTimings = array_map(
|
||||
fn (string $test): array => ['test' => $test, 'time' => $timings[$test] ?? $median],
|
||||
$tests,
|
||||
);
|
||||
|
||||
usort($testsWithTimings, fn (array $a, array $b): int => $b['time'] <=> $a['time']);
|
||||
|
||||
/** @var list<list<string>> */
|
||||
$bins = array_fill(0, $total, []);
|
||||
/** @var non-empty-list<float> */
|
||||
$binTimes = array_fill(0, $total, 0.0);
|
||||
|
||||
foreach ($testsWithTimings as $item) {
|
||||
$minIndex = array_search(min($binTimes), $binTimes, strict: true);
|
||||
assert(is_int($minIndex));
|
||||
|
||||
$bins[$minIndex][] = $item['test'];
|
||||
$binTimes[$minIndex] += $item['time'];
|
||||
}
|
||||
|
||||
return $bins;
|
||||
}
|
||||
|
||||
/**
|
||||
* Calculates the median of an array of floats.
|
||||
*
|
||||
* @param list<float> $values
|
||||
*/
|
||||
private function median(array $values): float
|
||||
{
|
||||
sort($values);
|
||||
|
||||
$count = count($values);
|
||||
$middle = (int) floor($count / 2);
|
||||
|
||||
if ($count % 2 === 0) {
|
||||
return ($values[$middle - 1] + $values[$middle]) / 2;
|
||||
}
|
||||
|
||||
return $values[$middle];
|
||||
}
|
||||
|
||||
/**
|
||||
* Writes the timings to shards.json.
|
||||
*
|
||||
* @param array<string, float> $timings
|
||||
*/
|
||||
private function writeTimings(array $timings): void
|
||||
{
|
||||
$path = $this->shardsPath();
|
||||
|
||||
$directory = dirname($path);
|
||||
if (! is_dir($directory)) {
|
||||
mkdir($directory, 0755, true);
|
||||
}
|
||||
|
||||
if (self::$knownTests !== null) {
|
||||
$knownSet = array_flip(self::$knownTests);
|
||||
$timings = array_intersect_key($timings, $knownSet);
|
||||
}
|
||||
|
||||
ksort($timings);
|
||||
|
||||
$canonical = self::$knownTests ?? array_keys($timings);
|
||||
sort($canonical);
|
||||
|
||||
file_put_contents($path, json_encode([
|
||||
'timings' => $timings,
|
||||
'checksum' => md5(implode("\n", $canonical)),
|
||||
'updated_at' => date('c'),
|
||||
], JSON_PRETTY_PRINT | JSON_UNESCAPED_SLASHES)."\n");
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the shard information.
|
||||
*
|
||||
|
||||
@ -5,6 +5,7 @@ declare(strict_types=1);
|
||||
namespace Pest\Plugins;
|
||||
|
||||
use Pest\Contracts\Plugins\HandlesArguments;
|
||||
use Pest\Exceptions\InvalidOption;
|
||||
use Pest\TestSuite;
|
||||
|
||||
/**
|
||||
@ -14,116 +15,21 @@ final class Snapshot implements HandlesArguments
|
||||
{
|
||||
use Concerns\HandleArguments;
|
||||
|
||||
/**
|
||||
* Whether snapshots should be updated on this run.
|
||||
*/
|
||||
public static bool $updateSnapshots = false;
|
||||
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
*/
|
||||
public function handleArguments(array $arguments): array
|
||||
{
|
||||
if (Parallel::isWorker() && Parallel::getGlobal('UPDATE_SNAPSHOTS') === true) {
|
||||
self::$updateSnapshots = true;
|
||||
|
||||
return $arguments;
|
||||
}
|
||||
|
||||
if (! $this->hasArgument('--update-snapshots', $arguments)) {
|
||||
return $arguments;
|
||||
}
|
||||
|
||||
self::$updateSnapshots = true;
|
||||
|
||||
if ($this->isFullRun($arguments)) {
|
||||
TestSuite::getInstance()->snapshots->flush();
|
||||
if ($this->hasArgument('--parallel', $arguments)) {
|
||||
throw new InvalidOption('The [--update-snapshots] option is not supported when running in parallel.');
|
||||
}
|
||||
|
||||
if ($this->hasArgument('--parallel', $arguments) || $this->hasArgument('-p', $arguments)) {
|
||||
Parallel::setGlobal('UPDATE_SNAPSHOTS', true);
|
||||
}
|
||||
TestSuite::getInstance()->snapshots->flush();
|
||||
|
||||
return $this->popArgument('--update-snapshots', $arguments);
|
||||
}
|
||||
|
||||
/**
|
||||
* Options that take a value as the next argument (rather than via "=value").
|
||||
*
|
||||
* @var list<string>
|
||||
*/
|
||||
private const array FLAGS_WITH_VALUES = [
|
||||
'--filter',
|
||||
'--group',
|
||||
'--exclude-group',
|
||||
'--test-suffix',
|
||||
'--covers',
|
||||
'--uses',
|
||||
'--cache-directory',
|
||||
'--cache-result-file',
|
||||
'--configuration',
|
||||
'--colors',
|
||||
'--test-directory',
|
||||
'--bootstrap',
|
||||
'--order-by',
|
||||
'--random-order-seed',
|
||||
'--log-junit',
|
||||
'--log-teamcity',
|
||||
'--log-events-text',
|
||||
'--log-events-verbose-text',
|
||||
'--coverage-clover',
|
||||
'--coverage-cobertura',
|
||||
'--coverage-crap4j',
|
||||
'--coverage-html',
|
||||
'--coverage-php',
|
||||
'--coverage-text',
|
||||
'--coverage-xml',
|
||||
'--assignee',
|
||||
'--issue',
|
||||
'--ticket',
|
||||
'--pr',
|
||||
'--pull-request',
|
||||
'--retry',
|
||||
'--shard',
|
||||
'--repeat',
|
||||
];
|
||||
|
||||
/**
|
||||
* Determines whether the command targets the entire suite (no filter, no path).
|
||||
*
|
||||
* @param array<int, string> $arguments
|
||||
*/
|
||||
private function isFullRun(array $arguments): bool
|
||||
{
|
||||
if ($this->hasArgument('--filter', $arguments)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
$tokens = array_slice($arguments, 1);
|
||||
$skipNext = false;
|
||||
|
||||
foreach ($tokens as $arg) {
|
||||
if ($skipNext) {
|
||||
$skipNext = false;
|
||||
|
||||
continue;
|
||||
}
|
||||
|
||||
if ($arg === '') {
|
||||
continue;
|
||||
}
|
||||
|
||||
if ($arg[0] === '-') {
|
||||
if (in_array($arg, self::FLAGS_WITH_VALUES, true)) {
|
||||
$skipNext = true;
|
||||
}
|
||||
|
||||
continue;
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
@ -59,10 +59,8 @@ final class SnapshotRepository
|
||||
{
|
||||
$snapshotFilename = $this->getSnapshotFilename();
|
||||
|
||||
$directory = dirname($snapshotFilename);
|
||||
|
||||
if (! is_dir($directory)) {
|
||||
@mkdir($directory, 0755, true);
|
||||
if (! file_exists(dirname($snapshotFilename))) {
|
||||
mkdir(dirname($snapshotFilename), 0755, true);
|
||||
}
|
||||
|
||||
file_put_contents($snapshotFilename, $snapshot);
|
||||
|
||||
@ -1,22 +0,0 @@
|
||||
<?php
|
||||
|
||||
declare(strict_types=1);
|
||||
|
||||
namespace Pest\Subscribers;
|
||||
|
||||
use PHPUnit\Event\TestSuite\Finished;
|
||||
use PHPUnit\Event\TestSuite\FinishedSubscriber;
|
||||
|
||||
/**
|
||||
* @internal
|
||||
*/
|
||||
final class EnsureShardTimingFinished implements FinishedSubscriber
|
||||
{
|
||||
/**
|
||||
* Runs the subscriber.
|
||||
*/
|
||||
public function notify(Finished $event): void
|
||||
{
|
||||
EnsureShardTimingsAreCollected::finished($event);
|
||||
}
|
||||
}
|
||||
@ -1,22 +0,0 @@
|
||||
<?php
|
||||
|
||||
declare(strict_types=1);
|
||||
|
||||
namespace Pest\Subscribers;
|
||||
|
||||
use PHPUnit\Event\TestSuite\Started;
|
||||
use PHPUnit\Event\TestSuite\StartedSubscriber;
|
||||
|
||||
/**
|
||||
* @internal
|
||||
*/
|
||||
final class EnsureShardTimingStarted implements StartedSubscriber
|
||||
{
|
||||
/**
|
||||
* Runs the subscriber.
|
||||
*/
|
||||
public function notify(Started $event): void
|
||||
{
|
||||
EnsureShardTimingsAreCollected::started($event);
|
||||
}
|
||||
}
|
||||
@ -1,75 +0,0 @@
|
||||
<?php
|
||||
|
||||
declare(strict_types=1);
|
||||
|
||||
namespace Pest\Subscribers;
|
||||
|
||||
use PHPUnit\Event\Telemetry\HRTime;
|
||||
use PHPUnit\Event\TestSuite\Finished;
|
||||
use PHPUnit\Event\TestSuite\Started;
|
||||
|
||||
/**
|
||||
* @internal
|
||||
*/
|
||||
final class EnsureShardTimingsAreCollected
|
||||
{
|
||||
/**
|
||||
* The start times for each test class.
|
||||
*
|
||||
* @var array<string, HRTime>
|
||||
*/
|
||||
private static array $startTimes = [];
|
||||
|
||||
/**
|
||||
* The collected timings for each test class.
|
||||
*
|
||||
* @var array<string, float>
|
||||
*/
|
||||
private static array $timings = [];
|
||||
|
||||
/**
|
||||
* Records the start time for a test suite.
|
||||
*/
|
||||
public static function started(Started $event): void
|
||||
{
|
||||
if (! $event->testSuite()->isForTestClass()) {
|
||||
return;
|
||||
}
|
||||
|
||||
$name = preg_replace('/^P\\\\/', '', $event->testSuite()->name());
|
||||
|
||||
if (is_string($name)) {
|
||||
self::$startTimes[$name] = $event->telemetryInfo()->time();
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Records the duration for a test suite.
|
||||
*/
|
||||
public static function finished(Finished $event): void
|
||||
{
|
||||
if (! $event->testSuite()->isForTestClass()) {
|
||||
return;
|
||||
}
|
||||
|
||||
$name = preg_replace('/^P\\\\/', '', $event->testSuite()->name());
|
||||
|
||||
if (! is_string($name) || ! isset(self::$startTimes[$name])) {
|
||||
return;
|
||||
}
|
||||
|
||||
$duration = $event->telemetryInfo()->time()->duration(self::$startTimes[$name]);
|
||||
|
||||
self::$timings[$name] = round($duration->asFloat(), 4);
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the collected timings.
|
||||
*
|
||||
* @return array<string, float>
|
||||
*/
|
||||
public static function timings(): array
|
||||
{
|
||||
return self::$timings;
|
||||
}
|
||||
}
|
||||
@ -23,9 +23,7 @@ final class Backtrace
|
||||
$current = null;
|
||||
|
||||
foreach (debug_backtrace(self::BACKTRACE_OPTIONS) as $trace) {
|
||||
if (array_key_exists(self::FILE, $trace) === false) {
|
||||
break;
|
||||
}
|
||||
assert(array_key_exists(self::FILE, $trace));
|
||||
|
||||
$traceFile = str_replace(DIRECTORY_SEPARATOR, '/', $trace[self::FILE]);
|
||||
|
||||
|
||||
@ -8,6 +8,7 @@ use Pest\Exceptions\ShouldNotHappen;
|
||||
use SebastianBergmann\CodeCoverage\CodeCoverage;
|
||||
use SebastianBergmann\CodeCoverage\Node\Directory;
|
||||
use SebastianBergmann\CodeCoverage\Node\File;
|
||||
use SebastianBergmann\CodeCoverage\Report\Facade;
|
||||
use SebastianBergmann\Environment\Runtime;
|
||||
use Symfony\Component\Console\Output\OutputInterface;
|
||||
|
||||
@ -74,7 +75,7 @@ final class Coverage
|
||||
* Reports the code coverage report to the
|
||||
* console and returns the result in float.
|
||||
*/
|
||||
public static function report(OutputInterface $output, bool $compact = false, bool $showOnlyCovered = false): float
|
||||
public static function report(OutputInterface $output, bool $compact = false): float
|
||||
{
|
||||
if (! file_exists($reportPath = self::getPath())) {
|
||||
if (self::usingXdebug()) {
|
||||
@ -92,10 +93,18 @@ final class Coverage
|
||||
$codeCoverage = require $reportPath;
|
||||
unlink($reportPath);
|
||||
|
||||
$totalCoverage = $codeCoverage->getReport()->percentageOfExecutedLines();
|
||||
// @phpstan-ignore-next-line
|
||||
if (is_array($codeCoverage)) {
|
||||
$facade = Facade::fromSerializedData($codeCoverage);
|
||||
|
||||
/** @var Directory<File|Directory> $report */
|
||||
$report = $codeCoverage->getReport();
|
||||
/** @var Directory<File|Directory> $report */
|
||||
$report = (fn (): Directory => $this->report)->call($facade);
|
||||
} else {
|
||||
/** @var Directory<File|Directory> $report */
|
||||
$report = $codeCoverage->getReport();
|
||||
}
|
||||
|
||||
$totalCoverage = $report->percentageOfExecutedLines();
|
||||
|
||||
foreach ($report->getIterator() as $file) {
|
||||
if (! $file instanceof File) {
|
||||
@ -109,10 +118,6 @@ final class Coverage
|
||||
$basename,
|
||||
]);
|
||||
|
||||
if ($showOnlyCovered && $file->percentageOfExecutedLines()->asFloat() === 0.0) {
|
||||
continue;
|
||||
}
|
||||
|
||||
$percentage = $file->numberOfExecutableLines() === 0
|
||||
? '100.0'
|
||||
: number_format($file->percentageOfExecutedLines()->asFloat(), 1, '.', '');
|
||||
|
||||
@ -17,7 +17,7 @@ final class DatasetInfo
|
||||
|
||||
public static function isInsideADatasetsDirectory(string $file): bool
|
||||
{
|
||||
return in_array(self::DATASETS_DIR_NAME, self::directorySegmentsInsideTestsDirectory($file), true);
|
||||
return basename(dirname($file)) === self::DATASETS_DIR_NAME;
|
||||
}
|
||||
|
||||
public static function isADatasetsFile(string $file): bool
|
||||
@ -32,23 +32,7 @@ final class DatasetInfo
|
||||
}
|
||||
|
||||
if (self::isInsideADatasetsDirectory($file)) {
|
||||
$scope = [];
|
||||
|
||||
foreach (self::directorySegmentsInsideTestsDirectory($file) as $segment) {
|
||||
if ($segment === self::DATASETS_DIR_NAME) {
|
||||
break;
|
||||
}
|
||||
|
||||
$scope[] = $segment;
|
||||
}
|
||||
|
||||
$testsDirectoryPath = self::testsDirectoryPath($file);
|
||||
|
||||
if ($scope === []) {
|
||||
return $testsDirectoryPath;
|
||||
}
|
||||
|
||||
return $testsDirectoryPath.DIRECTORY_SEPARATOR.implode(DIRECTORY_SEPARATOR, $scope);
|
||||
return dirname($file, 2);
|
||||
}
|
||||
|
||||
if (self::isADatasetsFile($file)) {
|
||||
@ -57,45 +41,4 @@ final class DatasetInfo
|
||||
|
||||
return $file;
|
||||
}
|
||||
|
||||
/**
|
||||
* @return list<string>
|
||||
*/
|
||||
private static function directorySegmentsInsideTestsDirectory(string $file): array
|
||||
{
|
||||
$directory = dirname(self::pathInsideTestsDirectory($file));
|
||||
|
||||
if ($directory === '.' || $directory === DIRECTORY_SEPARATOR) {
|
||||
return [];
|
||||
}
|
||||
|
||||
return array_values(array_filter(
|
||||
explode(DIRECTORY_SEPARATOR, trim($directory, DIRECTORY_SEPARATOR)),
|
||||
static fn (string $segment): bool => $segment !== '',
|
||||
));
|
||||
}
|
||||
|
||||
private static function pathInsideTestsDirectory(string $file): string
|
||||
{
|
||||
$testsDirectory = DIRECTORY_SEPARATOR.trim(testDirectory(), DIRECTORY_SEPARATOR).DIRECTORY_SEPARATOR;
|
||||
$position = strrpos($file, $testsDirectory);
|
||||
|
||||
if ($position === false) {
|
||||
return $file;
|
||||
}
|
||||
|
||||
return substr($file, $position + strlen($testsDirectory));
|
||||
}
|
||||
|
||||
private static function testsDirectoryPath(string $file): string
|
||||
{
|
||||
$testsDirectory = DIRECTORY_SEPARATOR.trim(testDirectory(), DIRECTORY_SEPARATOR).DIRECTORY_SEPARATOR;
|
||||
$position = strrpos($file, $testsDirectory);
|
||||
|
||||
if ($position === false) {
|
||||
return dirname($file);
|
||||
}
|
||||
|
||||
return substr($file, 0, $position + strlen($testsDirectory) - 1);
|
||||
}
|
||||
}
|
||||
|
||||
@ -86,4 +86,17 @@ final readonly class Exporter
|
||||
|
||||
return (string) preg_replace(array_keys($map), array_values($map), $this->exporter->shortenedExport($value));
|
||||
}
|
||||
|
||||
/**
|
||||
* Exports a value into a full single-line string without truncation.
|
||||
*/
|
||||
public function export(mixed $value): string
|
||||
{
|
||||
$map = [
|
||||
'#\\\n\s*#' => '',
|
||||
'# Object \(\.{3}\)#' => '',
|
||||
];
|
||||
|
||||
return (string) preg_replace(array_keys($map), array_values($map), $this->exporter->export($value));
|
||||
}
|
||||
}
|
||||
|
||||
@ -50,7 +50,7 @@ final class HigherOrderMessage
|
||||
}
|
||||
|
||||
if ($this->hasHigherOrderCallable()) {
|
||||
return (new HigherOrderCallables($target))->{$this->name}(...$this->arguments);
|
||||
return new HigherOrderCallables($target)->{$this->name}(...$this->arguments);
|
||||
}
|
||||
|
||||
try {
|
||||
|
||||
@ -31,7 +31,7 @@ final class HigherOrderMessageCollection
|
||||
*/
|
||||
public function addWhen(callable $condition, string $filename, int $line, string $name, ?array $arguments): void
|
||||
{
|
||||
$this->messages[] = (new HigherOrderMessage($filename, $line, $name, $arguments))->when($condition);
|
||||
$this->messages[] = new HigherOrderMessage($filename, $line, $name, $arguments)->when($condition);
|
||||
}
|
||||
|
||||
/**
|
||||
|
||||
@ -38,7 +38,7 @@ final class HigherOrderTapProxy
|
||||
return $this->target->{$property};
|
||||
}
|
||||
|
||||
$className = (new ReflectionClass($this->target))->getName();
|
||||
$className = new ReflectionClass($this->target)->getName();
|
||||
|
||||
if (str_starts_with($className, 'P\\')) {
|
||||
$className = substr($className, 2);
|
||||
@ -60,7 +60,7 @@ final class HigherOrderTapProxy
|
||||
$filename = Backtrace::file();
|
||||
$line = Backtrace::line();
|
||||
|
||||
return (new HigherOrderMessage($filename, $line, $methodName, $arguments))
|
||||
return new HigherOrderMessage($filename, $line, $methodName, $arguments)
|
||||
->call($this->target);
|
||||
}
|
||||
}
|
||||
|
||||
@ -181,7 +181,7 @@ final class Reflection
|
||||
*/
|
||||
public static function getFunctionArguments(Closure $function): array
|
||||
{
|
||||
$parameters = (new ReflectionFunction($function))->getParameters();
|
||||
$parameters = new ReflectionFunction($function)->getParameters();
|
||||
$arguments = [];
|
||||
|
||||
foreach ($parameters as $parameter) {
|
||||
@ -207,7 +207,7 @@ final class Reflection
|
||||
|
||||
public static function getFunctionVariable(Closure $function, string $key): mixed
|
||||
{
|
||||
return (new ReflectionFunction($function))->getStaticVariables()[$key] ?? null;
|
||||
return new ReflectionFunction($function)->getStaticVariables()[$key] ?? null;
|
||||
}
|
||||
|
||||
/**
|
||||
|
||||
@ -11,10 +11,6 @@ use PHPUnit\Event\Code\TestDoxBuilder;
|
||||
use PHPUnit\Event\Code\TestMethod;
|
||||
use PHPUnit\Event\Code\ThrowableBuilder;
|
||||
use PHPUnit\Event\Test\Errored;
|
||||
use PHPUnit\Event\Test\PhpunitDeprecationTriggered;
|
||||
use PHPUnit\Event\Test\PhpunitErrorTriggered;
|
||||
use PHPUnit\Event\Test\PhpunitNoticeTriggered;
|
||||
use PHPUnit\Event\Test\PhpunitWarningTriggered;
|
||||
use PHPUnit\Event\TestData\TestDataCollection;
|
||||
use PHPUnit\Framework\SkippedWithMessageException;
|
||||
use PHPUnit\Metadata\MetadataCollection;
|
||||
@ -47,8 +43,6 @@ final class StateGenerator
|
||||
));
|
||||
}
|
||||
|
||||
$this->addTriggeredPhpunitEvents($state, $testResult->testTriggeredPhpunitErrorEvents(), TestResult::FAIL);
|
||||
|
||||
foreach ($testResult->testMarkedIncompleteEvents() as $testResultEvent) {
|
||||
$state->add(TestResult::fromPestParallelTestCase(
|
||||
$testResultEvent->test(),
|
||||
@ -105,8 +99,6 @@ final class StateGenerator
|
||||
}
|
||||
}
|
||||
|
||||
$this->addTriggeredPhpunitEvents($state, $testResult->testTriggeredPhpunitDeprecationEvents(), TestResult::DEPRECATED);
|
||||
|
||||
foreach ($testResult->notices() as $testResultEvent) {
|
||||
foreach ($testResultEvent->triggeringTests() as $triggeringTest) {
|
||||
['test' => $test] = $triggeringTest;
|
||||
@ -131,8 +123,6 @@ final class StateGenerator
|
||||
}
|
||||
}
|
||||
|
||||
$this->addTriggeredPhpunitEvents($state, $testResult->testTriggeredPhpunitNoticeEvents(), TestResult::NOTICE);
|
||||
|
||||
foreach ($testResult->warnings() as $testResultEvent) {
|
||||
foreach ($testResultEvent->triggeringTests() as $triggeringTest) {
|
||||
['test' => $test] = $triggeringTest;
|
||||
@ -145,8 +135,6 @@ final class StateGenerator
|
||||
}
|
||||
}
|
||||
|
||||
$this->addTriggeredPhpunitEvents($state, $testResult->testTriggeredPhpunitWarningEvents(), TestResult::WARN);
|
||||
|
||||
foreach ($testResult->phpWarnings() as $testResultEvent) {
|
||||
foreach ($testResultEvent->triggeringTests() as $triggeringTest) {
|
||||
['test' => $test] = $triggeringTest;
|
||||
@ -177,24 +165,4 @@ final class StateGenerator
|
||||
|
||||
return $state;
|
||||
}
|
||||
|
||||
/**
|
||||
* @param array<string, list<PhpunitDeprecationTriggered|PhpunitErrorTriggered|PhpunitNoticeTriggered|PhpunitWarningTriggered>> $testResultEvents
|
||||
*/
|
||||
private function addTriggeredPhpunitEvents(State $state, array $testResultEvents, string $type): void
|
||||
{
|
||||
foreach ($testResultEvents as $events) {
|
||||
foreach ($events as $event) {
|
||||
if (! $event->test()->isTestMethod()) {
|
||||
continue;
|
||||
}
|
||||
|
||||
$state->add(TestResult::fromPestParallelTestCase(
|
||||
$event->test(),
|
||||
$type,
|
||||
ThrowableBuilder::from(new TestOutcome($event->message()))
|
||||
));
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@ -1,19 +0,0 @@
|
||||
<?php
|
||||
|
||||
declare(strict_types=1);
|
||||
|
||||
namespace Pest\TestCaseMethodFilters;
|
||||
|
||||
use Pest\Contracts\TestCaseMethodFilter;
|
||||
use Pest\Factories\TestCaseMethodFactory;
|
||||
|
||||
final readonly class FlakyTestCaseFilter implements TestCaseMethodFilter
|
||||
{
|
||||
/**
|
||||
* Filter the test case methods.
|
||||
*/
|
||||
public function accept(TestCaseMethodFactory $factory): bool
|
||||
{
|
||||
return $factory->flakyTries !== null;
|
||||
}
|
||||
}
|
||||
@ -10,7 +10,7 @@ use Tests\TestCase;
|
||||
|
|
||||
| The closure you provide to your test functions is always bound to a specific PHPUnit test
|
||||
| case class. By default, that class is "PHPUnit\Framework\TestCase". Of course, you may
|
||||
| need to change it using the "pest()" function to bind different classes or traits.
|
||||
| need to change it using the "pest()" function to bind a different classes or traits.
|
||||
|
|
||||
*/
|
||||
|
||||
|
||||
@ -9,7 +9,7 @@ use Tests\TestCase;
|
||||
|
|
||||
| The closure you provide to your test functions is always bound to a specific PHPUnit test
|
||||
| case class. By default, that class is "PHPUnit\Framework\TestCase". Of course, you may
|
||||
| need to change it using the "pest()" function to bind different classes or traits.
|
||||
| need to change it using the "pest()" function to bind a different classes or traits.
|
||||
|
|
||||
*/
|
||||
|
||||
|
||||
@ -0,0 +1,7 @@
|
||||
<div class="container">
|
||||
<div class="row">
|
||||
<div class="col-md-12">
|
||||
<h1>Snapshot</h1>
|
||||
</div>
|
||||
</div>
|
||||
</div>
|
||||
@ -0,0 +1,7 @@
|
||||
<div class="container">
|
||||
<div class="row">
|
||||
<div class="col-md-12">
|
||||
<h1>Snapshot</h1>
|
||||
</div>
|
||||
</div>
|
||||
</div>
|
||||
@ -1,5 +1,5 @@
|
||||
|
||||
Pest Testing Framework 4.6.3.
|
||||
Pest Testing Framework 5.0.0-rc.3.
|
||||
|
||||
USAGE: pest <file> [options]
|
||||
|
||||
@ -28,7 +28,6 @@
|
||||
--pull-request Output to standard output tests with the given pull request number (alias for --pr)
|
||||
--retry Run non-passing tests first and stop execution upon first error or failure
|
||||
--dirty ...... Only run tests that have uncommitted changes according to Git
|
||||
--flaky .................... Output to standard output tests marked as flaky
|
||||
--all .................... Ignore test selection from XML configuration file
|
||||
--list-suites ................................... List available test suites
|
||||
--testsuite [name] ......... Only run tests from the specified test suite(s)
|
||||
@ -45,11 +44,11 @@
|
||||
--filter [pattern] ............................... Filter which tests to run
|
||||
--exclude-filter [pattern] .. Exclude tests for the specified filter pattern
|
||||
--test-suffix [suffixes] Only search for test in files with specified suffix(es). Default: Test.php,.phpt
|
||||
--test-files-file [file] Only run test files listed in file (one file by line)
|
||||
|
||||
EXECUTION OPTIONS:
|
||||
--parallel ........................................... Run tests in parallel
|
||||
--update-snapshots Update snapshots for tests using the "toMatchSnapshot" expectation
|
||||
--update-shards Update shards.json with test timing data for time-balanced sharding
|
||||
--globals-backup ................. Backup and restore $GLOBALS for each test
|
||||
--static-backup ......... Backup and restore static properties for each test
|
||||
--strict-coverage ................... Be strict about code coverage metadata
|
||||
@ -91,11 +90,7 @@
|
||||
--cache-result ............................ Write test results to cache file
|
||||
--do-not-cache-result .............. Do not write test results to cache file
|
||||
--order-by [order] Run tests in order: default|defects|depends|duration|no-depends|random|reverse|size
|
||||
--resolve-dependencies ...................... Alias for "--order-by depends"
|
||||
--ignore-dependencies .................... Alias for "--order-by no-depends"
|
||||
--random-order ............................... Alias for "--order-by random"
|
||||
--random-order-seed [N] Use the specified random seed when running tests in random order
|
||||
--reverse-order ............................. Alias for "--order-by reverse"
|
||||
|
||||
REPORTING OPTIONS:
|
||||
--colors=[flag] ......... Use colors in output ("never", "auto" or "always")
|
||||
@ -125,19 +120,17 @@
|
||||
LOGGING OPTIONS:
|
||||
--log-junit [file] .......... Write test results in JUnit XML format to file
|
||||
--log-otr [file] Write test results in Open Test Reporting XML format to file
|
||||
--include-git-information Include Git information in Open Test Reporting XML logfile
|
||||
--log-teamcity [file] ........ Write test results in TeamCity format to file
|
||||
--testdox-html [file] .. Write test results in TestDox format (HTML) to file
|
||||
--testdox-text [file] Write test results in TestDox format (plain text) to file
|
||||
--log-events-text [file] ............... Stream events as plain text to file
|
||||
--log-events-verbose-text [file] Stream events as plain text with extended information to file
|
||||
--include-git-information ..... Include Git information in supported formats
|
||||
--no-logging ....... Ignore logging configured in the XML configuration file
|
||||
|
||||
CODE COVERAGE OPTIONS:
|
||||
--coverage ..... Generate code coverage report and output to standard output
|
||||
--coverage --min Set the minimum required coverage percentage, and fail if not met
|
||||
--coverage --exactly Set the exact required coverage percentage, and fail if not met
|
||||
--coverage --only-covered Hide files with 0% coverage from the code coverage report
|
||||
--coverage-clover [file] Write code coverage report in Clover XML format to file
|
||||
--coverage-openclover [file] Write code coverage report in OpenClover XML format to file
|
||||
--coverage-cobertura [file] Write code coverage report in Cobertura XML format to file
|
||||
|
||||
@ -15,9 +15,6 @@
|
||||
↓ todo on describe → should not fail
|
||||
↓ todo on describe → should run
|
||||
|
||||
TODO Tests\Features\Flaky - 1 todo
|
||||
↓ it does not retry todo tests
|
||||
|
||||
TODO Tests\Features\Todo - 29 todos
|
||||
↓ something todo later
|
||||
↓ something todo later chained
|
||||
@ -84,6 +81,6 @@
|
||||
PASS Tests\CustomTestCase\ParentTest
|
||||
✓ override method
|
||||
|
||||
Tests: 40 todos, 3 passed (21 assertions)
|
||||
Tests: 39 todos, 3 passed (21 assertions)
|
||||
Duration: x.xxs
|
||||
|
||||
|
||||
@ -15,9 +15,6 @@
|
||||
↓ todo on describe → should not fail
|
||||
↓ todo on describe → should run
|
||||
|
||||
TODO Tests\Features\Flaky - 1 todo
|
||||
↓ it does not retry todo tests
|
||||
|
||||
TODO Tests\Features\Todo - 29 todos
|
||||
↓ something todo later
|
||||
↓ something todo later chained
|
||||
@ -84,6 +81,6 @@
|
||||
PASS Tests\CustomTestCase\ParentTest
|
||||
✓ override method
|
||||
|
||||
Tests: 40 todos, 3 passed (21 assertions)
|
||||
Tests: 39 todos, 3 passed (21 assertions)
|
||||
Duration: x.xxs
|
||||
|
||||
|
||||
@ -15,9 +15,6 @@
|
||||
↓ todo on describe → should not fail
|
||||
↓ todo on describe → should run
|
||||
|
||||
TODO Tests\Features\Flaky - 1 todo
|
||||
↓ it does not retry todo tests
|
||||
|
||||
TODO Tests\Features\Todo - 29 todos
|
||||
↓ something todo later
|
||||
↓ something todo later chained
|
||||
@ -84,6 +81,6 @@
|
||||
PASS Tests\CustomTestCase\ParentTest
|
||||
✓ override method
|
||||
|
||||
Tests: 40 todos, 3 passed (21 assertions)
|
||||
Tests: 39 todos, 3 passed (21 assertions)
|
||||
Duration: x.xxs
|
||||
|
||||
|
||||
@ -15,9 +15,6 @@
|
||||
↓ todo on describe → should not fail
|
||||
↓ todo on describe → should run
|
||||
|
||||
TODO Tests\Features\Flaky - 1 todo
|
||||
↓ it does not retry todo tests
|
||||
|
||||
TODO Tests\Features\Todo - 29 todos
|
||||
↓ something todo later
|
||||
↓ something todo later chained
|
||||
@ -84,6 +81,6 @@
|
||||
PASS Tests\CustomTestCase\ParentTest
|
||||
✓ override method
|
||||
|
||||
Tests: 40 todos, 3 passed (21 assertions)
|
||||
Tests: 39 todos, 3 passed (21 assertions)
|
||||
Duration: x.xxs
|
||||
|
||||
|
||||
@ -1,3 +1,3 @@
|
||||
|
||||
Pest Testing Framework 4.6.3.
|
||||
Pest Testing Framework 5.0.0-rc.3.
|
||||
|
||||
|
||||
@ -95,48 +95,6 @@
|
||||
PASS Tests\Features\Covers\TraitCoverage
|
||||
✓ it uses the correct PHPUnit attribute for trait
|
||||
|
||||
PASS Tests\Features\DatasetMethodChaining
|
||||
✓ beforeEach()->with() applies dataset to tests → receives the dataset value with (10)
|
||||
✓ beforeEach()->with() applies dataset to tests → it also receives the dataset value in it() with (10)
|
||||
✓ beforeEach()->with() with multiple dataset values → receives each value from the dataset with (1)
|
||||
✓ beforeEach()->with() with multiple dataset values → receives each value from the dataset with (2)
|
||||
✓ beforeEach()->with() with multiple dataset values → receives each value from the dataset with (3)
|
||||
✓ beforeEach()->with() with keyed dataset → receives keyed dataset values with dataset "first"
|
||||
✓ beforeEach()->with() with keyed dataset → receives keyed dataset values with dataset "second"
|
||||
✓ beforeEach()->with() with closure dataset → receives values from closure dataset with (100)
|
||||
✓ beforeEach()->with() with closure dataset → receives values from closure dataset with (200)
|
||||
✓ describe()->with() passes dataset to tests → receives the dataset value with (42)
|
||||
✓ describe()->with() passes dataset to tests → it also receives it in it() with (42)
|
||||
✓ describe()->with() with multiple values → receives each value with (5)
|
||||
✓ describe()->with() with multiple values → receives each value with (10)
|
||||
✓ describe()->with() with multiple values → receives each value with (15)
|
||||
✓ describe()->with() with keyed dataset → receives keyed values with dataset "alpha"
|
||||
✓ describe()->with() with keyed dataset → receives keyed values with dataset "beta"
|
||||
✓ describe()->with() with closure dataset → receives closure dataset values with (7)
|
||||
✓ describe()->with() with closure dataset → receives closure dataset values with (14)
|
||||
✓ outer with dataset → inner without dataset → inherits outer dataset with (1)
|
||||
✓ nested describe blocks with datasets at multiple levels → level 1 → receives level 1 dataset with (10)
|
||||
✓ nested describe blocks with datasets at multiple levels → level 1 → level 2 → receives datasets from all ancestor levels with (10) / (20)
|
||||
✓ deeply nested describe with datasets → a → b → c → receives all ancestor datasets with (1) / (2) / (3)
|
||||
✓ beforeEach()->with() combined with test->with() → receives both datasets as cross product with (10) / (1)
|
||||
✓ beforeEach()->with() combined with test->with() → receives both datasets as cross product with (10) / (2)
|
||||
✓ describe()->with() combined with test->with() → receives both datasets with (5) / (50)
|
||||
✓ describe()->with() combined with test->with() → receives both datasets with (5) / (60)
|
||||
✓ beforeEach closure and beforeEach()->with() coexist → has both the closure state and dataset with (99)
|
||||
✓ beforeEach()->with() does not interfere with closure hooks → closures run in order and dataset is applied with (42)
|
||||
✓ first describe with dataset → gets its own dataset with (111)
|
||||
✓ second describe with different dataset → gets its own dataset, not the sibling with (222)
|
||||
✓ third describe without dataset → has no dataset leaking from siblings
|
||||
✓ describe()->with() with beforeEach closure → both hook and dataset work with (77)
|
||||
✓ describe()->with() with afterEach closure → dataset is available and afterEach runs with (88)
|
||||
✓ multiple tests share the same beforeEach dataset → first test gets the dataset with (33)
|
||||
✓ multiple tests share the same beforeEach dataset → second test also gets the dataset with (33)
|
||||
✓ multiple tests share the same beforeEach dataset → it third test with it() also gets the dataset with (33)
|
||||
✓ outer describe → inner describe with dataset on hook → inherits outer beforeEach and has inner dataset with (55)
|
||||
✓ outer describe → outer test is unaffected by inner dataset
|
||||
✓ describe()->with() preserves depends → first with (9)
|
||||
✓ describe()->with() preserves depends → second with (9)
|
||||
|
||||
PASS Tests\Features\DatasetsTests - 1 todo
|
||||
✓ it throws exception if dataset does not exist
|
||||
✓ it throws exception if dataset already exist
|
||||
@ -257,20 +215,6 @@
|
||||
✓ it may be used with high order after describe block with dataset "formal"
|
||||
✓ it may be used with high order after describe block with dataset "informal"
|
||||
✓ after describe block with named dataset with ('after')
|
||||
✓ named parameters match by parameter name with ('Taylor', 'taylor@laravel.com')
|
||||
✓ named parameters work with multiple dataset items with ('Taylor', 'taylor@laravel.com')
|
||||
✓ named parameters work with multiple dataset items with ('James', 'james@laravel.com')
|
||||
✓ named parameters work in different order than closure params with ('a', 'b', 'c')
|
||||
✓ named parameters work with named dataset keys with dataset "taylor"
|
||||
✓ named parameters work with named dataset keys with dataset "james"
|
||||
✓ named parameters work with closures that should be resolved with (Closure Object (), Closure Object ())
|
||||
✓ named parameters work with closure type hints with ('Taylor', Closure Object ())
|
||||
✓ named parameters work with registered datasets with ('Taylor', 'taylor@laravel.com')
|
||||
✓ named parameters work with registered datasets with ('James', 'james@laravel.com')
|
||||
✓ named parameters work with bound closure returning associative array with (Closure Object ())
|
||||
✓ dataset items can mix named and sequential styles with ('Taylor', 'taylor@laravel.com')
|
||||
✓ dataset items can mix named and sequential styles with ('James', 'james@laravel.com') #1
|
||||
✓ dataset items can mix named and sequential styles with ('James', 'james@laravel.com') #2
|
||||
|
||||
PASS Tests\Features\Depends
|
||||
✓ first
|
||||
@ -504,10 +448,6 @@
|
||||
✓ failures with custom message
|
||||
✓ not failures
|
||||
|
||||
PASS Tests\Features\Expect\toBeCasedCorrectly
|
||||
✓ pass
|
||||
✓ failure
|
||||
|
||||
PASS Tests\Features\Expect\toBeDigits
|
||||
✓ pass
|
||||
✓ failures
|
||||
@ -1037,6 +977,8 @@
|
||||
✓ pass with toArray
|
||||
✓ pass with array
|
||||
✓ pass with toSnapshot
|
||||
✓ failures
|
||||
✓ failures with custom message
|
||||
✓ not failures
|
||||
✓ multiple snapshot expectations
|
||||
✓ multiple snapshot expectations with datasets with (1)
|
||||
@ -1092,10 +1034,6 @@
|
||||
✓ pass
|
||||
✓ failures
|
||||
✓ not failures
|
||||
✓ trait inheritance - direct usage
|
||||
✓ trait inheritance - inherited usage
|
||||
✓ trait inheritance - negative case
|
||||
✓ nested trait inheritance
|
||||
|
||||
PASS Tests\Features\Expect\unless
|
||||
✓ it pass
|
||||
@ -1127,40 +1065,6 @@
|
||||
✓ it may return a file path
|
||||
✓ it may throw an exception if the file does not exist
|
||||
|
||||
WARN Tests\Features\Flaky - 1 todo
|
||||
✓ it passes on first try
|
||||
✓ it passes on a subsequent try
|
||||
✓ it has a default of 3 tries
|
||||
✓ it succeeds on the last possible try
|
||||
✓ it works with tries of 1
|
||||
✓ it retries assertion failures
|
||||
✓ it works with a dataset with (1)
|
||||
✓ it works with a dataset with (2)
|
||||
✓ it works with a dataset with (3)
|
||||
✓ it retries each dataset independently with ('alpha')
|
||||
✓ it retries each dataset independently with ('beta')
|
||||
✓ within a describe block → it retries inside describe
|
||||
✓ lifecycle hooks with flaky → it re-runs beforeEach on each retry
|
||||
✓ afterEach with flaky → it runs afterEach between retries
|
||||
- it does not retry skipped tests → intentionally skipped
|
||||
✓ it works with repeat and flaky @ repetition 1 of 2
|
||||
✓ it works with repeat and flaky @ repetition 2 of 2
|
||||
✓ it works as higher order test
|
||||
✓ it fails after exhausting all retries
|
||||
✓ it throws when tries is less than 1
|
||||
✓ it throws when tries is negative
|
||||
↓ it does not retry todo tests
|
||||
✓ it retries php errors
|
||||
✓ it works with throws and flaky
|
||||
✓ it does not retry expected exceptions
|
||||
✓ it does not retry fails()
|
||||
✓ it retries unexpected exceptions even with throws set
|
||||
✓ it does not leak mock objects between retries
|
||||
✓ it does not stop retrying when snapshot changes are absent
|
||||
✓ it does not leak dynamic properties between retries
|
||||
✓ it clears output buffer between retries when expectOutputString is used
|
||||
✓ it preserves output between retries when no output expectation is set
|
||||
|
||||
WARN Tests\Features\Helpers
|
||||
✓ it can set/get properties on $this
|
||||
! it gets null if property do not exist → Undefined property Tests\Features\Helpers::$wqdwqdqw
|
||||
@ -1586,10 +1490,6 @@
|
||||
PASS Tests\Fixtures\ExampleTest
|
||||
✓ it example 2
|
||||
|
||||
PASS Tests\Fixtures\ParallelNestedDatasets\TestFileWithNestedDataset
|
||||
✓ loads nested dataset with ('alice')
|
||||
✓ loads nested dataset with ('bob')
|
||||
|
||||
WARN Tests\Fixtures\UnexpectedOutput
|
||||
- output
|
||||
|
||||
@ -1740,14 +1640,9 @@
|
||||
✓ it cannot resolve a parameter without type
|
||||
|
||||
PASS Tests\Unit\Support\DatasetInfo
|
||||
✓ it can check if dataset is defined inside a Datasets directory with ('/var/www/Datasets/project/tes…rs.php', true) #1
|
||||
✓ it can check if dataset is defined inside a Datasets directory with ('/var/www/Datasets/project/tes…rs.php', true) #2
|
||||
✓ it can check if dataset is defined inside a Datasets directory with ('/var/www/project/tests/Datase…rs.php', true) #1
|
||||
✓ it can check if dataset is defined inside a Datasets directory with ('/var/www/project/tests/Datase…rs.php', true) #2
|
||||
✓ it can check if dataset is defined inside a Datasets directory with ('/var/www/project/tests/Datase…rs.php', true)
|
||||
✓ it can check if dataset is defined inside a Datasets directory with ('/var/www/project/tests/Datasets.php', false)
|
||||
✓ it can check if dataset is defined inside a Datasets directory with ('/var/www/project/tests/Featur…rs.php', true) #1
|
||||
✓ it can check if dataset is defined inside a Datasets directory with ('/var/www/project/tests/Featur…rs.php', true) #2
|
||||
✓ it can check if dataset is defined inside a Datasets directory with ('/var/www/project/tests/Featur…rs.php', true) #3
|
||||
✓ it can check if dataset is defined inside a Datasets directory with ('/var/www/project/tests/Featur…rs.php', true)
|
||||
✓ it can check if dataset is defined inside a Datasets directory with ('/var/www/project/tests/Featur…rs.php', false)
|
||||
✓ it can check if dataset is defined inside a Datasets directory with ('/var/www/project/tests/Featur…ts.php', false)
|
||||
✓ it can check if dataset is defined inside a Datasets.php file with ('/var/www/project/tests/Datase…rs.php', false)
|
||||
@ -1755,18 +1650,12 @@
|
||||
✓ it can check if dataset is defined inside a Datasets.php file with ('/var/www/project/tests/Featur…rs.php', false) #1
|
||||
✓ it can check if dataset is defined inside a Datasets.php file with ('/var/www/project/tests/Featur…rs.php', false) #2
|
||||
✓ it can check if dataset is defined inside a Datasets.php file with ('/var/www/project/tests/Featur…ts.php', true)
|
||||
✓ it computes the dataset scope with ('/var/www/Datasets/project/tes…rs.php', '/var/www/Datasets/project/tests')
|
||||
✓ it computes the dataset scope with ('/var/www/Datasets/project/tes…rs.php', '/var/www/Datasets/project/tes…atures')
|
||||
✓ it computes the dataset scope with ('/var/www/project/tests/Datase…rs.php', '/var/www/project/tests') #1
|
||||
✓ it computes the dataset scope with ('/var/www/project/tests/Datase…rs.php', '/var/www/project/tests') #2
|
||||
✓ it computes the dataset scope with ('/var/www/project/tests/Datase…rs.php', '/var/www/project/tests')
|
||||
✓ it computes the dataset scope with ('/var/www/project/tests/Datasets.php', '/var/www/project/tests')
|
||||
✓ it computes the dataset scope with ('/var/www/project/tests/Featur…rs.php', '/var/www/project/tests/Features') #1
|
||||
✓ it computes the dataset scope with ('/var/www/project/tests/Featur…rs.php', '/var/www/project/tests/Features') #2
|
||||
✓ it computes the dataset scope with ('/var/www/project/tests/Featur…rs.php', '/var/www/project/tests/Features')
|
||||
✓ it computes the dataset scope with ('/var/www/project/tests/Featur…rs.php', '/var/www/project/tests/Featur…rs.php') #1
|
||||
✓ it computes the dataset scope with ('/var/www/project/tests/Featur…ts.php', '/var/www/project/tests/Features')
|
||||
✓ it computes the dataset scope with ('/var/www/project/tests/Featur…rs.php', '/var/www/project/tests/Featur…ollers') #1
|
||||
✓ it computes the dataset scope with ('/var/www/project/tests/Featur…rs.php', '/var/www/project/tests/Featur…ollers') #2
|
||||
✓ it computes the dataset scope with ('/var/www/project/tests/Featur…rs.php', '/var/www/project/tests/Features') #3
|
||||
✓ it computes the dataset scope with ('/var/www/project/tests/Featur…rs.php', '/var/www/project/tests/Featur…ollers')
|
||||
✓ it computes the dataset scope with ('/var/www/project/tests/Featur…rs.php', '/var/www/project/tests/Featur…rs.php') #2
|
||||
✓ it computes the dataset scope with ('/var/www/project/tests/Featur…ts.php', '/var/www/project/tests/Featur…ollers')
|
||||
|
||||
@ -1860,17 +1749,13 @@
|
||||
PASS Tests\Visual\Help
|
||||
✓ visual snapshot of help command output
|
||||
|
||||
PASS Tests\Visual\JUnit
|
||||
WARN Tests\Visual\JUnit
|
||||
✓ junit output
|
||||
✓ junit with parallel
|
||||
- junit with parallel → Not working yet
|
||||
|
||||
PASS Tests\Visual\Parallel
|
||||
✓ parallel
|
||||
✓ a parallel test can extend another test with same name
|
||||
✓ parallel reports invalid datasets as failures
|
||||
|
||||
PASS Tests\Visual\ParallelNestedDatasets
|
||||
✓ parallel loads nested datasets from nested directories
|
||||
|
||||
PASS Tests\Visual\SingleTestOrDirectory
|
||||
✓ allows to run a single test
|
||||
@ -1890,10 +1775,6 @@
|
||||
- todo
|
||||
- todo in parallel
|
||||
|
||||
PASS Tests\Visual\UnicodeFilename
|
||||
✓ filter works with unicode characters in filename
|
||||
✓ filter with unicode regex matches unicode filename
|
||||
|
||||
WARN Tests\Visual\Version
|
||||
- visual snapshot of help command output
|
||||
|
||||
@ -1901,4 +1782,4 @@
|
||||
✓ pass with dataset with ('my-datas-set-value')
|
||||
✓ within describe → pass with dataset with ('my-datas-set-value')
|
||||
|
||||
Tests: 2 deprecated, 4 warnings, 5 incomplete, 2 notices, 40 todos, 35 skipped, 1294 passed (2971 assertions)
|
||||
Tests: 2 deprecated, 4 warnings, 5 incomplete, 2 notices, 39 todos, 35 skipped, 1188 passed (2813 assertions)
|
||||
@ -1,5 +0,0 @@
|
||||
<?php
|
||||
|
||||
it('fails after exhausting all retries', function () {
|
||||
throw new Exception('Always fails');
|
||||
})->flaky(tries: 2);
|
||||
@ -1,5 +0,0 @@
|
||||
<?php
|
||||
|
||||
test('missing dataset', function (string $value) {
|
||||
expect($value)->toBe('x');
|
||||
})->with('missing.dataset');
|
||||
@ -1,3 +0,0 @@
|
||||
<?php
|
||||
|
||||
it('passes')->assertTrue(true);
|
||||
@ -1,3 +0,0 @@
|
||||
<?php
|
||||
|
||||
it('tests unicode filename with ß')->assertTrue(true);
|
||||
@ -17,9 +17,7 @@ arch()->preset()->security()->ignoring([
|
||||
'eval',
|
||||
'str_shuffle',
|
||||
'exec',
|
||||
'md5',
|
||||
'unserialize',
|
||||
'uniqid',
|
||||
'extract',
|
||||
'assert',
|
||||
]);
|
||||
|
||||
@ -1,287 +0,0 @@
|
||||
<?php
|
||||
|
||||
/**
|
||||
* Tests for dataset method chaining with hooks and describe blocks.
|
||||
*
|
||||
* Covers the fix from PR #1565: beforeEach()->with(), describe()->with(),
|
||||
* and nested describe blocks with datasets.
|
||||
*/
|
||||
|
||||
// ---------------------------------------------------------------
|
||||
// beforeEach()->with() inside describe blocks
|
||||
// ---------------------------------------------------------------
|
||||
|
||||
describe('beforeEach()->with() applies dataset to tests', function () {
|
||||
beforeEach()->with([10]);
|
||||
|
||||
test('receives the dataset value', function ($value) {
|
||||
expect($value)->toBe(10);
|
||||
});
|
||||
|
||||
it('also receives the dataset value in it()', function ($value) {
|
||||
expect($value)->toBe(10);
|
||||
});
|
||||
});
|
||||
|
||||
describe('beforeEach()->with() with multiple dataset values', function () {
|
||||
beforeEach()->with([1, 2, 3]);
|
||||
|
||||
test('receives each value from the dataset', function ($value) {
|
||||
expect($value)->toBeIn([1, 2, 3]);
|
||||
});
|
||||
});
|
||||
|
||||
describe('beforeEach()->with() with keyed dataset', function () {
|
||||
beforeEach()->with(['first' => [10], 'second' => [20]]);
|
||||
|
||||
test('receives keyed dataset values', function ($value) {
|
||||
expect($value)->toBeIn([10, 20]);
|
||||
});
|
||||
});
|
||||
|
||||
describe('beforeEach()->with() with closure dataset', function () {
|
||||
beforeEach()->with(function () {
|
||||
yield [100];
|
||||
yield [200];
|
||||
});
|
||||
|
||||
test('receives values from closure dataset', function ($value) {
|
||||
expect($value)->toBeIn([100, 200]);
|
||||
});
|
||||
});
|
||||
|
||||
// ---------------------------------------------------------------
|
||||
// describe()->with() method chaining
|
||||
// ---------------------------------------------------------------
|
||||
|
||||
describe('describe()->with() passes dataset to tests', function () {
|
||||
test('receives the dataset value', function ($value) {
|
||||
expect($value)->toBe(42);
|
||||
});
|
||||
|
||||
it('also receives it in it()', function ($value) {
|
||||
expect($value)->toBe(42);
|
||||
});
|
||||
})->with([42]);
|
||||
|
||||
describe('describe()->with() with multiple values', function () {
|
||||
test('receives each value', function ($value) {
|
||||
expect($value)->toBeIn([5, 10, 15]);
|
||||
});
|
||||
})->with([5, 10, 15]);
|
||||
|
||||
describe('describe()->with() with keyed dataset', function () {
|
||||
test('receives keyed values', function ($value) {
|
||||
expect($value)->toBeIn([100, 200]);
|
||||
});
|
||||
})->with(['alpha' => [100], 'beta' => [200]]);
|
||||
|
||||
describe('describe()->with() with closure dataset', function () {
|
||||
test('receives closure dataset values', function ($value) {
|
||||
expect($value)->toBeIn([7, 14]);
|
||||
});
|
||||
})->with(function () {
|
||||
yield [7];
|
||||
yield [14];
|
||||
});
|
||||
|
||||
// ---------------------------------------------------------------
|
||||
// Nested describe blocks with datasets
|
||||
// ---------------------------------------------------------------
|
||||
|
||||
describe('outer with dataset', function () {
|
||||
describe('inner without dataset', function () {
|
||||
test('inherits outer dataset', function (...$args) {
|
||||
expect($args)->toBe([1]);
|
||||
});
|
||||
});
|
||||
})->with([1]);
|
||||
|
||||
describe('nested describe blocks with datasets at multiple levels', function () {
|
||||
describe('level 1', function () {
|
||||
test('receives level 1 dataset', function (...$args) {
|
||||
expect($args)->toBe([10]);
|
||||
});
|
||||
|
||||
describe('level 2', function () {
|
||||
test('receives datasets from all ancestor levels', function (...$args) {
|
||||
expect($args)->toBe([10, 20]);
|
||||
});
|
||||
})->with([20]);
|
||||
})->with([10]);
|
||||
});
|
||||
|
||||
describe('deeply nested describe with datasets', function () {
|
||||
describe('a', function () {
|
||||
describe('b', function () {
|
||||
describe('c', function () {
|
||||
test('receives all ancestor datasets', function (...$args) {
|
||||
expect($args)->toBe([1, 2, 3]);
|
||||
});
|
||||
})->with([3]);
|
||||
})->with([2]);
|
||||
})->with([1]);
|
||||
});
|
||||
|
||||
// ---------------------------------------------------------------
|
||||
// Combining hook datasets with test-level datasets
|
||||
// ---------------------------------------------------------------
|
||||
|
||||
describe('beforeEach()->with() combined with test->with()', function () {
|
||||
beforeEach()->with([10]);
|
||||
|
||||
test('receives both datasets as cross product', function ($hookValue, $testValue) {
|
||||
expect($hookValue)->toBe(10);
|
||||
expect($testValue)->toBeIn([1, 2]);
|
||||
})->with([1, 2]);
|
||||
});
|
||||
|
||||
describe('describe()->with() combined with test->with()', function () {
|
||||
test('receives both datasets', function ($describeValue, $testValue) {
|
||||
expect($describeValue)->toBe(5);
|
||||
expect($testValue)->toBeIn([50, 60]);
|
||||
})->with([50, 60]);
|
||||
})->with([5]);
|
||||
|
||||
// ---------------------------------------------------------------
|
||||
// beforeEach()->with() combined with beforeEach closure
|
||||
// ---------------------------------------------------------------
|
||||
|
||||
describe('beforeEach closure and beforeEach()->with() coexist', function () {
|
||||
beforeEach(function () {
|
||||
$this->setupValue = 'initialized';
|
||||
});
|
||||
|
||||
beforeEach()->with([99]);
|
||||
|
||||
test('has both the closure state and dataset', function ($value) {
|
||||
expect($this->setupValue)->toBe('initialized');
|
||||
expect($value)->toBe(99);
|
||||
});
|
||||
});
|
||||
|
||||
describe('beforeEach()->with() does not interfere with closure hooks', function () {
|
||||
beforeEach(function () {
|
||||
$this->counter = 1;
|
||||
});
|
||||
|
||||
beforeEach(function () {
|
||||
$this->counter++;
|
||||
});
|
||||
|
||||
beforeEach()->with([42]);
|
||||
|
||||
test('closures run in order and dataset is applied', function ($value) {
|
||||
expect($this->counter)->toBe(2);
|
||||
expect($value)->toBe(42);
|
||||
});
|
||||
});
|
||||
|
||||
// ---------------------------------------------------------------
|
||||
// Dataset isolation between describe blocks
|
||||
// ---------------------------------------------------------------
|
||||
|
||||
describe('first describe with dataset', function () {
|
||||
beforeEach()->with([111]);
|
||||
|
||||
test('gets its own dataset', function ($value) {
|
||||
expect($value)->toBe(111);
|
||||
});
|
||||
});
|
||||
|
||||
describe('second describe with different dataset', function () {
|
||||
beforeEach()->with([222]);
|
||||
|
||||
test('gets its own dataset, not the sibling', function ($value) {
|
||||
expect($value)->toBe(222);
|
||||
});
|
||||
});
|
||||
|
||||
describe('third describe without dataset', function () {
|
||||
test('has no dataset leaking from siblings', function () {
|
||||
expect(true)->toBeTrue();
|
||||
});
|
||||
});
|
||||
|
||||
// ---------------------------------------------------------------
|
||||
// describe()->with() combined with beforeEach hooks
|
||||
// ---------------------------------------------------------------
|
||||
|
||||
describe('describe()->with() with beforeEach closure', function () {
|
||||
beforeEach(function () {
|
||||
$this->hookRan = true;
|
||||
});
|
||||
|
||||
test('both hook and dataset work', function ($value) {
|
||||
expect($this->hookRan)->toBeTrue();
|
||||
expect($value)->toBe(77);
|
||||
});
|
||||
})->with([77]);
|
||||
|
||||
describe('describe()->with() with afterEach closure', function () {
|
||||
afterEach(function () {
|
||||
expect($this->value)->toBe(88);
|
||||
});
|
||||
|
||||
test('dataset is available and afterEach runs', function ($value) {
|
||||
$this->value = $value;
|
||||
expect($value)->toBe(88);
|
||||
});
|
||||
})->with([88]);
|
||||
|
||||
// ---------------------------------------------------------------
|
||||
// Multiple tests in a describe with beforeEach()->with()
|
||||
// ---------------------------------------------------------------
|
||||
|
||||
describe('multiple tests share the same beforeEach dataset', function () {
|
||||
beforeEach()->with([33]);
|
||||
|
||||
test('first test gets the dataset', function ($value) {
|
||||
expect($value)->toBe(33);
|
||||
});
|
||||
|
||||
test('second test also gets the dataset', function ($value) {
|
||||
expect($value)->toBe(33);
|
||||
});
|
||||
|
||||
it('third test with it() also gets the dataset', function ($value) {
|
||||
expect($value)->toBe(33);
|
||||
});
|
||||
});
|
||||
|
||||
// ---------------------------------------------------------------
|
||||
// Nested describe with beforeEach()->with() at inner level
|
||||
// ---------------------------------------------------------------
|
||||
|
||||
describe('outer describe', function () {
|
||||
beforeEach(function () {
|
||||
$this->outer = true;
|
||||
});
|
||||
|
||||
describe('inner describe with dataset on hook', function () {
|
||||
beforeEach()->with([55]);
|
||||
|
||||
test('inherits outer beforeEach and has inner dataset', function ($value) {
|
||||
expect($this->outer)->toBeTrue();
|
||||
expect($value)->toBe(55);
|
||||
});
|
||||
});
|
||||
|
||||
test('outer test is unaffected by inner dataset', function () {
|
||||
expect($this->outer)->toBeTrue();
|
||||
});
|
||||
});
|
||||
|
||||
// ---------------------------------------------------------------
|
||||
// describe()->with() with depends
|
||||
// ---------------------------------------------------------------
|
||||
|
||||
describe('describe()->with() preserves depends', function () {
|
||||
test('first', function ($value) {
|
||||
expect($value)->toBe(9);
|
||||
});
|
||||
|
||||
test('second', function ($value) {
|
||||
expect($value)->toBe(9);
|
||||
})->depends('first');
|
||||
})->with([9]);
|
||||
@ -457,88 +457,3 @@ dataset('after-describe', ['after']);
|
||||
test('after describe block with named dataset', function (...$args) {
|
||||
expect($args)->toBe(['after']);
|
||||
})->with('after-describe');
|
||||
|
||||
test('named parameters match by parameter name', function (string $email, string $name) {
|
||||
expect($name)->toBe('Taylor');
|
||||
expect($email)->toBe('taylor@laravel.com');
|
||||
})->with([
|
||||
['name' => 'Taylor', 'email' => 'taylor@laravel.com'],
|
||||
]);
|
||||
|
||||
test('named parameters work with multiple dataset items', function (string $email, string $name) {
|
||||
expect($name)->toBeString();
|
||||
expect($email)->toContain('@');
|
||||
})->with([
|
||||
['name' => 'Taylor', 'email' => 'taylor@laravel.com'],
|
||||
['name' => 'James', 'email' => 'james@laravel.com'],
|
||||
]);
|
||||
|
||||
test('named parameters work in different order than closure params', function (string $third, string $first, string $second) {
|
||||
expect($first)->toBe('a');
|
||||
expect($second)->toBe('b');
|
||||
expect($third)->toBe('c');
|
||||
})->with([
|
||||
['first' => 'a', 'second' => 'b', 'third' => 'c'],
|
||||
]);
|
||||
|
||||
test('named parameters work with named dataset keys', function (string $email, string $name) {
|
||||
expect($name)->toBeString();
|
||||
expect($email)->toContain('@');
|
||||
})->with([
|
||||
'taylor' => ['name' => 'Taylor', 'email' => 'taylor@laravel.com'],
|
||||
'james' => ['name' => 'James', 'email' => 'james@laravel.com'],
|
||||
]);
|
||||
|
||||
test('named parameters work with closures that should be resolved', function (string $email, string $name) {
|
||||
expect($name)->toBe('bar');
|
||||
expect($email)->toBe('bar@example.com');
|
||||
})->with([
|
||||
[
|
||||
'name' => function () {
|
||||
return $this->foo;
|
||||
},
|
||||
'email' => function () {
|
||||
return $this->foo.'@example.com';
|
||||
},
|
||||
],
|
||||
]);
|
||||
|
||||
test('named parameters work with closure type hints', function (Closure $callback, string $name) {
|
||||
expect($name)->toBe('Taylor');
|
||||
expect($callback())->toBe('resolved');
|
||||
})->with([
|
||||
[
|
||||
'name' => 'Taylor',
|
||||
'callback' => function () {
|
||||
return 'resolved';
|
||||
},
|
||||
],
|
||||
]);
|
||||
|
||||
dataset('named-params-dataset', [
|
||||
['name' => 'Taylor', 'email' => 'taylor@laravel.com'],
|
||||
['name' => 'James', 'email' => 'james@laravel.com'],
|
||||
]);
|
||||
|
||||
test('named parameters work with registered datasets', function (string $email, string $name) {
|
||||
expect($name)->toBeString();
|
||||
expect($email)->toContain('@');
|
||||
})->with('named-params-dataset');
|
||||
|
||||
test('named parameters work with bound closure returning associative array', function (string $email, string $name) {
|
||||
expect($name)->toBe('bar');
|
||||
expect($email)->toBe('test@example.com');
|
||||
})->with([
|
||||
function () {
|
||||
return ['name' => $this->foo, 'email' => 'test@example.com'];
|
||||
},
|
||||
]);
|
||||
|
||||
test('dataset items can mix named and sequential styles', function (string $name, string $email) {
|
||||
expect($name)->toBeString();
|
||||
expect($email)->toContain('@');
|
||||
})->with([
|
||||
['name' => 'Taylor', 'email' => 'taylor@laravel.com'],
|
||||
['James', 'james@laravel.com'],
|
||||
['James', 'email' => 'james@laravel.com'],
|
||||
]);
|
||||
|
||||
@ -1,12 +0,0 @@
|
||||
<?php
|
||||
|
||||
use Pest\Arch\Exceptions\ArchExpectationFailedException;
|
||||
|
||||
test('pass')
|
||||
->expect('Tests\Fixtures\Arch\ToBeCasedCorrectly\CorrectCasing')
|
||||
->toBeCasedCorrectly();
|
||||
|
||||
test('failure')
|
||||
->expect('Tests\Fixtures\Arch\ToBeCasedCorrectly\IncorrectCasing')
|
||||
->toBeCasedCorrectly()
|
||||
->throws(ArchExpectationFailedException::class);
|
||||
@ -134,6 +134,18 @@ test('pass with `toSnapshot`', function () {
|
||||
expect($object)->toMatchSnapshot();
|
||||
});
|
||||
|
||||
test('failures', function () {
|
||||
TestSuite::getInstance()->snapshots->save($this->snapshotable);
|
||||
|
||||
expect('contain that does not match snapshot')->toMatchSnapshot();
|
||||
})->throws(ExpectationFailedException::class, 'Failed asserting that two strings are identical.');
|
||||
|
||||
test('failures with custom message', function () {
|
||||
TestSuite::getInstance()->snapshots->save($this->snapshotable);
|
||||
|
||||
expect('contain that does not match snapshot')->toMatchSnapshot('oh no');
|
||||
})->throws(ExpectationFailedException::class, 'oh no');
|
||||
|
||||
test('not failures', function () {
|
||||
TestSuite::getInstance()->snapshots->save($this->snapshotable);
|
||||
|
||||
|
||||
@ -14,19 +14,3 @@ test('failures', function () {
|
||||
test('not failures', function () {
|
||||
expect('Pest\Expectations\HigherOrderExpectation')->not->toUseTrait('Pest\Concerns\Retrievable');
|
||||
})->throws(ArchExpectationFailedException::class);
|
||||
|
||||
test('trait inheritance - direct usage', function () {
|
||||
expect('Tests\Fixtures\Arch\ToUseTrait\HasTrait\ParentClassWithTrait')->toUseTrait('Tests\Fixtures\Arch\ToUseTrait\HasTrait\TestTraitForInheritance');
|
||||
});
|
||||
|
||||
test('trait inheritance - inherited usage', function () {
|
||||
expect('Tests\Fixtures\Arch\ToUseTrait\HasInheritedTrait\ChildClassExtendingParent')->toUseTrait('Tests\Fixtures\Arch\ToUseTrait\HasTrait\TestTraitForInheritance');
|
||||
});
|
||||
|
||||
test('trait inheritance - negative case', function () {
|
||||
expect('Tests\Fixtures\Arch\ToUseTrait\HasInheritedTrait\ChildClassExtendingParent')->not->toUseTrait('NonExistentTrait');
|
||||
});
|
||||
|
||||
test('nested trait inheritance', function () {
|
||||
expect('Tests\Fixtures\Arch\ToUseTrait\HasInheritedTrait\ChildClassExtendingParent')->toUseTrait('Tests\Fixtures\Arch\ToUseTrait\HasNestedTrait\NestedTrait');
|
||||
});
|
||||
|
||||
@ -1,300 +0,0 @@
|
||||
<?php
|
||||
|
||||
use Symfony\Component\Process\Process;
|
||||
|
||||
it('passes on first try', function () {
|
||||
expect(true)->toBeTrue();
|
||||
})->flaky();
|
||||
|
||||
it('passes on a subsequent try', function () {
|
||||
$file = sys_get_temp_dir().'/pest_flaky_'.crc32(__FILE__.__LINE__);
|
||||
$count = file_exists($file) ? (int) file_get_contents($file) : 0;
|
||||
file_put_contents($file, (string) ++$count);
|
||||
|
||||
if ($count < 2) {
|
||||
throw new Exception('Flaky failure');
|
||||
}
|
||||
|
||||
@unlink($file);
|
||||
expect(true)->toBeTrue();
|
||||
})->flaky(tries: 3);
|
||||
|
||||
it('has a default of 3 tries', function () {
|
||||
expect(true)->toBeTrue();
|
||||
})->flaky();
|
||||
|
||||
it('succeeds on the last possible try', function () {
|
||||
$file = sys_get_temp_dir().'/pest_flaky_last_try';
|
||||
$count = file_exists($file) ? (int) file_get_contents($file) : 0;
|
||||
file_put_contents($file, (string) ++$count);
|
||||
|
||||
if ($count < 3) {
|
||||
throw new Exception('Not yet');
|
||||
}
|
||||
|
||||
@unlink($file);
|
||||
expect(true)->toBeTrue();
|
||||
})->flaky(tries: 3);
|
||||
|
||||
it('works with tries of 1', function () {
|
||||
expect(true)->toBeTrue();
|
||||
})->flaky(tries: 1);
|
||||
|
||||
it('retries assertion failures', function () {
|
||||
$file = sys_get_temp_dir().'/pest_flaky_assertion';
|
||||
$count = file_exists($file) ? (int) file_get_contents($file) : 0;
|
||||
file_put_contents($file, (string) ++$count);
|
||||
|
||||
if ($count < 2) {
|
||||
expect(false)->toBeTrue();
|
||||
}
|
||||
|
||||
@unlink($file);
|
||||
expect(true)->toBeTrue();
|
||||
})->flaky(tries: 3);
|
||||
|
||||
it('works with a dataset', function (int $number) {
|
||||
expect($number)->toBeGreaterThan(0);
|
||||
})->flaky(tries: 2)->with([1, 2, 3]);
|
||||
|
||||
it('retries each dataset independently', function (string $label) {
|
||||
$file = sys_get_temp_dir().'/pest_flaky_dataset_'.md5($label);
|
||||
$count = file_exists($file) ? (int) file_get_contents($file) : 0;
|
||||
file_put_contents($file, (string) ++$count);
|
||||
|
||||
if ($count < 2) {
|
||||
throw new Exception("Flaky for $label");
|
||||
}
|
||||
|
||||
@unlink($file);
|
||||
expect(true)->toBeTrue();
|
||||
})->flaky(tries: 3)->with(['alpha', 'beta']);
|
||||
|
||||
describe('within a describe block', function () {
|
||||
it('retries inside describe', function () {
|
||||
$file = sys_get_temp_dir().'/pest_flaky_describe';
|
||||
$count = file_exists($file) ? (int) file_get_contents($file) : 0;
|
||||
file_put_contents($file, (string) ++$count);
|
||||
|
||||
if ($count < 2) {
|
||||
throw new Exception('Flaky inside describe');
|
||||
}
|
||||
|
||||
@unlink($file);
|
||||
expect(true)->toBeTrue();
|
||||
})->flaky(tries: 2);
|
||||
});
|
||||
|
||||
describe('lifecycle hooks with flaky', function () {
|
||||
beforeEach(function () {
|
||||
$this->setupCount = ($this->setupCount ?? 0) + 1;
|
||||
});
|
||||
|
||||
it('re-runs beforeEach on each retry', function () {
|
||||
$file = sys_get_temp_dir().'/pest_flaky_lifecycle';
|
||||
$count = file_exists($file) ? (int) file_get_contents($file) : 0;
|
||||
file_put_contents($file, (string) ++$count);
|
||||
|
||||
if ($count < 2) {
|
||||
throw new Exception('Flaky lifecycle');
|
||||
}
|
||||
|
||||
@unlink($file);
|
||||
// After retry: setUp ran for initial + retry = setupCount should be 2
|
||||
expect($this->setupCount)->toBe(2);
|
||||
})->flaky(tries: 3);
|
||||
});
|
||||
|
||||
describe('afterEach with flaky', function () {
|
||||
$state = new stdClass;
|
||||
$state->teardownCount = 0;
|
||||
|
||||
afterEach(function () use ($state) {
|
||||
$state->teardownCount++;
|
||||
});
|
||||
|
||||
it('runs afterEach between retries', function () use ($state) {
|
||||
$file = sys_get_temp_dir().'/pest_flaky_aftereach';
|
||||
$count = file_exists($file) ? (int) file_get_contents($file) : 0;
|
||||
file_put_contents($file, (string) ++$count);
|
||||
|
||||
if ($count < 2) {
|
||||
throw new Exception('Flaky afterEach');
|
||||
}
|
||||
|
||||
@unlink($file);
|
||||
// tearDown was called once between retries
|
||||
expect($state->teardownCount)->toBe(1);
|
||||
})->flaky(tries: 3);
|
||||
});
|
||||
|
||||
it('does not retry skipped tests')
|
||||
->skip('intentionally skipped')
|
||||
->flaky(tries: 3);
|
||||
|
||||
it('works with repeat and flaky', function () {
|
||||
expect(true)->toBeTrue();
|
||||
})->repeat(times: 2)->flaky(tries: 2);
|
||||
|
||||
it('works as higher order test')
|
||||
->assertTrue(true)
|
||||
->flaky(tries: 2);
|
||||
|
||||
it('fails after exhausting all retries', function () {
|
||||
$process = new Process(
|
||||
['php', 'bin/pest', 'tests/.tests/FlakyFailure.php'],
|
||||
dirname(__DIR__, 2),
|
||||
['COLLISION_PRINTER' => 'DefaultPrinter', 'COLLISION_IGNORE_DURATION' => 'true'],
|
||||
);
|
||||
|
||||
$process->run();
|
||||
|
||||
expect($process->getExitCode())->not->toBe(0);
|
||||
expect(removeAnsiEscapeSequences($process->getOutput()))
|
||||
->toContain('FAILED')
|
||||
->toContain('Always fails');
|
||||
});
|
||||
|
||||
it('throws when tries is less than 1', function () {
|
||||
it('invalid', function () {})->flaky(tries: 0);
|
||||
})->throws(InvalidArgumentException::class, 'The number of tries must be greater than 0.');
|
||||
|
||||
it('throws when tries is negative', function () {
|
||||
it('invalid negative', function () {})->flaky(tries: -1);
|
||||
})->throws(InvalidArgumentException::class, 'The number of tries must be greater than 0.');
|
||||
|
||||
it('does not retry todo tests')
|
||||
->todo()
|
||||
->flaky(tries: 3);
|
||||
|
||||
it('retries php errors', function () {
|
||||
$file = sys_get_temp_dir().'/pest_flaky_error';
|
||||
$count = file_exists($file) ? (int) file_get_contents($file) : 0;
|
||||
file_put_contents($file, (string) ++$count);
|
||||
|
||||
if ($count < 2) {
|
||||
throw new TypeError('type error');
|
||||
}
|
||||
|
||||
@unlink($file);
|
||||
expect(true)->toBeTrue();
|
||||
})->flaky(tries: 3);
|
||||
|
||||
it('works with throws and flaky', function () {
|
||||
throw new RuntimeException('Expected exception');
|
||||
})->throws(RuntimeException::class, 'Expected exception')->flaky(tries: 2);
|
||||
|
||||
it('does not retry expected exceptions', function () {
|
||||
// If flaky retried this, the temp file counter would reach 2 and
|
||||
// the test would NOT throw — causing PHPUnit's "expected exception
|
||||
// was not raised" to fail. The test passes only if we don't retry.
|
||||
$file = sys_get_temp_dir().'/pest_flaky_expected';
|
||||
$count = file_exists($file) ? (int) file_get_contents($file) : 0;
|
||||
file_put_contents($file, (string) ++$count);
|
||||
|
||||
if ($count >= 2) {
|
||||
@unlink($file);
|
||||
|
||||
// Second call means flaky retried — don't throw, which will FAIL
|
||||
// because PHPUnit expects the exception
|
||||
return;
|
||||
}
|
||||
|
||||
@unlink($file);
|
||||
throw new RuntimeException('Expected on first attempt');
|
||||
})->throws(RuntimeException::class)->flaky(tries: 3);
|
||||
|
||||
it('does not retry fails()', function () {
|
||||
$this->fail('Expected failure');
|
||||
})->fails('Expected failure')->flaky(tries: 2);
|
||||
|
||||
it('retries unexpected exceptions even with throws set', function () {
|
||||
$file = sys_get_temp_dir().'/pest_flaky_unexpected';
|
||||
$count = file_exists($file) ? (int) file_get_contents($file) : 0;
|
||||
file_put_contents($file, (string) ++$count);
|
||||
|
||||
if ($count < 2) {
|
||||
throw new LogicException('Unexpected flaky error');
|
||||
}
|
||||
|
||||
@unlink($file);
|
||||
throw new RuntimeException('Expected exception');
|
||||
})->throws(RuntimeException::class)->flaky(tries: 3);
|
||||
|
||||
it('does not leak mock objects between retries', function () {
|
||||
$mock = $this->createMock(Countable::class);
|
||||
$mock->expects($this->once())->method('count')->willReturn(1);
|
||||
|
||||
$file = sys_get_temp_dir().'/pest_flaky_mock';
|
||||
$count = file_exists($file) ? (int) file_get_contents($file) : 0;
|
||||
file_put_contents($file, (string) ++$count);
|
||||
|
||||
if ($count < 2) {
|
||||
@unlink(sys_get_temp_dir().'/pest_flaky_mock'); // clean before retry writes again
|
||||
file_put_contents($file, '1');
|
||||
throw new Exception('Flaky mock failure');
|
||||
}
|
||||
|
||||
@unlink($file);
|
||||
// Call mock — only the mock from THIS attempt should be verified
|
||||
expect($mock->count())->toBe(1);
|
||||
})->flaky(tries: 3);
|
||||
|
||||
it('does not stop retrying when snapshot changes are absent', function () {
|
||||
// Ensures the snapshot guard only triggers when __snapshotChanges is non-empty
|
||||
$file = sys_get_temp_dir().'/pest_flaky_no_snapshot';
|
||||
$count = file_exists($file) ? (int) file_get_contents($file) : 0;
|
||||
file_put_contents($file, (string) ++$count);
|
||||
|
||||
if ($count < 2) {
|
||||
throw new Exception('No snapshots here');
|
||||
}
|
||||
|
||||
@unlink($file);
|
||||
expect(true)->toBeTrue();
|
||||
})->flaky(tries: 3);
|
||||
|
||||
it('does not leak dynamic properties between retries', function () {
|
||||
$file = sys_get_temp_dir().'/pest_flaky_props';
|
||||
$count = file_exists($file) ? (int) file_get_contents($file) : 0;
|
||||
file_put_contents($file, (string) ++$count);
|
||||
|
||||
if ($count < 2) {
|
||||
$this->leakedProperty = 'from attempt 1';
|
||||
throw new Exception('Flaky props');
|
||||
}
|
||||
|
||||
@unlink($file);
|
||||
expect(isset($this->leakedProperty))->toBeFalse();
|
||||
})->flaky(tries: 3);
|
||||
|
||||
it('clears output buffer between retries when expectOutputString is used', function () {
|
||||
$file = sys_get_temp_dir().'/pest_flaky_output';
|
||||
$count = file_exists($file) ? (int) file_get_contents($file) : 0;
|
||||
file_put_contents($file, (string) ++$count);
|
||||
|
||||
$this->expectOutputString('clean');
|
||||
|
||||
if ($count < 2) {
|
||||
echo 'stale';
|
||||
throw new Exception('Flaky output');
|
||||
}
|
||||
|
||||
@unlink($file);
|
||||
echo 'clean';
|
||||
})->flaky(tries: 3);
|
||||
|
||||
it('preserves output between retries when no output expectation is set', function () {
|
||||
$file = sys_get_temp_dir().'/pest_flaky_output_no_expect';
|
||||
$count = file_exists($file) ? (int) file_get_contents($file) : 0;
|
||||
file_put_contents($file, (string) ++$count);
|
||||
|
||||
if ($count < 2) {
|
||||
echo 'from attempt 1';
|
||||
throw new Exception('Flaky output no expect');
|
||||
}
|
||||
|
||||
@unlink($file);
|
||||
// Output from attempt 1 is still in the buffer
|
||||
$this->expectOutputString('from attempt 1');
|
||||
})->flaky(tries: 3);
|
||||
@ -1,5 +0,0 @@
|
||||
<?php
|
||||
|
||||
namespace Tests\Fixtures\Arch\ToBeCasedCorrectly\CorrectCasing;
|
||||
|
||||
class CorrectCasing {}
|
||||
@ -1,5 +0,0 @@
|
||||
<?php
|
||||
|
||||
namespace Tests\Fixtures\Arch\ToBeCasedCorrectly\IncorrectCasing;
|
||||
|
||||
class IncorrectCasing {}
|
||||
@ -1,5 +0,0 @@
|
||||
<?php
|
||||
|
||||
namespace Tests\Fixtures\Arch\ToBeCasedCorrectly\IncorrectDirectoryCasing;
|
||||
|
||||
class CorrectCasing {}
|
||||
@ -1,9 +0,0 @@
|
||||
<?php
|
||||
|
||||
declare(strict_types=1);
|
||||
|
||||
namespace Tests\Fixtures\Arch\ToUseTrait\HasInheritedTrait;
|
||||
|
||||
use Tests\Fixtures\Arch\ToUseTrait\HasTrait\ParentClassWithTrait;
|
||||
|
||||
class ChildClassExtendingParent extends ParentClassWithTrait {}
|
||||
@ -1,13 +0,0 @@
|
||||
<?php
|
||||
|
||||
declare(strict_types=1);
|
||||
|
||||
namespace Tests\Fixtures\Arch\ToUseTrait\HasNestedTrait;
|
||||
|
||||
trait NestedTrait
|
||||
{
|
||||
public function nestedMethod()
|
||||
{
|
||||
return 'nested';
|
||||
}
|
||||
}
|
||||
@ -1,10 +0,0 @@
|
||||
<?php
|
||||
|
||||
declare(strict_types=1);
|
||||
|
||||
namespace Tests\Fixtures\Arch\ToUseTrait\HasTrait;
|
||||
|
||||
class ParentClassWithTrait
|
||||
{
|
||||
use TestTraitForInheritance;
|
||||
}
|
||||
@ -1,17 +0,0 @@
|
||||
<?php
|
||||
|
||||
declare(strict_types=1);
|
||||
|
||||
namespace Tests\Fixtures\Arch\ToUseTrait\HasTrait;
|
||||
|
||||
use Tests\Fixtures\Arch\ToUseTrait\HasNestedTrait\NestedTrait;
|
||||
|
||||
trait TestTraitForInheritance
|
||||
{
|
||||
use NestedTrait;
|
||||
|
||||
public function testMethod()
|
||||
{
|
||||
return 'test';
|
||||
}
|
||||
}
|
||||
@ -1,6 +0,0 @@
|
||||
<?php
|
||||
|
||||
dataset('nested.users', [
|
||||
['alice'],
|
||||
['bob'],
|
||||
]);
|
||||
@ -1,5 +0,0 @@
|
||||
<?php
|
||||
|
||||
test('loads nested dataset', function (string $name) {
|
||||
expect($name)->not->toBeEmpty();
|
||||
})->with('nested.users');
|
||||
@ -86,12 +86,5 @@ dataset('dataset_in_pest_file', ['A', 'B']);
|
||||
|
||||
function removeAnsiEscapeSequences(string $input): ?string
|
||||
{
|
||||
return preg_replace(
|
||||
[
|
||||
'#\\x1b[[][^A-Za-z]*[A-Za-z]#', // CSI (colors, cursor, etc.)
|
||||
'#\\x1b\\]8;[^\\x1b\\x07]*(?:\\x1b\\\\|\\x07)#', // OSC 8 hyperlinks
|
||||
],
|
||||
'',
|
||||
$input,
|
||||
);
|
||||
return preg_replace('#\\x1b[[][^A-Za-z]*[A-Za-z]#', '', $input);
|
||||
}
|
||||
|
||||
@ -14,3 +14,17 @@ it('throw expectation failed exception with array argument', function (): void {
|
||||
|
||||
$expectation->throwExpectationFailedException('toBe', ['bar']);
|
||||
})->throws(ExpectationFailedException::class, "Expecting 'foo' not to be 'bar'.");
|
||||
|
||||
it('does not truncate long string arguments in error message', function (): void {
|
||||
$expectation = new OppositeExpectation(expect('foo'));
|
||||
|
||||
$longMessage = 'Very long error message. Very long error message. Very long error message.';
|
||||
|
||||
$expectation->throwExpectationFailedException('toBe', [$longMessage]);
|
||||
})->throws(ExpectationFailedException::class, 'Very long error message. Very long error message. Very long error message.');
|
||||
|
||||
it('does not truncate custom error message when using not()', function (): void {
|
||||
$longMessage = 'This is a very detailed custom error message that should not be truncated in the output.';
|
||||
|
||||
expect(true)->not()->toBeTrue($longMessage);
|
||||
})->throws(ExpectationFailedException::class, 'This is a very detailed custom error message that should not be truncated in the output.');
|
||||
|
||||
@ -5,14 +5,9 @@ use Pest\Support\DatasetInfo;
|
||||
it('can check if dataset is defined inside a Datasets directory', function (string $file, bool $inside) {
|
||||
expect(DatasetInfo::isInsideADatasetsDirectory($file))->toBe($inside);
|
||||
})->with([
|
||||
['file' => '/var/www/Datasets/project/tests/Datasets/Nested/Numbers.php', 'inside' => true],
|
||||
['file' => '/var/www/Datasets/project/tests/Features/Datasets/Nested/Numbers.php', 'inside' => true],
|
||||
['file' => '/var/www/project/tests/Datasets/Numbers.php', 'inside' => true],
|
||||
['file' => '/var/www/project/tests/Datasets/Nested/Numbers.php', 'inside' => true],
|
||||
['file' => '/var/www/project/tests/Datasets.php', 'inside' => false],
|
||||
['file' => '/var/www/project/tests/Features/Datasets/Numbers.php', 'inside' => true],
|
||||
['file' => '/var/www/project/tests/Features/Datasets/Nested/Numbers.php', 'inside' => true],
|
||||
['file' => '/var/www/project/tests/Features/Datasets/Nested/Datasets/Numbers.php', 'inside' => true],
|
||||
['file' => '/var/www/project/tests/Features/Numbers.php', 'inside' => false],
|
||||
['file' => '/var/www/project/tests/Features/Datasets.php', 'inside' => false],
|
||||
]);
|
||||
@ -30,18 +25,12 @@ it('can check if dataset is defined inside a Datasets.php file', function (strin
|
||||
it('computes the dataset scope', function (string $file, string $scope) {
|
||||
expect(DatasetInfo::scope($file))->toBe($scope);
|
||||
})->with([
|
||||
['file' => '/var/www/Datasets/project/tests/Datasets/Nested/Numbers.php', 'scope' => '/var/www/Datasets/project/tests'],
|
||||
['file' => '/var/www/Datasets/project/tests/Features/Datasets/Nested/Numbers.php', 'scope' => '/var/www/Datasets/project/tests/Features'],
|
||||
['file' => '/var/www/project/tests/Datasets/Numbers.php', 'scope' => '/var/www/project/tests'],
|
||||
['file' => '/var/www/project/tests/Datasets/Nested/Numbers.php', 'scope' => '/var/www/project/tests'],
|
||||
['file' => '/var/www/project/tests/Datasets.php', 'scope' => '/var/www/project/tests'],
|
||||
['file' => '/var/www/project/tests/Features/Datasets/Numbers.php', 'scope' => '/var/www/project/tests/Features'],
|
||||
['file' => '/var/www/project/tests/Features/Datasets/Nested/Numbers.php', 'scope' => '/var/www/project/tests/Features'],
|
||||
['file' => '/var/www/project/tests/Features/Numbers.php', 'scope' => '/var/www/project/tests/Features/Numbers.php'],
|
||||
['file' => '/var/www/project/tests/Features/Datasets.php', 'scope' => '/var/www/project/tests/Features'],
|
||||
['file' => '/var/www/project/tests/Features/Controllers/Datasets/Numbers.php', 'scope' => '/var/www/project/tests/Features/Controllers'],
|
||||
['file' => '/var/www/project/tests/Features/Controllers/Datasets/Nested/Numbers.php', 'scope' => '/var/www/project/tests/Features/Controllers'],
|
||||
['file' => '/var/www/project/tests/Features/Datasets/Nested/Datasets/Numbers.php', 'scope' => '/var/www/project/tests/Features'],
|
||||
['file' => '/var/www/project/tests/Features/Controllers/Numbers.php', 'scope' => '/var/www/project/tests/Features/Controllers/Numbers.php'],
|
||||
['file' => '/var/www/project/tests/Features/Controllers/Datasets.php', 'scope' => '/var/www/project/tests/Features/Controllers'],
|
||||
]);
|
||||
|
||||
@ -60,17 +60,20 @@ test('junit with parallel', function () use ($normalizedPath, $run) {
|
||||
expect($result['testsuite']['@attributes'])
|
||||
->name->toBe('Tests\tests\SuccessOnly')
|
||||
->file->toBe($normalizedPath('tests/.tests/SuccessOnly.php'))
|
||||
->tests->toBe('1')
|
||||
->assertions->toBe('1')
|
||||
->tests->toBe('2')
|
||||
->assertions->toBe('2')
|
||||
->errors->toBe('0')
|
||||
->failures->toBe('0')
|
||||
->skipped->toBe('0');
|
||||
|
||||
expect($result['testsuite']['testcase']['@attributes'])
|
||||
expect($result['testsuite']['testcase'])
|
||||
->toHaveCount(2);
|
||||
|
||||
expect($result['testsuite']['testcase'][0]['@attributes'])
|
||||
->name->toBe('it can pass with comparison')
|
||||
->file->toBe($normalizedPath('tests/.tests/SuccessOnly.php::it can pass with comparison'))
|
||||
->class->toBe('Tests\tests\SuccessOnly')
|
||||
->classname->toBe('Tests.tests.SuccessOnly')
|
||||
->assertions->toBe('1')
|
||||
->time->toStartWith('0.0');
|
||||
});
|
||||
})->skip('Not working yet');
|
||||
|
||||
@ -15,34 +15,11 @@ $run = function () {
|
||||
};
|
||||
|
||||
test('parallel', function () use ($run) {
|
||||
$output = $run('--exclude-group=integration');
|
||||
|
||||
if (getenv('REBUILD_SNAPSHOTS')) {
|
||||
preg_match('/Tests:\s+(.+\(\d+ assertions\))/', $output, $matches);
|
||||
|
||||
$file = file_get_contents(__FILE__);
|
||||
$file = preg_replace(
|
||||
'/\$expected = \'.*?\';/',
|
||||
"\$expected = '2 deprecated, 4 warnings, 5 incomplete, 3 notices, 40 todos, 27 skipped, 1278 passed (2920 assertions)';",
|
||||
$file,
|
||||
);
|
||||
file_put_contents(__FILE__, $file);
|
||||
}
|
||||
|
||||
$expected = '2 deprecated, 4 warnings, 5 incomplete, 3 notices, 40 todos, 27 skipped, 1278 passed (2920 assertions)';
|
||||
|
||||
expect($output)
|
||||
->toContain("Tests: {$expected}")
|
||||
expect($run('--exclude-group=integration'))
|
||||
->toContain('Tests: 2 deprecated, 4 warnings, 5 incomplete, 2 notices, 39 todos, 26 skipped, 1177 passed (2789 assertions)')
|
||||
->toContain('Parallel: 3 processes');
|
||||
})->skipOnWindows();
|
||||
|
||||
test('a parallel test can extend another test with same name', function () use ($run) {
|
||||
expect($run('tests/Fixtures/Inheritance'))->toContain('Tests: 1 skipped, 1 passed (1 assertions)');
|
||||
})->skipOnWindows();
|
||||
|
||||
test('parallel reports invalid datasets as failures', function () use ($run) {
|
||||
expect($run('tests/.tests/ParallelInvalidDataset'))
|
||||
->toContain("A dataset with the name `missing.dataset` does not exist. You can create it using `dataset('missing.dataset', ['a', 'b']);`.")
|
||||
->toContain('Tests: 1 failed, 1 passed (1 assertions)')
|
||||
->toContain('Parallel: 3 processes');
|
||||
})->skipOnWindows();
|
||||
expect($run('tests/Fixtures/Inheritance'))->toContain('Tests: 1 skipped, 2 passed (2 assertions)');
|
||||
});
|
||||
|
||||
@ -1,40 +0,0 @@
|
||||
<?php
|
||||
|
||||
use Symfony\Component\Process\Process;
|
||||
|
||||
$run = function (bool $parallel = false): array {
|
||||
$command = [
|
||||
'php',
|
||||
'bin/pest',
|
||||
'tests/Fixtures/ParallelNestedDatasets/TestFileWithNestedDataset.php',
|
||||
'--colors=never',
|
||||
];
|
||||
|
||||
if ($parallel) {
|
||||
$command[] = '--parallel';
|
||||
$command[] = '--processes=2';
|
||||
}
|
||||
|
||||
$process = new Process($command, dirname(__DIR__, 2),
|
||||
['COLLISION_PRINTER' => 'DefaultPrinter', 'COLLISION_IGNORE_DURATION' => 'true'],
|
||||
);
|
||||
|
||||
$process->run();
|
||||
|
||||
return [
|
||||
'exitCode' => $process->getExitCode(),
|
||||
'output' => removeAnsiEscapeSequences($process->getOutput().$process->getErrorOutput()),
|
||||
];
|
||||
};
|
||||
|
||||
test('parallel loads nested datasets from nested directories', function () use ($run) {
|
||||
$serial = $run();
|
||||
$parallel = $run(true);
|
||||
|
||||
expect($serial['exitCode'])->toBe(0)
|
||||
->and($parallel['exitCode'])->toBe(0)
|
||||
->and($serial['output'])->toContain('Tests: 2 passed (2 assertions)')
|
||||
->and($parallel['output'])->toContain('Tests: 2 passed (2 assertions)')
|
||||
->and($parallel['output'])->toContain('Parallel: 2 processes')
|
||||
->and($parallel['output'])->not->toContain('No tests found.');
|
||||
})->skipOnWindows();
|
||||
@ -12,7 +12,7 @@ test('visual snapshot of test suite on success', function () {
|
||||
|
||||
$output = function () use ($testsPath) {
|
||||
$process = (new Process(
|
||||
['php', '-d', 'memory_limit=256M', 'bin/pest'],
|
||||
['php', 'bin/pest'],
|
||||
dirname($testsPath),
|
||||
['EXCLUDE' => 'integration', '--exclude-group' => 'integration', 'REBUILD_SNAPSHOTS' => false, 'PARATEST' => 0, 'COLLISION_PRINTER' => 'DefaultPrinter', 'COLLISION_IGNORE_DURATION' => 'true'],
|
||||
));
|
||||
@ -21,10 +21,8 @@ test('visual snapshot of test suite on success', function () {
|
||||
|
||||
return preg_replace([
|
||||
'#\\x1b[[][^A-Za-z]*[A-Za-z]#',
|
||||
'#\\x1b\\]8;[^\\x1b\\x07]*(?:\\x1b\\\\|\\x07)#',
|
||||
'/(Tests\\\PHPUnit\\\CustomAffixes\\\InvalidTestName)([A-Za-z0-9]*)/',
|
||||
], [
|
||||
'',
|
||||
'',
|
||||
'$1',
|
||||
], $process->getOutput());
|
||||
|
||||
@ -1,37 +0,0 @@
|
||||
<?php
|
||||
|
||||
use Symfony\Component\Process\Process;
|
||||
|
||||
test('filter works with unicode characters in filename', function () {
|
||||
$process = new Process([
|
||||
'php',
|
||||
'bin/pest',
|
||||
'tests/.tests/StraßenTest.php',
|
||||
'--colors=never',
|
||||
], dirname(__DIR__, 2), ['COLLISION_PRINTER' => 'DefaultPrinter', 'COLLISION_IGNORE_DURATION' => 'true']);
|
||||
|
||||
$process->run();
|
||||
|
||||
$output = $process->getOutput();
|
||||
|
||||
expect($output)->toContain('StraßenTest');
|
||||
expect($output)->toContain('tests unicode filename');
|
||||
expect($output)->toContain('1 passed');
|
||||
})->skipOnWindows();
|
||||
|
||||
test('filter with unicode regex matches unicode filename', function () {
|
||||
$process = new Process([
|
||||
'php',
|
||||
'bin/pest',
|
||||
'--filter=.*Straß.*',
|
||||
'tests/.tests/',
|
||||
'--colors=never',
|
||||
], dirname(__DIR__, 2), ['COLLISION_PRINTER' => 'DefaultPrinter', 'COLLISION_IGNORE_DURATION' => 'true']);
|
||||
|
||||
$process->run();
|
||||
|
||||
$output = $process->getOutput();
|
||||
|
||||
expect($output)->toContain('StraßenTest');
|
||||
expect($output)->toContain('1 passed');
|
||||
})->skipOnWindows();
|
||||
Reference in New Issue
Block a user