mirror of
https://github.com/pestphp/pest.git
synced 2026-04-21 06:27:28 +02:00
Compare commits
5 Commits
| Author | SHA1 | Date | |
|---|---|---|---|
| 8871a6f5ef | |||
| e4b6fc08b6 | |||
| 7796630eaf | |||
| 3aec2b26ef | |||
| 7a7c35292c |
68
.github/workflows/static.yml
vendored
68
.github/workflows/static.yml
vendored
@ -1,68 +0,0 @@
|
||||
name: Static Analysis
|
||||
|
||||
on:
|
||||
push:
|
||||
branches: [4.x]
|
||||
pull_request:
|
||||
schedule:
|
||||
- cron: '0 9 * * *'
|
||||
|
||||
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:
|
||||
dependency-version: [prefer-lowest, prefer-stable]
|
||||
|
||||
steps:
|
||||
- name: Checkout
|
||||
uses: actions/checkout@v6
|
||||
|
||||
- name: Setup PHP
|
||||
uses: shivammathur/setup-php@v2
|
||||
with:
|
||||
php-version: 8.3
|
||||
tools: composer:v2
|
||||
coverage: none
|
||||
extensions: sockets
|
||||
|
||||
- name: Get Composer cache directory
|
||||
id: composer-cache
|
||||
shell: bash
|
||||
run: echo "dir=$(composer config cache-files-dir)" >> $GITHUB_OUTPUT
|
||||
|
||||
- name: Cache Composer dependencies
|
||||
uses: actions/cache@v5
|
||||
with:
|
||||
path: ${{ steps.composer-cache.outputs.dir }}
|
||||
key: static-php-8.3-${{ matrix.dependency-version }}-composer-${{ hashFiles('**/composer.json', '**/composer.lock') }}
|
||||
restore-keys: |
|
||||
static-php-8.3-${{ matrix.dependency-version }}-composer-
|
||||
static-php-8.3-composer-
|
||||
|
||||
- name: Install Dependencies
|
||||
run: composer update --${{ matrix.dependency-version }} --no-interaction --no-progress --ansi
|
||||
|
||||
- name: Profanity Check
|
||||
run: composer test:profanity
|
||||
|
||||
- name: Type Check
|
||||
run: composer test:type:check
|
||||
|
||||
- name: Type Coverage
|
||||
run: composer test:type:coverage
|
||||
|
||||
- name: Style
|
||||
run: composer test:lint
|
||||
37
.github/workflows/tests.yml
vendored
37
.github/workflows/tests.yml
vendored
@ -2,40 +2,26 @@ name: Tests
|
||||
|
||||
on:
|
||||
push:
|
||||
branches: [4.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']
|
||||
os: [ubuntu-latest, macos-latest, windows-latest]
|
||||
symfony: ['7.1']
|
||||
php: ['8.2', '8.3', '8.4']
|
||||
dependency_version: [prefer-stable]
|
||||
exclude:
|
||||
- php: '8.3'
|
||||
symfony: '8.0'
|
||||
|
||||
name: PHP ${{ matrix.php }} - Symfony ^${{ matrix.symfony }} - ${{ matrix.os }} - ${{ matrix.dependency_version }}
|
||||
|
||||
steps:
|
||||
- name: Checkout
|
||||
uses: actions/checkout@v6
|
||||
uses: actions/checkout@v4
|
||||
|
||||
- name: Setup PHP
|
||||
uses: shivammathur/setup-php@v2
|
||||
@ -43,21 +29,6 @@ jobs:
|
||||
php-version: ${{ matrix.php }}
|
||||
tools: composer:v2
|
||||
coverage: none
|
||||
extensions: sockets
|
||||
|
||||
- name: Get Composer cache directory
|
||||
id: composer-cache
|
||||
shell: bash
|
||||
run: echo "dir=$(composer config cache-files-dir)" >> $GITHUB_OUTPUT
|
||||
|
||||
- name: Cache Composer dependencies
|
||||
uses: actions/cache@v5
|
||||
with:
|
||||
path: ${{ steps.composer-cache.outputs.dir }}
|
||||
key: ${{ matrix.os }}-php-${{ matrix.php }}-symfony-${{ matrix.symfony }}-composer-${{ hashFiles('**/composer.json', '**/composer.lock') }}
|
||||
restore-keys: |
|
||||
${{ matrix.os }}-php-${{ matrix.php }}-symfony-${{ matrix.symfony }}-composer-
|
||||
${{ matrix.os }}-php-${{ matrix.php }}-composer-
|
||||
|
||||
- name: Setup Problem Matches
|
||||
run: |
|
||||
|
||||
14
Makefile
Normal file
14
Makefile
Normal file
@ -0,0 +1,14 @@
|
||||
# Well documented Makefiles
|
||||
DEFAULT_GOAL := help
|
||||
help:
|
||||
@awk 'BEGIN {FS = ":.*##"; printf "\nUsage:\n make \033[36m<target>\033[0m\n"} /^[a-zA-Z0-9_-]+:.*?##/ { printf " \033[36m%-40s\033[0m %s\n", $$1, $$2 } /^##@/ { printf "\n\033[1m%s\033[0m\n", substr($$0, 5) } ' $(MAKEFILE_LIST)
|
||||
|
||||
build: ## Build all docker images. Specify the command e.g. via make build ARGS="--build-arg PHP=8.2"
|
||||
docker compose build $(ARGS)
|
||||
|
||||
##@ [Application]
|
||||
install: ## Install the composer dependencies
|
||||
docker compose run --rm composer install
|
||||
|
||||
test: ## Run the tests
|
||||
docker compose run --rm composer test
|
||||
31
README.md
31
README.md
@ -1,24 +1,23 @@
|
||||
<p align="center">
|
||||
<img src="https://raw.githubusercontent.com/pestphp/art/master/v4/social.png" width="600" alt="PEST">
|
||||
<img src="https://raw.githubusercontent.com/pestphp/art/master/v3/banner.png" width="600" alt="PEST">
|
||||
<p align="center">
|
||||
<a href="https://github.com/pestphp/pest/actions"><img alt="GitHub Workflow Status (master)" src="https://img.shields.io/github/actions/workflow/status/pestphp/pest/tests.yml?branch=4.x&label=Tests%204.x"></a>
|
||||
<a href="https://github.com/pestphp/pest/actions"><img alt="GitHub Workflow Status (master)" src="https://img.shields.io/github/actions/workflow/status/pestphp/pest/tests.yml?branch=3.x&label=Tests%203.x"></a>
|
||||
<a href="https://packagist.org/packages/pestphp/pest"><img alt="Total Downloads" src="https://img.shields.io/packagist/dt/pestphp/pest"></a>
|
||||
<a href="https://packagist.org/packages/pestphp/pest"><img alt="Latest Version" src="https://img.shields.io/packagist/v/pestphp/pest"></a>
|
||||
<a href="https://packagist.org/packages/pestphp/pest"><img alt="License" src="https://img.shields.io/packagist/l/pestphp/pest"></a>
|
||||
<a href="https://whyphp.dev"><img src="https://img.shields.io/badge/Why_PHP-in_2026-7A86E8?style=flat-square&labelColor=18181b" alt="Why PHP in 2026"></a>
|
||||
</p>
|
||||
</p>
|
||||
|
||||
------
|
||||
|
||||
> Pest v4 Now Available: **[Read the announcement »](https://pestphp.com/docs/pest-v4-is-here-now-with-browser-testing)**.
|
||||
> Pest v3 Now Available: **[Read the announcement »](https://pestphp.com/docs/pest3-now-available)**.
|
||||
|
||||
**Pest** is an elegant PHP testing Framework with a focus on simplicity, meticulously designed to bring back the joy of testing in PHP.
|
||||
|
||||
- Explore our docs at **[pestphp.com »](https://pestphp.com)**
|
||||
- Follow the creator Nuno Maduro:
|
||||
- YouTube: **[youtube.com/@nunomaduro](https://youtube.com/@nunomaduro)** — Videos every week
|
||||
- Twitch: **[twitch.tv/nunomaduro](https://twitch.tv/nunomaduro)** — Live coding on Mondays, Wednesdays, and Fridays at 9PM UTC
|
||||
- YouTube: **[youtube.com/@nunomaduro](https://www.youtube.com/@nunomaduro)** — Videos every weekday
|
||||
- Twitch: **[twitch.tv/enunomaduro](https://www.twitch.tv/enunomaduro)** — Streams (almost) every weekday
|
||||
- Twitter / X: **[x.com/enunomaduro](https://x.com/enunomaduro)**
|
||||
- LinkedIn: **[linkedin.com/in/nunomaduro](https://www.linkedin.com/in/nunomaduro)**
|
||||
- Instagram: **[instagram.com/enunomaduro](https://www.instagram.com/enunomaduro)**
|
||||
@ -31,23 +30,23 @@ We cannot thank our sponsors enough for their incredible support in funding Pest
|
||||
|
||||
### Platinum Sponsors
|
||||
|
||||
- **[CodeRabbit](https://coderabbit.ai/?ref=pestphp)**
|
||||
- **[Mailtrap](https://l.rw.rw/pestphp)**
|
||||
- **[SerpApi](https://serpapi.com/?ref=nunomaduro)**
|
||||
- **[Tighten](https://tighten.com/?ref=nunomaduro)**
|
||||
- **[Redberry](https://redberry.international/laravel-development/?utm_source=pest&utm_medium=banner&utm_campaign=pest_sponsorship)**
|
||||
- **[Laracasts](https://laracasts.com/?ref=pestphp)**
|
||||
|
||||
### Gold Sponsors
|
||||
|
||||
- **[CodeRabbit](https://coderabbit.ai/?ref=pestphp)**
|
||||
- **[NativePHP](https://nativephp.com/mobile?ref=pestphp.com)**
|
||||
- **[CMS Max](https://cmsmax.com/?ref=pestphp)**
|
||||
|
||||
### Premium Sponsors
|
||||
|
||||
- [Zapiet](https://zapiet.com/?ref=pestphp)
|
||||
- [Load Forge](https://loadforge.com/?ref=pestphp)
|
||||
- [Route4Me](https://route4me.com/pt?ref=pestphp)
|
||||
- [Nerdify](https://getnerdify.com/?ref=pestphp)
|
||||
- [Akaunting](https://akaunting.com/?ref=pestphp)
|
||||
- [TestMu AI](https://www.testmuai.com/?utm_medium=sponsor&utm_source=pest)
|
||||
- [DocuWriter.ai](https://www.docuwriter.ai/?ref=pestphp)
|
||||
- [Localazy](https://localazy.com/?ref=pestphp)
|
||||
- [Forge](https://forge.laravel.com/?ref=pestphp)
|
||||
- [Route4Me](https://www.route4me.com/?ref=pestphp)
|
||||
- [Spatie](https://spatie.be/?ref=pestphp)
|
||||
- [Worksome](https://www.worksome.com/?ref=pestphp)
|
||||
- [Zapiet](https://www.zapiet.com/?ref=pestphp)
|
||||
|
||||
Pest is an open-sourced software licensed under the **[MIT license](https://opensource.org/licenses/MIT)**.
|
||||
|
||||
@ -2,10 +2,10 @@
|
||||
|
||||
When releasing a new version of Pest there are some checks and updates that need to be done:
|
||||
|
||||
> **For Pest v3 you should use the `3.x` branch instead.**
|
||||
> **For Pest v2 you should use the `2.x` branch instead.**
|
||||
|
||||
- Clear your local repository with: `git add . && git reset --hard && git checkout 4.x`
|
||||
- On the GitHub repository, check the contents of [github.com/pestphp/pest/compare/{latest_version}...4.x](https://github.com/pestphp/pest/compare/{latest_version}...4.x)
|
||||
- Clear your local repository with: `git add . && git reset --hard && git checkout 3.x`
|
||||
- On the GitHub repository, check the contents of [github.com/pestphp/pest/compare/{latest_version}...3.x](https://github.com/pestphp/pest/compare/{latest_version}...3.x)
|
||||
- Update the version number in [src/Pest.php](src/Pest.php)
|
||||
- Run the tests locally using: `composer test`
|
||||
- Commit the Pest file with the message: `git commit -m "release: vX.X.X"`
|
||||
|
||||
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);
|
||||
}
|
||||
|
||||
@ -86,7 +86,7 @@ $bootPest = (static function (): void {
|
||||
$getopt['teamcity-file'] ?? null,
|
||||
$getopt['testdox-file'] ?? null,
|
||||
isset($getopt['testdox-color']),
|
||||
(int) ($getopt['testdox-columns'] ?? null),
|
||||
$getopt['testdox-columns'] ?? null,
|
||||
);
|
||||
|
||||
while (true) {
|
||||
|
||||
@ -17,21 +17,19 @@
|
||||
}
|
||||
],
|
||||
"require": {
|
||||
"php": "^8.3.0",
|
||||
"brianium/paratest": "^7.20.0",
|
||||
"nunomaduro/collision": "^8.9.3",
|
||||
"php": "^8.2.0",
|
||||
"brianium/paratest": "^7.8.5",
|
||||
"nunomaduro/collision": "^8.9.1",
|
||||
"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.22",
|
||||
"symfony/process": "^7.4.8|^8.0.8"
|
||||
"pestphp/pest-plugin": "^3.0.0",
|
||||
"pestphp/pest-plugin-arch": "^3.1.1",
|
||||
"pestphp/pest-plugin-mutate": "^3.0.5",
|
||||
"phpunit/phpunit": "^11.5.50"
|
||||
},
|
||||
"conflict": {
|
||||
"filp/whoops": "<2.18.3",
|
||||
"phpunit/phpunit": ">12.5.22",
|
||||
"sebastian/exporter": "<7.0.0",
|
||||
"filp/whoops": "<2.16.0",
|
||||
"phpunit/phpunit": ">11.5.50",
|
||||
"sebastian/exporter": "<6.0.0",
|
||||
"webmozart/assert": "<1.11.0"
|
||||
},
|
||||
"autoload": {
|
||||
@ -50,19 +48,14 @@
|
||||
"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",
|
||||
"psy/psysh": "^0.12.22"
|
||||
"pestphp/pest-dev-tools": "^3.4.0",
|
||||
"pestphp/pest-plugin-type-coverage": "^3.6.1",
|
||||
"symfony/process": "^7.4.5"
|
||||
},
|
||||
"minimum-stability": "dev",
|
||||
"prefer-stable": true,
|
||||
@ -77,26 +70,13 @@
|
||||
"bin/pest"
|
||||
],
|
||||
"scripts": {
|
||||
"lint": [
|
||||
"rector",
|
||||
"pint --parallel"
|
||||
],
|
||||
"test:lint": [
|
||||
"rector --dry-run",
|
||||
"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",
|
||||
"test:unit": "php bin/pest --exclude-group=integration --compact",
|
||||
"test:inline": "php bin/pest --configuration=phpunit.inline.xml",
|
||||
"test:parallel": "php bin/pest --exclude-group=integration --parallel --processes=3",
|
||||
"test:integration": "php bin/pest --group=integration -v",
|
||||
"update:snapshots": "REBUILD_SNAPSHOTS=true php bin/pest --update-snapshots",
|
||||
"refacto": "rector",
|
||||
"test:unit": "php bin/pest --colors=always --exclude-group=integration --compact",
|
||||
"test:inline": "php bin/pest --colors=always --configuration=phpunit.inline.xml",
|
||||
"test:parallel": "php bin/pest --colors=always --exclude-group=integration --parallel --processes=3",
|
||||
"test:integration": "php bin/pest --colors=always --group=integration -v",
|
||||
"update:snapshots": "REBUILD_SNAPSHOTS=true php bin/pest --colors=always --update-snapshots",
|
||||
"test": [
|
||||
"@test:lint",
|
||||
"@test:type:check",
|
||||
"@test:type:coverage",
|
||||
"@test:unit",
|
||||
"@test:parallel",
|
||||
"@test:integration"
|
||||
@ -122,7 +102,6 @@
|
||||
"Pest\\Plugins\\Snapshot",
|
||||
"Pest\\Plugins\\Verbose",
|
||||
"Pest\\Plugins\\Version",
|
||||
"Pest\\Plugins\\Shard",
|
||||
"Pest\\Plugins\\Parallel"
|
||||
]
|
||||
},
|
||||
|
||||
14
docker-compose.yml
Normal file
14
docker-compose.yml
Normal file
@ -0,0 +1,14 @@
|
||||
version: "3.8"
|
||||
|
||||
services:
|
||||
php:
|
||||
build:
|
||||
context: ./docker
|
||||
volumes:
|
||||
- .:/var/www/html
|
||||
composer:
|
||||
build:
|
||||
context: ./docker
|
||||
volumes:
|
||||
- .:/var/www/html
|
||||
entrypoint: ["composer"]
|
||||
@ -52,8 +52,6 @@ use PHPUnit\Util\Filter;
|
||||
use PHPUnit\Util\ThrowableToStringMapper;
|
||||
|
||||
/**
|
||||
* @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
|
||||
*
|
||||
* @internal This class is not covered by the backward compatibility promise for PHPUnit
|
||||
*/
|
||||
final readonly class ThrowableBuilder
|
||||
@ -84,7 +82,7 @@ final readonly class ThrowableBuilder
|
||||
$t->getMessage(),
|
||||
ThrowableToStringMapper::map($t),
|
||||
$trace,
|
||||
$previous,
|
||||
$previous
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
@ -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.
|
||||
*
|
||||
|
||||
@ -99,9 +99,7 @@ abstract class NameFilterIterator extends RecursiveFilterIterator
|
||||
}
|
||||
|
||||
if ($test instanceof HasPrintableTestCaseName) {
|
||||
$name = trim(
|
||||
$test::getPrintableTestCaseName().'::'.$test->getPrintableTestCaseMethodName().$test->dataSetAsString()
|
||||
);
|
||||
$name = $test::getPrintableTestCaseName().'::'.$test->getPrintableTestCaseMethodName();
|
||||
} else {
|
||||
$name = $test::class.'::'.$test->nameWithDataSet();
|
||||
}
|
||||
|
||||
@ -72,7 +72,10 @@ use function Pest\version;
|
||||
*/
|
||||
final class DefaultResultCache implements ResultCache
|
||||
{
|
||||
private const string DEFAULT_RESULT_CACHE_FILENAME = '.phpunit.result.cache';
|
||||
/**
|
||||
* @var string
|
||||
*/
|
||||
private const DEFAULT_RESULT_CACHE_FILENAME = '.phpunit.result.cache';
|
||||
|
||||
private readonly string $cacheFilename;
|
||||
|
||||
|
||||
@ -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;
|
||||
}
|
||||
}
|
||||
@ -45,7 +45,6 @@ declare(strict_types=1);
|
||||
namespace PHPUnit\TextUI;
|
||||
|
||||
use Pest\Plugins\Only;
|
||||
use Pest\Runner\Filter\EnsureTestCaseIsInitiatedFilter;
|
||||
use PHPUnit\Event;
|
||||
use PHPUnit\Framework\TestSuite;
|
||||
use PHPUnit\Runner\Filter\Factory;
|
||||
@ -67,12 +66,6 @@ final readonly class TestSuiteFilterProcessor
|
||||
{
|
||||
$factory = new Factory;
|
||||
|
||||
// @phpstan-ignore-next-line
|
||||
(fn () => $this->filters[] = [
|
||||
'className' => EnsureTestCaseIsInitiatedFilter::class,
|
||||
'argument' => '',
|
||||
])->call($factory);
|
||||
|
||||
if (! $configuration->hasFilter() &&
|
||||
! $configuration->hasGroups() &&
|
||||
! $configuration->hasExcludeGroups() &&
|
||||
@ -80,8 +73,6 @@ final readonly class TestSuiteFilterProcessor
|
||||
! $configuration->hasTestsCovering() &&
|
||||
! $configuration->hasTestsUsing() &&
|
||||
! Only::isEnabled()) {
|
||||
$suite->injectFilter($factory);
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
|
||||
@ -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#"
|
||||
|
||||
@ -16,7 +16,6 @@
|
||||
<testsuites>
|
||||
<testsuite name="default">
|
||||
<directory suffix=".php">./tests</directory>
|
||||
<directory suffix=".php">./tests-external</directory>
|
||||
<exclude>./tests/.snapshots</exclude>
|
||||
<exclude>./tests/.tests</exclude>
|
||||
<exclude>./tests/Fixtures/Inheritance</exclude>
|
||||
|
||||
@ -2,10 +2,7 @@
|
||||
|
||||
declare(strict_types=1);
|
||||
|
||||
use Rector\CodingStyle\Rector\ArrowFunction\ArrowFunctionDelegatingCallToFirstClassCallableRector;
|
||||
use Rector\Config\RectorConfig;
|
||||
use Rector\DeadCode\Rector\ClassMethod\RemoveParentDelegatingConstructorRector;
|
||||
use Rector\TypeDeclaration\Rector\ClassMethod\NarrowObjectReturnTypeRector;
|
||||
use Rector\TypeDeclaration\Rector\ClassMethod\ReturnNeverTypeRector;
|
||||
|
||||
return RectorConfig::configure()
|
||||
@ -15,9 +12,6 @@ return RectorConfig::configure()
|
||||
->withSkip([
|
||||
__DIR__.'/src/Plugins/Parallel/Paratest/WrapperRunner.php',
|
||||
ReturnNeverTypeRector::class,
|
||||
ArrowFunctionDelegatingCallToFirstClassCallableRector::class,
|
||||
NarrowObjectReturnTypeRector::class,
|
||||
RemoveParentDelegatingConstructorRector::class,
|
||||
])
|
||||
->withPreparedSets(
|
||||
deadCode: true,
|
||||
|
||||
@ -1,22 +0,0 @@
|
||||
<div class="mx-2 mb-1">
|
||||
<p>
|
||||
<span>Using the <span class="text-yellow font-bold">visit()</span> function requires the Pest Plugin Browser to be installed.</span>
|
||||
|
||||
<span class="ml-1 text-yellow font-bold">Run:</span>
|
||||
</p>
|
||||
|
||||
<div>
|
||||
<span class="text-gray mr-1">- </span>
|
||||
<span>composer require pestphp/pest-plugin-browser:^4.0 --dev</span>
|
||||
</div>
|
||||
|
||||
<div>
|
||||
<span class="text-gray mr-1">- </span>
|
||||
<span>npm install playwright@latest</span>
|
||||
</div>
|
||||
|
||||
<div>
|
||||
<span class="text-gray mr-1">- </span>
|
||||
<span>npx playwright install</span>
|
||||
</div>
|
||||
</div>
|
||||
@ -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')
|
||||
@ -153,7 +150,7 @@ final class Laravel extends AbstractPreset
|
||||
->toHaveSuffix('Controller');
|
||||
|
||||
$this->expectations[] = expect('App\Http')
|
||||
->toOnlyBeUsedIn(['App\Http', 'App\Providers']);
|
||||
->toOnlyBeUsedIn('App\Http');
|
||||
|
||||
$this->expectations[] = expect('App\Http\Controllers')
|
||||
->not->toHavePublicMethodsBesides(['__construct', '__invoke', 'index', 'show', 'create', 'store', 'edit', 'update', 'destroy', 'middleware']);
|
||||
|
||||
@ -32,6 +32,7 @@ final class Security extends AbstractPreset
|
||||
'create_function',
|
||||
'unserialize',
|
||||
'extract',
|
||||
'parse_str',
|
||||
'mb_parse_str',
|
||||
'dl',
|
||||
'assert',
|
||||
|
||||
@ -17,7 +17,7 @@ final class BootExcludeList implements Bootstrapper
|
||||
*
|
||||
* @var array<int, non-empty-string>
|
||||
*/
|
||||
private const array EXCLUDE_LIST = [
|
||||
private const EXCLUDE_LIST = [
|
||||
'bin',
|
||||
'overrides',
|
||||
'resources',
|
||||
|
||||
@ -5,7 +5,6 @@ declare(strict_types=1);
|
||||
namespace Pest\Bootstrappers;
|
||||
|
||||
use Pest\Contracts\Bootstrapper;
|
||||
use Pest\Exceptions\FatalException;
|
||||
use Pest\Support\DatasetInfo;
|
||||
use Pest\Support\Str;
|
||||
use Pest\TestSuite;
|
||||
@ -25,7 +24,7 @@ final class BootFiles implements Bootstrapper
|
||||
*
|
||||
* @var array<int, string>
|
||||
*/
|
||||
private const array STRUCTURE = [
|
||||
private const STRUCTURE = [
|
||||
'Expectations',
|
||||
'Expectations.php',
|
||||
'Helpers',
|
||||
@ -41,10 +40,6 @@ final class BootFiles implements Bootstrapper
|
||||
$rootPath = TestSuite::getInstance()->rootPath;
|
||||
$testsPath = $rootPath.DIRECTORY_SEPARATOR.testDirectory();
|
||||
|
||||
if (! is_dir($testsPath)) {
|
||||
throw new FatalException(sprintf('The test directory [%s] does not exist.', $testsPath));
|
||||
}
|
||||
|
||||
foreach (self::STRUCTURE as $filename) {
|
||||
$filename = sprintf('%s%s%s', $testsPath, DIRECTORY_SEPARATOR, $filename);
|
||||
|
||||
@ -83,7 +78,7 @@ final class BootFiles implements Bootstrapper
|
||||
|
||||
private function bootDatasets(string $testsPath): void
|
||||
{
|
||||
assert($testsPath !== '');
|
||||
assert(strlen($testsPath) > 0);
|
||||
|
||||
$files = (new PhpUnitFileIterator)->getFilesAsArray($testsPath, '.php');
|
||||
|
||||
|
||||
@ -15,18 +15,17 @@ final class BootOverrides implements Bootstrapper
|
||||
/**
|
||||
* The list of files to be overridden.
|
||||
*
|
||||
* @var array<int, string>
|
||||
* @var array<string, string>
|
||||
*/
|
||||
public const array FILES = [
|
||||
'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',
|
||||
'Event/Value/ThrowableBuilder.php',
|
||||
'Logging/JUnit/JunitXmlLogger.php',
|
||||
public const FILES = [
|
||||
'53c246e5f416a39817ac81124cdd64ea8403038d01d7a202e1ffa486fbdf3fa7' => 'Runner/Filter/NameFilterIterator.php',
|
||||
'77ffb7647b583bd82e37962c6fbdc4b04d3344d8a2c1ed103e625ed1ff7cb5c2' => 'Runner/ResultCache/DefaultResultCache.php',
|
||||
'd0e81317889ad88c707db4b08a94cadee4c9010d05ff0a759f04e71af5efed89' => 'Runner/TestSuiteLoader.php',
|
||||
'3bb609b0d3bf6dee8df8d6cd62a3c8ece823c4bb941eaaae39e3cb267171b9d2' => 'TextUI/Command/Commands/WarmCodeCoverageCacheCommand.php',
|
||||
'8abdad6413329c6fe0d7d44a8b9926e390af32c0b3123f3720bb9c5bbc6fbb7e' => 'TextUI/Output/Default/ProgressPrinter/Subscriber/TestSkippedSubscriber.php',
|
||||
'b4250fc3ffad5954624cb5e682fd940b874e8d3422fa1ee298bd7225e1aa5fc2' => 'TextUI/TestSuiteFilterProcessor.php',
|
||||
'8cfcb4999af79463eca51a42058e502ea4ddc776cba5677bf2f8eb6093e21a5c' => 'Event/Value/ThrowableBuilder.php',
|
||||
'86cd9bcaa53cdd59c5b13e58f30064a015c549501e7629d93b96893d4dee1eb1' => 'Logging/JUnit/JunitXmlLogger.php',
|
||||
];
|
||||
|
||||
/**
|
||||
|
||||
@ -20,7 +20,7 @@ final readonly class BootSubscribers implements Bootstrapper
|
||||
*
|
||||
* @var array<int, class-string<Subscriber>>
|
||||
*/
|
||||
private const array SUBSCRIBERS = [
|
||||
private const SUBSCRIBERS = [
|
||||
Subscribers\EnsureConfigurationIsAvailable::class,
|
||||
Subscribers\EnsureIgnorableTestCasesAreIgnored::class,
|
||||
Subscribers\EnsureKernelDumpIsFlushed::class,
|
||||
|
||||
@ -8,8 +8,6 @@ use Closure;
|
||||
|
||||
/**
|
||||
* @internal
|
||||
*
|
||||
* @template T of object
|
||||
*/
|
||||
trait Extendable
|
||||
{
|
||||
@ -22,8 +20,6 @@ trait Extendable
|
||||
|
||||
/**
|
||||
* Register a new extend.
|
||||
*
|
||||
* @param-closure-this T $extend
|
||||
*/
|
||||
public function extend(string $name, Closure $extend): void
|
||||
{
|
||||
|
||||
@ -6,16 +6,12 @@ namespace Pest\Concerns;
|
||||
|
||||
use Closure;
|
||||
use Pest\Exceptions\DatasetArgumentsMismatch;
|
||||
use Pest\Panic;
|
||||
use Pest\Preset;
|
||||
use Pest\Support\ChainableClosure;
|
||||
use Pest\Support\ExceptionTrace;
|
||||
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;
|
||||
@ -105,6 +101,27 @@ trait Testable
|
||||
*/
|
||||
private array $__snapshotChanges = [];
|
||||
|
||||
/**
|
||||
* Creates a new Test Case instance.
|
||||
*/
|
||||
public function __construct(string $name)
|
||||
{
|
||||
parent::__construct($name);
|
||||
|
||||
$test = TestSuite::getInstance()->tests->get(self::$__filename);
|
||||
|
||||
if ($test->hasMethod($name)) {
|
||||
$method = $test->getMethod($name);
|
||||
$this->__description = self::$__latestDescription = $method->description;
|
||||
self::$__latestAssignees = $method->assignees;
|
||||
self::$__latestNotes = $method->notes;
|
||||
self::$__latestIssues = $method->issues;
|
||||
self::$__latestPrs = $method->prs;
|
||||
$this->__describing = $method->describing;
|
||||
$this->__test = $method->getClosure();
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Resets the test case static properties.
|
||||
*/
|
||||
@ -197,11 +214,7 @@ trait Testable
|
||||
$beforeAll = ChainableClosure::boundStatically(self::$__beforeAll, $beforeAll);
|
||||
}
|
||||
|
||||
try {
|
||||
call_user_func(Closure::bind($beforeAll, null, self::class));
|
||||
} catch (Throwable $e) {
|
||||
Panic::with($e);
|
||||
}
|
||||
call_user_func(Closure::bind($beforeAll, null, self::class));
|
||||
}
|
||||
|
||||
/**
|
||||
@ -229,6 +242,8 @@ trait Testable
|
||||
|
||||
$method = TestSuite::getInstance()->tests->get(self::$__filename)->getMethod($this->name());
|
||||
|
||||
$method->setUp($this);
|
||||
|
||||
$description = $method->description;
|
||||
if ($this->dataName()) {
|
||||
$description = str_contains((string) $description, ':dataset')
|
||||
@ -270,33 +285,6 @@ trait Testable
|
||||
$this->__callClosure($beforeEach, $arguments);
|
||||
}
|
||||
|
||||
/**
|
||||
* Initialize test case properties from TestSuite.
|
||||
*/
|
||||
public function __initializeTestCase(): void
|
||||
{
|
||||
// Return if the test case has already been initialized
|
||||
if (isset($this->__test)) {
|
||||
return;
|
||||
}
|
||||
|
||||
$name = $this->name();
|
||||
$test = TestSuite::getInstance()->tests->get(self::$__filename);
|
||||
|
||||
if ($test->hasMethod($name)) {
|
||||
$method = $test->getMethod($name);
|
||||
$this->__description = self::$__latestDescription = $method->description;
|
||||
self::$__latestAssignees = $method->assignees;
|
||||
self::$__latestNotes = $method->notes;
|
||||
self::$__latestIssues = $method->issues;
|
||||
self::$__latestPrs = $method->prs;
|
||||
$this->__describing = $method->describing;
|
||||
$this->__test = $method->getClosure();
|
||||
|
||||
$method->setUp($this);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets executed after the Test Case.
|
||||
*/
|
||||
@ -330,80 +318,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 +340,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 +348,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 +374,7 @@ trait Testable
|
||||
return [$boundDatasetResult];
|
||||
}
|
||||
|
||||
return $boundDatasetResult;
|
||||
return array_values($boundDatasetResult);
|
||||
}
|
||||
|
||||
/**
|
||||
@ -524,7 +434,15 @@ trait Testable
|
||||
return;
|
||||
}
|
||||
|
||||
$this->markTestIncomplete(implode('. ', $this->__snapshotChanges));
|
||||
if (count($this->__snapshotChanges) === 1) {
|
||||
$this->markTestIncomplete($this->__snapshotChanges[0]);
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
$messages = implode(PHP_EOL, array_map(static fn (string $message): string => '- $message', $this->__snapshotChanges));
|
||||
|
||||
$this->markTestIncomplete($messages);
|
||||
}
|
||||
|
||||
/**
|
||||
@ -548,7 +466,7 @@ trait Testable
|
||||
*/
|
||||
public static function getLatestPrintableTestCaseMethodName(): string
|
||||
{
|
||||
return self::$__latestDescription ?? '';
|
||||
return self::$__latestDescription;
|
||||
}
|
||||
|
||||
/**
|
||||
@ -563,12 +481,4 @@ trait Testable
|
||||
'notes' => self::$__latestNotes,
|
||||
];
|
||||
}
|
||||
|
||||
/**
|
||||
* Opens a shell for the test case.
|
||||
*/
|
||||
public function shell(): void
|
||||
{
|
||||
Shell::open();
|
||||
}
|
||||
}
|
||||
|
||||
@ -4,7 +4,6 @@ declare(strict_types=1);
|
||||
|
||||
namespace Pest;
|
||||
|
||||
use Pest\PendingCalls\BeforeEachCall;
|
||||
use Pest\PendingCalls\UsesCall;
|
||||
|
||||
/**
|
||||
@ -63,14 +62,6 @@ final readonly class Configuration
|
||||
return (new UsesCall($this->filename, []))->group(...$groups);
|
||||
}
|
||||
|
||||
/**
|
||||
* Marks all tests in the current file to be run exclusively.
|
||||
*/
|
||||
public function only(): void
|
||||
{
|
||||
(new BeforeEachCall(TestSuite::getInstance(), $this->filename))->only();
|
||||
}
|
||||
|
||||
/**
|
||||
* Depending on where is called, it will extend the given classes and traits globally or locally.
|
||||
*/
|
||||
@ -111,14 +102,6 @@ final readonly class Configuration
|
||||
return Configuration\Project::getInstance();
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets the browser configuration.
|
||||
*/
|
||||
public function browser(): Browser\Configuration
|
||||
{
|
||||
return new Browser\Configuration;
|
||||
}
|
||||
|
||||
/**
|
||||
* Proxies calls to the uses method.
|
||||
*
|
||||
|
||||
@ -16,7 +16,7 @@ final readonly class Help
|
||||
*
|
||||
* @var array<int, string>
|
||||
*/
|
||||
private const array HELP_MESSAGES = [
|
||||
private const HELP_MESSAGES = [
|
||||
'<comment>Pest Options:</comment>',
|
||||
' <info>--init</info> Initialise a standard Pest configuration',
|
||||
' <info>--coverage</info> Enable coverage and output to standard output',
|
||||
|
||||
@ -22,11 +22,11 @@ final readonly class Thanks
|
||||
*
|
||||
* @var array<string, string>
|
||||
*/
|
||||
private const array FUNDING_MESSAGES = [
|
||||
private const FUNDING_MESSAGES = [
|
||||
'Star' => 'https://github.com/pestphp/pest',
|
||||
'YouTube' => 'https://youtube.com/@nunomaduro',
|
||||
'TikTok' => 'https://tiktok.com/@enunomaduro',
|
||||
'Twitch' => 'https://twitch.tv/nunomaduro',
|
||||
'TikTok' => 'https://tiktok.com/@nunomaduro',
|
||||
'Twitch' => 'https://twitch.tv/enunomaduro',
|
||||
'LinkedIn' => 'https://linkedin.com/in/nunomaduro',
|
||||
'Instagram' => 'https://instagram.com/enunomaduro',
|
||||
'X' => 'https://x.com/enunomaduro',
|
||||
|
||||
@ -22,7 +22,7 @@ final class DatasetMissing extends BadFunctionCallException implements Exception
|
||||
public function __construct(string $file, string $name, array $arguments)
|
||||
{
|
||||
parent::__construct(sprintf(
|
||||
'A test with the description [%s] has [%d] argument(s) ([%s]) and no dataset(s) provided in [%s]',
|
||||
"A test with the description '%s' has %d argument(s) ([%s]) and no dataset(s) provided in %s",
|
||||
$name,
|
||||
count($arguments),
|
||||
implode(', ', array_map(static fn (string $arg, string $type): string => sprintf('%s $%s', $type, $arg), array_keys($arguments), $arguments)),
|
||||
|
||||
@ -19,11 +19,7 @@ final class TestCaseAlreadyInUse extends InvalidArgumentException implements Exc
|
||||
*/
|
||||
public function __construct(string $inUse, string $newOne, string $folder)
|
||||
{
|
||||
parent::__construct(sprintf(
|
||||
'Test case [%s] can not be used. The folder [%s] already uses the test case [%s].',
|
||||
$newOne,
|
||||
$folder,
|
||||
$inUse,
|
||||
));
|
||||
parent::__construct(sprintf('Test case `%s` can not be used. The folder `%s` already uses the test case `%s`',
|
||||
$newOne, $folder, $inUse));
|
||||
}
|
||||
}
|
||||
|
||||
@ -22,7 +22,7 @@ final class TestClosureMustNotBeStatic extends InvalidArgumentException implemen
|
||||
{
|
||||
parent::__construct(
|
||||
sprintf(
|
||||
'Test closure must not be static. Please remove the [static] keyword from the [%s] method in [%s].',
|
||||
'Test closure must not be static. Please remove the `static` keyword from the `%s` method in `%s`.',
|
||||
$method->description,
|
||||
$method->filename
|
||||
)
|
||||
|
||||
@ -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;
|
||||
@ -53,9 +52,7 @@ use ReflectionProperty;
|
||||
*/
|
||||
final class Expectation
|
||||
{
|
||||
/** @use Extendable<self<TValue>> */
|
||||
use Extendable;
|
||||
|
||||
use Pipeable;
|
||||
use Retrievable;
|
||||
|
||||
@ -333,7 +330,7 @@ final class Expectation
|
||||
* @param array<int, mixed> $parameters
|
||||
* @return Expectation<TValue>|HigherOrderExpectation<Expectation<TValue>, TValue>
|
||||
*/
|
||||
public function __call(string $method, array $parameters): Expectation|HigherOrderExpectation|PendingArchExpectation|ArchExpectation
|
||||
public function __call(string $method, array $parameters): Expectation|HigherOrderExpectation|PendingArchExpectation
|
||||
{
|
||||
if (! self::hasMethod($method)) {
|
||||
if (! is_object($this->value) && method_exists(PendingArchExpectation::class, $method)) {
|
||||
@ -358,10 +355,6 @@ final class Expectation
|
||||
$reflectionClosure = new \ReflectionFunction($closure);
|
||||
$expectation = $reflectionClosure->getClosureThis();
|
||||
|
||||
if ($reflectionClosure->getReturnType()?->__toString() === ArchExpectation::class) {
|
||||
return $closure(...$parameters);
|
||||
}
|
||||
|
||||
assert(is_object($expectation));
|
||||
|
||||
ExpectationPipeline::for($closure)
|
||||
@ -400,7 +393,7 @@ final class Expectation
|
||||
*
|
||||
* @return Expectation<TValue>|OppositeExpectation<TValue>|EachExpectation<TValue>|HigherOrderExpectation<Expectation<TValue>, TValue|null>|TValue
|
||||
*/
|
||||
public function __get(string $name): mixed
|
||||
public function __get(string $name)
|
||||
{
|
||||
if (! self::hasMethod($name)) {
|
||||
if (! is_object($this->value) && method_exists(PendingArchExpectation::class, $name)) {
|
||||
@ -670,41 +663,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 +777,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;
|
||||
}
|
||||
}
|
||||
@ -947,14 +890,6 @@ final class Expectation
|
||||
return ToUseNothing::make($this);
|
||||
}
|
||||
|
||||
/**
|
||||
* Asserts that the source code of the given expectation target does not include suspicious characters.
|
||||
*/
|
||||
public function toHaveSuspiciousCharacters(): ArchExpectation
|
||||
{
|
||||
throw InvalidExpectation::fromMethods(['toHaveSuspiciousCharacters']);
|
||||
}
|
||||
|
||||
/**
|
||||
* Not supported.
|
||||
*/
|
||||
|
||||
@ -15,7 +15,6 @@ use Pest\Arch\PendingArchExpectation;
|
||||
use Pest\Arch\SingleArchExpectation;
|
||||
use Pest\Arch\Support\FileLineFinder;
|
||||
use Pest\Exceptions\InvalidExpectation;
|
||||
use Pest\Exceptions\MissingDependency;
|
||||
use Pest\Expectation;
|
||||
use Pest\Support\Arr;
|
||||
use Pest\Support\Exporter;
|
||||
@ -25,7 +24,6 @@ use PHPUnit\Framework\AssertionFailedError;
|
||||
use PHPUnit\Framework\ExpectationFailedException;
|
||||
use ReflectionMethod;
|
||||
use ReflectionProperty;
|
||||
use Spoofchecker;
|
||||
use stdClass;
|
||||
|
||||
/**
|
||||
@ -280,28 +278,6 @@ final readonly class OppositeExpectation
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* Asserts that the given expectation target does not have suspicious characters.
|
||||
*/
|
||||
public function toHaveSuspiciousCharacters(): ArchExpectation
|
||||
{
|
||||
if (! class_exists(Spoofchecker::class)) {
|
||||
throw new MissingDependency(__FUNCTION__, 'ext-intl >= 2.0');
|
||||
}
|
||||
|
||||
$checker = new Spoofchecker;
|
||||
|
||||
/** @var Expectation<array<int, string>|string> $original */
|
||||
$original = $this->original;
|
||||
|
||||
return Targeted::make(
|
||||
$original,
|
||||
fn (ObjectDescription $object): bool => ! $checker->isSuspicious((string) file_get_contents($object->path)),
|
||||
'to not include suspicious characters',
|
||||
FileLineFinder::where(fn (string $line): bool => $checker->isSuspicious($line)),
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* Asserts that the given expectation target does not have the given methods.
|
||||
*
|
||||
|
||||
10
src/Factories/Covers/CoversNothing.php
Normal file
10
src/Factories/Covers/CoversNothing.php
Normal file
@ -0,0 +1,10 @@
|
||||
<?php
|
||||
|
||||
declare(strict_types=1);
|
||||
|
||||
namespace Pest\Factories\Covers;
|
||||
|
||||
/**
|
||||
* @internal
|
||||
*/
|
||||
final class CoversNothing {}
|
||||
@ -59,11 +59,6 @@ final class TestCaseFactory
|
||||
Concerns\Expectable::class,
|
||||
];
|
||||
|
||||
/**
|
||||
* The namespace for the test case, overrides the path-based namespace when set.
|
||||
*/
|
||||
public ?string $namespace = null;
|
||||
|
||||
/**
|
||||
* Creates a new Factory instance.
|
||||
*/
|
||||
@ -116,8 +111,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;
|
||||
|
||||
@ -132,7 +127,7 @@ final class TestCaseFactory
|
||||
|
||||
$partsFQN = explode('\\', $classFQN);
|
||||
$className = array_pop($partsFQN);
|
||||
$namespace = $this->namespace ?? implode('\\', $partsFQN);
|
||||
$namespace = implode('\\', $partsFQN);
|
||||
$baseClass = sprintf('\%s', $this->class);
|
||||
|
||||
if (trim($className) === '') {
|
||||
|
||||
@ -9,7 +9,6 @@ use Pest\Evaluators\Attributes;
|
||||
use Pest\Exceptions\ShouldNotHappen;
|
||||
use Pest\Factories\Concerns\HigherOrderable;
|
||||
use Pest\Repositories\DatasetsRepository;
|
||||
use Pest\Support\Description;
|
||||
use Pest\Support\Str;
|
||||
use Pest\TestSuite;
|
||||
use PHPUnit\Framework\Assert;
|
||||
@ -36,7 +35,7 @@ final class TestCaseMethodFactory
|
||||
/**
|
||||
* The test's describing, if any.
|
||||
*
|
||||
* @var array<int, Description>
|
||||
* @var array<int, string>
|
||||
*/
|
||||
public array $describing = [];
|
||||
|
||||
@ -50,11 +49,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".
|
||||
*/
|
||||
|
||||
@ -2,13 +2,11 @@
|
||||
|
||||
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;
|
||||
use Pest\Expectation;
|
||||
use Pest\Installers\PluginBrowser;
|
||||
use Pest\Mutate\Contracts\MutationTestRunner;
|
||||
use Pest\Mutate\Repositories\ConfigurationRepository;
|
||||
use Pest\PendingCalls\AfterEachCall;
|
||||
@ -20,7 +18,6 @@ use Pest\Repositories\DatasetsRepository;
|
||||
use Pest\Support\Backtrace;
|
||||
use Pest\Support\Container;
|
||||
use Pest\Support\DatasetInfo;
|
||||
use Pest\Support\Description;
|
||||
use Pest\Support\HigherOrderTapProxy;
|
||||
use Pest\TestSuite;
|
||||
use PHPUnit\Framework\TestCase;
|
||||
@ -47,7 +44,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 +57,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,12 +88,14 @@ 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
|
||||
{
|
||||
$filename = Backtrace::testFile();
|
||||
|
||||
return new DescribeCall(TestSuite::getInstance(), $filename, new Description($description), $tests);
|
||||
return new DescribeCall(TestSuite::getInstance(), $filename, $description, $tests);
|
||||
}
|
||||
}
|
||||
|
||||
@ -107,7 +108,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 +120,7 @@ if (! function_exists('pest')) {
|
||||
*/
|
||||
function pest(): Configuration
|
||||
{
|
||||
return new Configuration(Backtrace::testFile());
|
||||
return new Configuration(Backtrace::file());
|
||||
}
|
||||
}
|
||||
|
||||
@ -129,9 +130,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 +152,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 +187,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 +206,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 +223,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 +252,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');
|
||||
@ -264,51 +278,3 @@ if (! function_exists('mutates')) {
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (! function_exists('fixture')) {
|
||||
/**
|
||||
* Returns the absolute path to a fixture file.
|
||||
*/
|
||||
function fixture(string $file): string
|
||||
{
|
||||
$file = implode(DIRECTORY_SEPARATOR, [
|
||||
TestSuite::getInstance()->rootPath,
|
||||
TestSuite::getInstance()->testPath,
|
||||
'Fixtures',
|
||||
str_replace(['/', '\\'], DIRECTORY_SEPARATOR, $file),
|
||||
]);
|
||||
|
||||
$fileRealPath = realpath($file);
|
||||
|
||||
if ($fileRealPath === false) {
|
||||
throw new InvalidArgumentException(
|
||||
'The fixture file ['.$file.'] does not exist.',
|
||||
);
|
||||
}
|
||||
|
||||
return $fileRealPath;
|
||||
}
|
||||
}
|
||||
|
||||
if (! function_exists('visit')) {
|
||||
/**
|
||||
* Browse to the given URL.
|
||||
*
|
||||
* @template TUrl of array<int, string>|string
|
||||
*
|
||||
* @param TUrl $url
|
||||
* @param array<string, mixed> $options
|
||||
* @return (TUrl is array<int, string> ? ArrayablePendingAwaitablePage : PendingAwaitablePage)
|
||||
*/
|
||||
function visit(array|string $url, array $options = []): ArrayablePendingAwaitablePage|PendingAwaitablePage
|
||||
{
|
||||
if (! class_exists(Pest\Browser\Configuration::class)) {
|
||||
PluginBrowser::install();
|
||||
|
||||
exit(0);
|
||||
}
|
||||
|
||||
// @phpstan-ignore-next-line
|
||||
return test()->visit($url, $options);
|
||||
}
|
||||
}
|
||||
|
||||
@ -1,15 +0,0 @@
|
||||
<?php
|
||||
|
||||
declare(strict_types=1);
|
||||
|
||||
namespace Pest\Installers;
|
||||
|
||||
use Pest\Support\View;
|
||||
|
||||
final readonly class PluginBrowser
|
||||
{
|
||||
public static function install(): void
|
||||
{
|
||||
View::render('installers/plugin-browser');
|
||||
}
|
||||
}
|
||||
@ -34,7 +34,7 @@ final readonly class Kernel
|
||||
*
|
||||
* @var array<int, class-string>
|
||||
*/
|
||||
private const array BOOTSTRAPPERS = [
|
||||
private const BOOTSTRAPPERS = [
|
||||
Bootstrappers\BootOverrides::class,
|
||||
Bootstrappers\BootSubscribers::class,
|
||||
Bootstrappers\BootFiles::class,
|
||||
@ -71,7 +71,7 @@ final readonly class Kernel
|
||||
$output,
|
||||
);
|
||||
|
||||
register_shutdown_function($kernel->shutdown(...));
|
||||
register_shutdown_function(fn () => $kernel->shutdown());
|
||||
|
||||
foreach (self::BOOTSTRAPPERS as $bootstrapper) {
|
||||
$bootstrapper = Container::getInstance()->get($bootstrapper);
|
||||
|
||||
@ -31,7 +31,7 @@ final readonly class Converter
|
||||
/**
|
||||
* The prefix for the test suite name.
|
||||
*/
|
||||
private const string PREFIX = 'P\\';
|
||||
private const PREFIX = 'P\\';
|
||||
|
||||
/**
|
||||
* The state generator.
|
||||
@ -131,7 +131,7 @@ final readonly class Converter
|
||||
|
||||
// clean the paths of each frame.
|
||||
$frames = array_map(
|
||||
$this->toRelativePath(...),
|
||||
fn (string $frame): string => $this->toRelativePath($frame),
|
||||
$frames
|
||||
);
|
||||
|
||||
|
||||
@ -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;
|
||||
@ -783,13 +782,15 @@ final class Expectation
|
||||
foreach ($array as $key => $value) {
|
||||
Assert::assertArrayHasKey($key, $valueAsArray, $message);
|
||||
|
||||
$assertMessage = $message !== '' ? $message : sprintf(
|
||||
'Failed asserting that an array has a key %s with the value %s.',
|
||||
$this->export($key),
|
||||
$this->export($valueAsArray[$key]),
|
||||
);
|
||||
if ($message === '') {
|
||||
$message = sprintf(
|
||||
'Failed asserting that an array has a key %s with the value %s.',
|
||||
$this->export($key),
|
||||
$this->export($valueAsArray[$key]),
|
||||
);
|
||||
}
|
||||
|
||||
Assert::assertEquals($value, $valueAsArray[$key], $assertMessage);
|
||||
Assert::assertEquals($value, $valueAsArray[$key], $message);
|
||||
}
|
||||
|
||||
return $this;
|
||||
@ -802,7 +803,7 @@ final class Expectation
|
||||
* @param iterable<string, mixed> $object
|
||||
* @return self<TValue>
|
||||
*/
|
||||
public function toMatchObject(object|iterable $object, string $message = ''): self
|
||||
public function toMatchObject(iterable $object, string $message = ''): self
|
||||
{
|
||||
foreach ((array) $object as $property => $value) {
|
||||
if (! is_object($this->value) && ! is_string($this->value)) {
|
||||
@ -814,13 +815,15 @@ final class Expectation
|
||||
/* @phpstan-ignore-next-line */
|
||||
$propertyValue = $this->value->{$property};
|
||||
|
||||
$assertMessage = $message !== '' ? $message : sprintf(
|
||||
'Failed asserting that an object has a property %s with the value %s.',
|
||||
$this->export($property),
|
||||
$this->export($propertyValue),
|
||||
);
|
||||
if ($message === '') {
|
||||
$message = sprintf(
|
||||
'Failed asserting that an object has a property %s with the value %s.',
|
||||
$this->export($property),
|
||||
$this->export($propertyValue),
|
||||
);
|
||||
}
|
||||
|
||||
Assert::assertEquals($value, $propertyValue, $assertMessage);
|
||||
Assert::assertEquals($value, $propertyValue, $message);
|
||||
}
|
||||
|
||||
return $this;
|
||||
@ -852,31 +855,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;
|
||||
@ -1169,21 +1159,4 @@ final class Expectation
|
||||
|
||||
return $this;
|
||||
}
|
||||
|
||||
/**
|
||||
* Asserts that the value can be converted to a slug
|
||||
*
|
||||
* @return self<TValue>
|
||||
*/
|
||||
public function toBeSlug(string $message = ''): self
|
||||
{
|
||||
if ($message === '') {
|
||||
$message = "Failed asserting that {$this->value} can be converted to a slug.";
|
||||
}
|
||||
|
||||
$slug = Str::slugify((string) $this->value);
|
||||
Assert::assertNotEmpty($slug, $message);
|
||||
|
||||
return $this;
|
||||
}
|
||||
}
|
||||
|
||||
@ -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();
|
||||
}
|
||||
}
|
||||
@ -4,8 +4,6 @@ declare(strict_types=1);
|
||||
|
||||
namespace Pest\PendingCalls\Concerns;
|
||||
|
||||
use Pest\Support\Description;
|
||||
|
||||
/**
|
||||
* @internal
|
||||
*/
|
||||
@ -14,14 +12,14 @@ trait Describable
|
||||
/**
|
||||
* Note: this is property is not used; however, it gets added automatically by rector php.
|
||||
*
|
||||
* @var array<int, Description>
|
||||
* @var array<int, string>
|
||||
*/
|
||||
public array $__describing;
|
||||
|
||||
/**
|
||||
* The describing of the test case.
|
||||
*
|
||||
* @var array<int, Description>
|
||||
* @var array<int, string>
|
||||
*/
|
||||
public array $describing = [];
|
||||
}
|
||||
|
||||
@ -5,7 +5,7 @@ declare(strict_types=1);
|
||||
namespace Pest\PendingCalls;
|
||||
|
||||
use Closure;
|
||||
use Pest\Support\Description;
|
||||
use Pest\Support\Backtrace;
|
||||
use Pest\TestSuite;
|
||||
|
||||
/**
|
||||
@ -16,7 +16,7 @@ final class DescribeCall
|
||||
/**
|
||||
* The current describe call.
|
||||
*
|
||||
* @var array<int, Description>
|
||||
* @var array<int, string>
|
||||
*/
|
||||
private static array $describing = [];
|
||||
|
||||
@ -31,7 +31,7 @@ final class DescribeCall
|
||||
public function __construct(
|
||||
public readonly TestSuite $testSuite,
|
||||
public readonly string $filename,
|
||||
public readonly Description $description,
|
||||
public readonly string $description,
|
||||
public readonly Closure $tests
|
||||
) {
|
||||
//
|
||||
@ -40,7 +40,7 @@ final class DescribeCall
|
||||
/**
|
||||
* What is the current describing.
|
||||
*
|
||||
* @return array<int, Description>
|
||||
* @return array<int, string>
|
||||
*/
|
||||
public static function describing(): array
|
||||
{
|
||||
@ -52,11 +52,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 +70,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);
|
||||
|
||||
@ -12,7 +12,6 @@ use Pest\Factories\Attribute;
|
||||
use Pest\Factories\TestCaseMethodFactory;
|
||||
use Pest\Mutate\Repositories\ConfigurationRepository;
|
||||
use Pest\PendingCalls\Concerns\Describable;
|
||||
use Pest\Plugins\Environment;
|
||||
use Pest\Plugins\Only;
|
||||
use Pest\Support\Backtrace;
|
||||
use Pest\Support\Container;
|
||||
@ -24,6 +23,7 @@ use Pest\TestSuite;
|
||||
use PHPUnit\Framework\AssertionFailedError;
|
||||
use PHPUnit\Framework\Attributes\CoversClass;
|
||||
use PHPUnit\Framework\Attributes\CoversFunction;
|
||||
use PHPUnit\Framework\Attributes\CoversNothing;
|
||||
use PHPUnit\Framework\Attributes\CoversTrait;
|
||||
use PHPUnit\Framework\Attributes\Group;
|
||||
use PHPUnit\Framework\TestCase;
|
||||
@ -183,9 +183,10 @@ final class TestCall // @phpstan-ignore-line
|
||||
}
|
||||
|
||||
/**
|
||||
* Runs the current test multiple times with each item of the given `iterable`.
|
||||
* Runs the current test multiple times with
|
||||
* each item of the given `iterable`.
|
||||
*
|
||||
* @param Closure|iterable<array-key, mixed>|string $data
|
||||
* @param array<Closure|iterable<int|string, mixed>|string> $data
|
||||
*/
|
||||
public function with(Closure|iterable|string ...$data): self
|
||||
{
|
||||
@ -319,61 +320,6 @@ final class TestCall // @phpstan-ignore-line
|
||||
: $this;
|
||||
}
|
||||
|
||||
/**
|
||||
* Weather the current test is running on a CI environment.
|
||||
*/
|
||||
private function runningOnCI(): bool
|
||||
{
|
||||
foreach ([
|
||||
'CI',
|
||||
'GITHUB_ACTIONS',
|
||||
'GITLAB_CI',
|
||||
'CIRCLECI',
|
||||
'TRAVIS',
|
||||
'APPVEYOR',
|
||||
'BITBUCKET_BUILD_NUMBER',
|
||||
'BUILDKITE',
|
||||
'TEAMCITY_VERSION',
|
||||
'JENKINS_URL',
|
||||
'SYSTEM_COLLECTIONURI',
|
||||
'CI_NAME',
|
||||
'TASKCLUSTER_ROOT_URL',
|
||||
'DRONE',
|
||||
'WERCKER',
|
||||
'NEVERCODE',
|
||||
'SEMAPHORE',
|
||||
'NETLIFY',
|
||||
'NOW_BUILDER',
|
||||
] as $env) {
|
||||
if (getenv($env) !== false) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
return Environment::name() === Environment::CI;
|
||||
}
|
||||
|
||||
/**
|
||||
* Skips the current test when running on a CI environments.
|
||||
*/
|
||||
public function skipOnCI(): self
|
||||
{
|
||||
if ($this->runningOnCI()) {
|
||||
return $this->skip('This test is skipped on [CI].');
|
||||
}
|
||||
|
||||
return $this;
|
||||
}
|
||||
|
||||
public function skipLocally(): self
|
||||
{
|
||||
if ($this->runningOnCI() === false) {
|
||||
return $this->skip('This test is skipped [locally].');
|
||||
}
|
||||
|
||||
return $this;
|
||||
}
|
||||
|
||||
/**
|
||||
* Skips the current test unless the given test is running on Windows.
|
||||
*/
|
||||
@ -412,20 +358,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".
|
||||
*/
|
||||
@ -677,29 +609,18 @@ final class TestCall // @phpstan-ignore-line
|
||||
}
|
||||
|
||||
/**
|
||||
* Adds one or more references to the tested method or class. This helps
|
||||
* to link test cases to the source code for easier navigation.
|
||||
*
|
||||
* @param array<class-string|string>|class-string ...$classes
|
||||
* Sets that the current test covers nothing.
|
||||
*/
|
||||
public function references(string|array ...$classes): self
|
||||
public function coversNothing(): self
|
||||
{
|
||||
assert($classes !== []);
|
||||
$this->testCaseMethod->attributes[] = new Attribute(
|
||||
CoversNothing::class,
|
||||
[],
|
||||
);
|
||||
|
||||
return $this;
|
||||
}
|
||||
|
||||
/**
|
||||
* Adds one or more references to the tested method or class. This helps
|
||||
* to link test cases to the source code for easier navigation.
|
||||
*
|
||||
* @param array<class-string|string>|class-string ...$classes
|
||||
*/
|
||||
public function see(string|array ...$classes): self
|
||||
{
|
||||
return $this->references(...$classes);
|
||||
}
|
||||
|
||||
/**
|
||||
* Informs the test runner that no expectations happen in this test,
|
||||
* and its purpose is simply to check whether the given code can
|
||||
@ -777,12 +698,7 @@ final class TestCall // @phpstan-ignore-line
|
||||
$this->testSuite->tests->set($this->testCaseMethod);
|
||||
|
||||
if (! is_null($testCase = $this->testSuite->tests->get($this->filename))) {
|
||||
$attributesToMerge = array_filter(
|
||||
$this->testCaseFactoryAttributes,
|
||||
fn (Attribute $attributeToMerge): bool => array_filter($testCase->attributes, fn (Attribute $attribute): bool => serialize($attributeToMerge) === serialize($attribute)) === []
|
||||
);
|
||||
|
||||
$testCase->attributes = array_merge($testCase->attributes, $attributesToMerge);
|
||||
$testCase->attributes = array_merge($testCase->attributes, $this->testCaseFactoryAttributes);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@ -6,7 +6,7 @@ namespace Pest;
|
||||
|
||||
function version(): string
|
||||
{
|
||||
return '4.6.2';
|
||||
return '3.8.6';
|
||||
}
|
||||
|
||||
function testDirectory(string $file = ''): string
|
||||
|
||||
@ -21,7 +21,7 @@ final class Cache implements HandlesArguments
|
||||
/**
|
||||
* The temporary folder.
|
||||
*/
|
||||
private const string TEMPORARY_FOLDER = __DIR__
|
||||
private const TEMPORARY_FOLDER = __DIR__
|
||||
.DIRECTORY_SEPARATOR
|
||||
.'..'
|
||||
.DIRECTORY_SEPARATOR
|
||||
|
||||
@ -56,31 +56,4 @@ trait HandleArguments
|
||||
|
||||
return array_values(array_flip($arguments));
|
||||
}
|
||||
|
||||
/**
|
||||
* Pops the given argument and its value from the arguments, returning the value.
|
||||
*
|
||||
* @param array<int, string> $arguments
|
||||
*/
|
||||
public function popArgumentValue(string $argument, array &$arguments): ?string
|
||||
{
|
||||
foreach ($arguments as $key => $value) {
|
||||
if (str_contains($value, "$argument=")) {
|
||||
unset($arguments[$key]);
|
||||
$arguments = array_values($arguments);
|
||||
|
||||
return substr($value, strlen($argument) + 1);
|
||||
}
|
||||
|
||||
if ($value === $argument && isset($arguments[$key + 1])) {
|
||||
$result = $arguments[$key + 1];
|
||||
unset($arguments[$key], $arguments[$key + 1]);
|
||||
$arguments = array_values($arguments);
|
||||
|
||||
return $result;
|
||||
}
|
||||
}
|
||||
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
||||
@ -21,7 +21,7 @@ final class Configuration implements HandlesArguments, Terminable
|
||||
/**
|
||||
* The base PHPUnit file.
|
||||
*/
|
||||
public const string BASE_PHPUNIT_FILE = __DIR__
|
||||
public const BASE_PHPUNIT_FILE = __DIR__
|
||||
.DIRECTORY_SEPARATOR
|
||||
.'..'
|
||||
.DIRECTORY_SEPARATOR
|
||||
@ -34,7 +34,7 @@ final class Configuration implements HandlesArguments, Terminable
|
||||
*/
|
||||
public function handleArguments(array $arguments): array
|
||||
{
|
||||
if ($this->hasArgument('--configuration', $arguments) || $this->hasArgument('-c', $arguments) || $this->hasCustomConfigurationFile()) {
|
||||
if ($this->hasArgument('--configuration', $arguments) || $this->hasCustomConfigurationFile()) {
|
||||
return $arguments;
|
||||
}
|
||||
|
||||
|
||||
@ -17,13 +17,20 @@ use Symfony\Component\Console\Output\OutputInterface;
|
||||
*/
|
||||
final class Coverage implements AddsOutput, HandlesArguments
|
||||
{
|
||||
private const string COVERAGE_OPTION = 'coverage';
|
||||
/**
|
||||
* @var string
|
||||
*/
|
||||
private const COVERAGE_OPTION = 'coverage';
|
||||
|
||||
private const string MIN_OPTION = 'min';
|
||||
/**
|
||||
* @var string
|
||||
*/
|
||||
private const MIN_OPTION = 'min';
|
||||
|
||||
private const string EXACTLY_OPTION = 'exactly';
|
||||
|
||||
private const string ONLY_COVERED_OPTION = 'only-covered';
|
||||
/**
|
||||
* @var string
|
||||
*/
|
||||
private const EXACTLY_OPTION = 'exactly';
|
||||
|
||||
/**
|
||||
* Whether it should show the coverage or not.
|
||||
@ -45,11 +52,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 +66,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 +89,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 +129,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 +153,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) {
|
||||
|
||||
@ -14,12 +14,12 @@ final class Environment implements HandlesArguments
|
||||
/**
|
||||
* The continuous integration environment.
|
||||
*/
|
||||
public const string CI = 'ci';
|
||||
public const CI = 'ci';
|
||||
|
||||
/**
|
||||
* The local environment.
|
||||
*/
|
||||
public const string LOCAL = 'local';
|
||||
public const LOCAL = 'local';
|
||||
|
||||
/**
|
||||
* The current environment.
|
||||
|
||||
@ -99,7 +99,6 @@ final readonly class Help implements HandlesArguments
|
||||
{
|
||||
$helpReflection = new PHPUnitHelp;
|
||||
|
||||
// @phpstan-ignore-next-line
|
||||
$content = (fn (): array => $this->elements())->call($helpReflection);
|
||||
|
||||
$content['Configuration'] = [...[[
|
||||
@ -107,13 +106,6 @@ final readonly class Help implements HandlesArguments
|
||||
'desc' => 'Initialise a standard Pest configuration',
|
||||
]], ...$content['Configuration']];
|
||||
|
||||
$content['AI'] = [
|
||||
[
|
||||
'arg' => '--ai',
|
||||
'desc' => 'Run a code snippet as a fully scaffolded test for AI verification',
|
||||
],
|
||||
];
|
||||
|
||||
$content['Execution'] = [...[
|
||||
[
|
||||
'arg' => '--parallel',
|
||||
@ -123,10 +115,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'] = [[
|
||||
@ -153,12 +141,6 @@ final readonly class Help implements HandlesArguments
|
||||
], [
|
||||
'arg' => '--retry',
|
||||
'desc' => 'Run non-passing tests first and stop execution upon first error or failure',
|
||||
], [
|
||||
'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 +156,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'] = [[
|
||||
|
||||
@ -20,12 +20,12 @@ final readonly class Init implements HandlesArguments
|
||||
/**
|
||||
* The option the triggers the init job.
|
||||
*/
|
||||
private const string INIT_OPTION = '--init';
|
||||
private const INIT_OPTION = '--init';
|
||||
|
||||
/**
|
||||
* The files that will be created.
|
||||
*/
|
||||
private const array STUBS = [
|
||||
private const STUBS = [
|
||||
'phpunit.xml.stub' => 'phpunit.xml',
|
||||
'Pest.php.stub' => 'tests/Pest.php',
|
||||
'TestCase.php.stub' => 'tests/TestCase.php',
|
||||
|
||||
@ -5,10 +5,7 @@ declare(strict_types=1);
|
||||
namespace Pest\Plugins;
|
||||
|
||||
use Pest\Contracts\Plugins\Terminable;
|
||||
use Pest\Factories\Attribute;
|
||||
use Pest\Factories\TestCaseMethodFactory;
|
||||
use Pest\PendingCalls\TestCall;
|
||||
use PHPUnit\Framework\Attributes\Group;
|
||||
|
||||
/**
|
||||
* @internal
|
||||
@ -18,7 +15,7 @@ final class Only implements Terminable
|
||||
/**
|
||||
* The temporary folder.
|
||||
*/
|
||||
private const string TEMPORARY_FOLDER = __DIR__
|
||||
private const TEMPORARY_FOLDER = __DIR__
|
||||
.DIRECTORY_SEPARATOR
|
||||
.'..'
|
||||
.DIRECTORY_SEPARATOR
|
||||
@ -26,19 +23,28 @@ final class Only implements Terminable
|
||||
.DIRECTORY_SEPARATOR
|
||||
.'.temp';
|
||||
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
*/
|
||||
public function terminate(): void
|
||||
{
|
||||
if (Parallel::isWorker()) {
|
||||
return;
|
||||
}
|
||||
|
||||
$lockFile = self::TEMPORARY_FOLDER.DIRECTORY_SEPARATOR.'only.lock';
|
||||
|
||||
if (file_exists($lockFile)) {
|
||||
unlink($lockFile);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Creates the lock file.
|
||||
*/
|
||||
public static function enable(TestCall|TestCaseMethodFactory $testCall, string $group = '__pest_only'): void
|
||||
public static function enable(TestCall $testCall, string $group = '__pest_only'): void
|
||||
{
|
||||
if ($testCall instanceof TestCall) {
|
||||
$testCall->group($group);
|
||||
} else {
|
||||
$testCall->attributes[] = new Attribute(
|
||||
Group::class,
|
||||
[$group],
|
||||
);
|
||||
}
|
||||
$testCall->group($group);
|
||||
|
||||
if (Environment::name() === Environment::CI || Parallel::isWorker()) {
|
||||
return;
|
||||
@ -82,20 +88,4 @@ final class Only implements Terminable
|
||||
|
||||
return file_get_contents($lockFile) ?: '__pest_only'; // @phpstan-ignore-line
|
||||
}
|
||||
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
*/
|
||||
public function terminate(): void
|
||||
{
|
||||
if (Parallel::isWorker()) {
|
||||
return;
|
||||
}
|
||||
|
||||
$lockFile = self::TEMPORARY_FOLDER.DIRECTORY_SEPARATOR.'only.lock';
|
||||
|
||||
if (file_exists($lockFile)) {
|
||||
unlink($lockFile);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@ -23,9 +23,9 @@ final class Parallel implements HandlesArguments
|
||||
{
|
||||
use HandleArguments;
|
||||
|
||||
private const string GLOBAL_PREFIX = 'PEST_PARALLEL_GLOBAL_';
|
||||
private const GLOBAL_PREFIX = 'PEST_PARALLEL_GLOBAL_';
|
||||
|
||||
private const array HANDLERS = [
|
||||
private const HANDLERS = [
|
||||
Parallel\Handlers\Parallel::class,
|
||||
Parallel\Handlers\Pest::class,
|
||||
Parallel\Handlers\Laravel::class,
|
||||
@ -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 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);
|
||||
}
|
||||
@ -199,18 +197,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;
|
||||
}
|
||||
}
|
||||
|
||||
@ -18,7 +18,7 @@ final class Parallel implements HandlesArguments
|
||||
/**
|
||||
* The list of arguments to remove.
|
||||
*/
|
||||
private const array ARGS_TO_REMOVE = [
|
||||
private const ARGS_TO_REMOVE = [
|
||||
'--parallel',
|
||||
'-p',
|
||||
'--no-output',
|
||||
|
||||
@ -11,7 +11,6 @@ final class CleanConsoleOutput extends ConsoleOutput
|
||||
/**
|
||||
* {@inheritdoc}
|
||||
*/
|
||||
#[\Override]
|
||||
protected function doWrite(string $message, bool $newline): void // @pest-arch-ignore-line
|
||||
{
|
||||
if ($this->isOpeningHeadline($message)) {
|
||||
|
||||
@ -59,10 +59,10 @@ final class ResultPrinter
|
||||
private readonly OutputInterface $output,
|
||||
private readonly Options $options
|
||||
) {
|
||||
$this->printer = new readonly class($this->output) implements Printer
|
||||
$this->printer = new class($this->output) implements Printer
|
||||
{
|
||||
public function __construct(
|
||||
private OutputInterface $output,
|
||||
private readonly OutputInterface $output,
|
||||
) {}
|
||||
|
||||
public function print(string $buffer): void
|
||||
@ -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
|
||||
|
||||
@ -17,7 +17,6 @@ use ParaTest\WrapperRunner\WrapperWorker;
|
||||
use Pest\Result;
|
||||
use Pest\TestSuite;
|
||||
use PHPUnit\Event\Facade as EventFacade;
|
||||
use PHPUnit\Event\Test\AfterLastTestMethodFailed;
|
||||
use PHPUnit\Event\TestRunner\WarningTriggered;
|
||||
use PHPUnit\Runner\CodeCoverage;
|
||||
use PHPUnit\Runner\ResultCache\DefaultResultCache;
|
||||
@ -39,7 +38,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;
|
||||
@ -52,12 +50,7 @@ final class WrapperRunner implements RunnerInterface
|
||||
/**
|
||||
* The time to sleep between cycles.
|
||||
*/
|
||||
/**
|
||||
* The merged test result from the parallel run.
|
||||
*/
|
||||
public static ?TestResult $result = null;
|
||||
|
||||
private const int CYCLE_SLEEP = 10000;
|
||||
private const CYCLE_SLEEP = 10000;
|
||||
|
||||
/**
|
||||
* The result printer.
|
||||
@ -137,7 +130,6 @@ final class WrapperRunner implements RunnerInterface
|
||||
$parameters = $this->handleLaravelHerd($parameters);
|
||||
|
||||
$parameters[] = $wrapper;
|
||||
$parameters[] = '--test-directory='.TestSuite::getInstance()->testPath;
|
||||
|
||||
$this->parameters = $parameters;
|
||||
$this->codeCoverageFilterRegistry = new CodeCoverageFilterRegistry;
|
||||
@ -232,7 +224,7 @@ final class WrapperRunner implements RunnerInterface
|
||||
$this->printer->printFeedback(
|
||||
$worker->progressFile,
|
||||
$worker->unexpectedOutputFile,
|
||||
$worker->teamcityFile ?? null,
|
||||
$this->teamcityFiles,
|
||||
);
|
||||
$worker->reset();
|
||||
}
|
||||
@ -321,42 +313,27 @@ final class WrapperRunner implements RunnerInterface
|
||||
$testResult = unserialize($contents);
|
||||
assert($testResult instanceof TestResult);
|
||||
|
||||
/** @var list<AfterLastTestMethodFailed> $failedEvents */
|
||||
$failedEvents = array_merge_recursive($testResultSum->testFailedEvents(), $testResult->testFailedEvents());
|
||||
|
||||
$testResultSum = new TestResult(
|
||||
(int) $testResultSum->hasTests() + (int) $testResult->hasTests(),
|
||||
$testResultSum->numberOfTestsRun() + $testResult->numberOfTestsRun(),
|
||||
$testResultSum->numberOfAssertions() + $testResult->numberOfAssertions(),
|
||||
array_merge_recursive($testResultSum->testErroredEvents(), $testResult->testErroredEvents()),
|
||||
$failedEvents,
|
||||
array_merge_recursive($testResultSum->testFailedEvents(), $testResult->testFailedEvents()),
|
||||
array_merge_recursive($testResultSum->testConsideredRiskyEvents(), $testResult->testConsideredRiskyEvents()),
|
||||
array_merge_recursive($testResultSum->testSuiteSkippedEvents(), $testResult->testSuiteSkippedEvents()),
|
||||
array_merge_recursive($testResultSum->testSkippedEvents(), $testResult->testSkippedEvents()),
|
||||
array_merge_recursive($testResultSum->testMarkedIncompleteEvents(), $testResult->testMarkedIncompleteEvents()),
|
||||
array_merge_recursive($testResultSum->testTriggeredPhpunitDeprecationEvents(), $testResult->testTriggeredPhpunitDeprecationEvents()),
|
||||
array_merge_recursive($testResultSum->testTriggeredPhpunitErrorEvents(), $testResult->testTriggeredPhpunitErrorEvents()),
|
||||
array_merge_recursive($testResultSum->testTriggeredPhpunitNoticeEvents(), $testResult->testTriggeredPhpunitNoticeEvents()),
|
||||
array_merge_recursive($testResultSum->testTriggeredPhpunitWarningEvents(), $testResult->testTriggeredPhpunitWarningEvents()),
|
||||
// @phpstan-ignore-next-line
|
||||
array_merge_recursive($testResultSum->testRunnerTriggeredDeprecationEvents(), $testResult->testRunnerTriggeredDeprecationEvents()),
|
||||
// @phpstan-ignore-next-line
|
||||
array_merge_recursive($testResultSum->testRunnerTriggeredNoticeEvents(), $testResult->testRunnerTriggeredNoticeEvents()),
|
||||
// @phpstan-ignore-next-line
|
||||
array_merge_recursive($testResultSum->testRunnerTriggeredWarningEvents(), $testResult->testRunnerTriggeredWarningEvents()),
|
||||
// @phpstan-ignore-next-line
|
||||
array_merge_recursive($testResultSum->errors(), $testResult->errors()),
|
||||
// @phpstan-ignore-next-line
|
||||
array_merge_recursive($testResultSum->deprecations(), $testResult->deprecations()),
|
||||
// @phpstan-ignore-next-line
|
||||
array_merge_recursive($testResultSum->notices(), $testResult->notices()),
|
||||
// @phpstan-ignore-next-line
|
||||
array_merge_recursive($testResultSum->warnings(), $testResult->warnings()),
|
||||
// @phpstan-ignore-next-line
|
||||
array_merge_recursive($testResultSum->phpDeprecations(), $testResult->phpDeprecations()),
|
||||
// @phpstan-ignore-next-line
|
||||
array_merge_recursive($testResultSum->phpNotices(), $testResult->phpNotices()),
|
||||
// @phpstan-ignore-next-line
|
||||
array_merge_recursive($testResultSum->phpWarnings(), $testResult->phpWarnings()),
|
||||
$testResultSum->numberOfIssuesIgnoredByBaseline() + $testResult->numberOfIssuesIgnoredByBaseline(),
|
||||
);
|
||||
@ -374,10 +351,8 @@ final class WrapperRunner implements RunnerInterface
|
||||
$testResultSum->testMarkedIncompleteEvents(),
|
||||
$testResultSum->testTriggeredPhpunitDeprecationEvents(),
|
||||
$testResultSum->testTriggeredPhpunitErrorEvents(),
|
||||
$testResultSum->testTriggeredPhpunitNoticeEvents(),
|
||||
$testResultSum->testTriggeredPhpunitWarningEvents(),
|
||||
$testResultSum->testRunnerTriggeredDeprecationEvents(),
|
||||
$testResultSum->testRunnerTriggeredNoticeEvents(),
|
||||
array_values(array_filter(
|
||||
$testResultSum->testRunnerTriggeredWarningEvents(),
|
||||
fn (WarningTriggered $event): bool => ! str_contains($event->message(), 'No tests found')
|
||||
@ -392,8 +367,6 @@ final class WrapperRunner implements RunnerInterface
|
||||
$testResultSum->numberOfIssuesIgnoredByBaseline(),
|
||||
);
|
||||
|
||||
self::$result = $testResultSum;
|
||||
|
||||
if ($this->options->configuration->cacheResult()) {
|
||||
$resultCacheSum = new DefaultResultCache($this->options->configuration->testResultCacheFile());
|
||||
foreach ($this->resultCacheFiles as $resultCacheFile) {
|
||||
@ -492,61 +465,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
|
||||
}
|
||||
}
|
||||
|
||||
@ -34,7 +34,7 @@ final class CompactPrinter
|
||||
/**
|
||||
* @var array<string, array<int, string>>
|
||||
*/
|
||||
private const array LOOKUP_TABLE = [
|
||||
private const LOOKUP_TABLE = [
|
||||
'.' => ['gray', '.'],
|
||||
'S' => ['yellow', 's'],
|
||||
'T' => ['cyan', 't'],
|
||||
@ -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,
|
||||
);
|
||||
}
|
||||
@ -131,14 +131,14 @@ final class CompactPrinter
|
||||
$status['collected'],
|
||||
$status['threshold'],
|
||||
$status['roots'],
|
||||
0.00,
|
||||
0.00,
|
||||
0.00,
|
||||
0.00,
|
||||
false,
|
||||
false,
|
||||
false,
|
||||
0,
|
||||
null,
|
||||
null,
|
||||
null,
|
||||
null,
|
||||
null,
|
||||
null,
|
||||
null,
|
||||
null,
|
||||
);
|
||||
|
||||
$telemetry = new Info(
|
||||
|
||||
@ -1,530 +0,0 @@
|
||||
<?php
|
||||
|
||||
declare(strict_types=1);
|
||||
|
||||
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;
|
||||
use Symfony\Component\Process\Process;
|
||||
|
||||
/**
|
||||
* @internal
|
||||
*/
|
||||
final class Shard implements AddsOutput, HandlesArguments, Terminable
|
||||
{
|
||||
use Concerns\HandleArguments;
|
||||
|
||||
private const string SHARD_OPTION = 'shard';
|
||||
|
||||
/**
|
||||
* The shard index and total number of shards.
|
||||
*
|
||||
* @var array{
|
||||
* index: int,
|
||||
* total: int,
|
||||
* testsRan: int,
|
||||
* testsCount: int
|
||||
* }|null
|
||||
*/
|
||||
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.
|
||||
*/
|
||||
public function __construct(
|
||||
private readonly OutputInterface $output,
|
||||
) {
|
||||
//
|
||||
}
|
||||
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
*/
|
||||
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;
|
||||
}
|
||||
|
||||
// @phpstan-ignore-next-line
|
||||
$input = new ArgvInput($arguments);
|
||||
|
||||
['index' => $index, 'total' => $total] = self::getShard($input);
|
||||
|
||||
$arguments = $this->popArgument("--shard=$index/$total", $this->popArgument('--shard', $this->popArgument(
|
||||
"$index/$total",
|
||||
$arguments,
|
||||
)));
|
||||
|
||||
/** @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] ?? [];
|
||||
}
|
||||
|
||||
self::$shard = [
|
||||
'index' => $index,
|
||||
'total' => $total,
|
||||
'testsRan' => count($testsToRun),
|
||||
'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.
|
||||
*
|
||||
* @param list<string> $arguments
|
||||
* @return list<string>
|
||||
*/
|
||||
private function allTests(array $arguments): array
|
||||
{
|
||||
$output = (new Process([
|
||||
'php',
|
||||
...$this->removeParallelArguments($arguments),
|
||||
'--list-tests',
|
||||
]))->setTimeout(120)->mustRun()->getOutput();
|
||||
|
||||
preg_match_all('/ - (?:P\\\\)?(Tests\\\\[^:]+)::/', $output, $matches);
|
||||
|
||||
return array_values(array_unique($matches[1]));
|
||||
}
|
||||
|
||||
/**
|
||||
* @param array<int, string> $arguments
|
||||
* @return array<int, string>
|
||||
*/
|
||||
private function removeParallelArguments(array $arguments): array
|
||||
{
|
||||
return array_filter($arguments, fn (string $argument): bool => ! in_array($argument, ['--parallel', '-p'], strict: true));
|
||||
}
|
||||
|
||||
/**
|
||||
* Builds the filter argument for the given tests to run.
|
||||
*/
|
||||
private function buildFilterArgument(mixed $testsToRun): string
|
||||
{
|
||||
return addslashes(implode('|', $testsToRun));
|
||||
}
|
||||
|
||||
/**
|
||||
* Adds output after the Test Suite execution.
|
||||
*/
|
||||
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;
|
||||
}
|
||||
|
||||
[
|
||||
'index' => $index,
|
||||
'total' => $total,
|
||||
'testsRan' => $testsRan,
|
||||
'testsCount' => $testsCount,
|
||||
] = self::$shard;
|
||||
|
||||
$this->output->writeln(sprintf(
|
||||
' <fg=gray>Shard:</> <fg=default>%d of %d</> — %d file%s ran, out of %d%s.',
|
||||
$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.
|
||||
*
|
||||
* @return array{index: int, total: int}
|
||||
*/
|
||||
public static function getShard(InputInterface $input): array
|
||||
{
|
||||
if ($input->hasParameterOption('--'.self::SHARD_OPTION)) {
|
||||
$shard = $input->getParameterOption('--'.self::SHARD_OPTION);
|
||||
} else {
|
||||
$shard = null;
|
||||
}
|
||||
|
||||
if (! is_string($shard) || ! preg_match('/^\d+\/\d+$/', $shard)) {
|
||||
throw new InvalidOption('The [--shard] option must be in the format "index/total".');
|
||||
}
|
||||
|
||||
[$index, $total] = explode('/', $shard);
|
||||
|
||||
if (! is_numeric($index) || ! is_numeric($total)) {
|
||||
throw new InvalidOption('The [--shard] option must be in the format "index/total".');
|
||||
}
|
||||
|
||||
if ($index <= 0 || $total <= 0 || $index > $total) {
|
||||
throw new InvalidOption('The [--shard] option index must be a non-negative integer less than the total number of shards.');
|
||||
}
|
||||
|
||||
$index = (int) $index;
|
||||
$total = (int) $total;
|
||||
|
||||
return [
|
||||
'index' => $index,
|
||||
'total' => $total,
|
||||
];
|
||||
}
|
||||
}
|
||||
@ -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;
|
||||
}
|
||||
}
|
||||
|
||||
@ -16,7 +16,7 @@ final class Verbose implements HandlesArguments
|
||||
/**
|
||||
* The list of verbosity levels.
|
||||
*/
|
||||
private const array VERBOSITY_LEVELS = ['v', 'vv', 'vvv', 'q'];
|
||||
private const VERBOSITY_LEVELS = ['v', 'vv', 'vvv', 'q'];
|
||||
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
|
||||
@ -19,7 +19,7 @@ use function sprintf;
|
||||
*/
|
||||
final class DatasetsRepository
|
||||
{
|
||||
private const string SEPARATOR = '>>';
|
||||
private const SEPARATOR = '>>';
|
||||
|
||||
/**
|
||||
* Holds the datasets.
|
||||
@ -67,11 +67,11 @@ final class DatasetsRepository
|
||||
}
|
||||
|
||||
/**
|
||||
* @return array<int|string, mixed>
|
||||
* @return Closure|array<int|string, mixed>
|
||||
*
|
||||
* @throws ShouldNotHappen
|
||||
*/
|
||||
public static function get(string $filename, string $description): array // @phpstan-ignore-line
|
||||
public static function get(string $filename, string $description): Closure|array // @phpstan-ignore-line
|
||||
{
|
||||
$dataset = self::$withs[$filename.self::SEPARATOR.$description];
|
||||
|
||||
@ -191,7 +191,6 @@ final class DatasetsRepository
|
||||
return str_starts_with($currentTestFile, $datasetScope);
|
||||
}, ARRAY_FILTER_USE_KEY);
|
||||
|
||||
/** @var string|null $closestScopeDatasetKey */
|
||||
$closestScopeDatasetKey = array_reduce(
|
||||
array_keys($matchingDatasets),
|
||||
fn (string|int|null $keyA, string|int|null $keyB): string|int|null => $keyA !== null && strlen((string) $keyA) > strlen((string) $keyB) ? $keyA : $keyB
|
||||
@ -201,6 +200,7 @@ final class DatasetsRepository
|
||||
throw new DatasetDoesNotExist($name);
|
||||
}
|
||||
|
||||
// @phpstan-ignore-next-line
|
||||
return $matchingDatasets[$closestScopeDatasetKey];
|
||||
}
|
||||
|
||||
|
||||
@ -19,7 +19,6 @@ final class SnapshotRepository
|
||||
* Creates a snapshot repository instance.
|
||||
*/
|
||||
public function __construct(
|
||||
private readonly string $rootPath,
|
||||
private readonly string $testsPath,
|
||||
private readonly string $snapshotsPath,
|
||||
) {}
|
||||
@ -59,10 +58,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);
|
||||
@ -106,19 +103,7 @@ final class SnapshotRepository
|
||||
*/
|
||||
private function getSnapshotFilename(): string
|
||||
{
|
||||
$testFile = TestSuite::getInstance()->getFilename();
|
||||
|
||||
if (str_starts_with($testFile, $this->testsPath)) {
|
||||
// if the test file is in the tests directory
|
||||
$startPath = $this->testsPath;
|
||||
} else {
|
||||
// if the test file is in the app, src, etc. directory
|
||||
$startPath = $this->rootPath;
|
||||
}
|
||||
|
||||
// relative path: we use substr() and not str_replace() to remove the start path
|
||||
// for instance, if the $startPath is /app/ and the $testFile is /app/app/tests/Unit/ExampleTest.php, we should only remove the first /app/ from the path
|
||||
$relativePath = substr($testFile, strlen($startPath));
|
||||
$relativePath = str_replace($this->testsPath, '', TestSuite::getInstance()->getFilename());
|
||||
|
||||
// remove extension from filename
|
||||
$relativePath = substr($relativePath, 0, (int) strrpos($relativePath, '.'));
|
||||
|
||||
@ -113,16 +113,6 @@ final class TestRepository
|
||||
$this->testCaseMethodFilters[] = $filter;
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets the class and traits configured for the given directory path.
|
||||
*
|
||||
* @return array<int, string>
|
||||
*/
|
||||
public function getUsesForPath(string $path): array
|
||||
{
|
||||
return $this->uses[$path][0] ?? [];
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets the test case factory from the given filename.
|
||||
*/
|
||||
|
||||
@ -4,16 +4,20 @@ declare(strict_types=1);
|
||||
|
||||
namespace Pest;
|
||||
|
||||
use NunoMaduro\Collision\Adapters\Phpunit\Support\ResultReflection;
|
||||
use PHPUnit\TestRunner\TestResult\TestResult;
|
||||
use PHPUnit\TextUI\Configuration\Configuration;
|
||||
use PHPUnit\TextUI\ShellExitCodeCalculator;
|
||||
|
||||
/**
|
||||
* @internal
|
||||
*/
|
||||
final class Result
|
||||
{
|
||||
private const int SUCCESS_EXIT = 0;
|
||||
private const SUCCESS_EXIT = 0;
|
||||
|
||||
private const FAILURE_EXIT = 1;
|
||||
|
||||
private const EXCEPTION_EXIT = 2;
|
||||
|
||||
/**
|
||||
* If the exit code is different from 0.
|
||||
@ -36,8 +40,44 @@ final class Result
|
||||
*/
|
||||
public static function exitCode(Configuration $configuration, TestResult $result): int
|
||||
{
|
||||
$shell = new ShellExitCodeCalculator;
|
||||
if ($result->wasSuccessful()) {
|
||||
if ($configuration->failOnWarning()) {
|
||||
$warnings = $result->numberOfTestsWithTestTriggeredPhpunitWarningEvents()
|
||||
+ count($result->warnings())
|
||||
+ count($result->phpWarnings());
|
||||
|
||||
return $shell->calculate($configuration, $result);
|
||||
if ($warnings > 0) {
|
||||
return self::FAILURE_EXIT;
|
||||
}
|
||||
}
|
||||
|
||||
if (! $result->hasTestTriggeredPhpunitWarningEvents()) {
|
||||
return self::SUCCESS_EXIT;
|
||||
}
|
||||
}
|
||||
|
||||
if ($configuration->failOnEmptyTestSuite() && ResultReflection::numberOfTests($result) === 0) {
|
||||
return self::FAILURE_EXIT;
|
||||
}
|
||||
|
||||
if ($result->wasSuccessful()) {
|
||||
if ($configuration->failOnRisky() && $result->hasTestConsideredRiskyEvents()) {
|
||||
$returnCode = self::FAILURE_EXIT;
|
||||
}
|
||||
|
||||
if ($configuration->failOnIncomplete() && $result->hasTestMarkedIncompleteEvents()) {
|
||||
$returnCode = self::FAILURE_EXIT;
|
||||
}
|
||||
|
||||
if ($configuration->failOnSkipped() && $result->hasTestSkippedEvents()) {
|
||||
$returnCode = self::FAILURE_EXIT;
|
||||
}
|
||||
}
|
||||
|
||||
if ($result->hasTestErroredEvents()) {
|
||||
return self::EXCEPTION_EXIT;
|
||||
}
|
||||
|
||||
return self::FAILURE_EXIT;
|
||||
}
|
||||
}
|
||||
|
||||
@ -1,39 +0,0 @@
|
||||
<?php
|
||||
|
||||
declare(strict_types=1);
|
||||
|
||||
namespace Pest\Runner\Filter;
|
||||
|
||||
use Pest\Contracts\HasPrintableTestCaseName;
|
||||
use PHPUnit\Framework\Test;
|
||||
use RecursiveFilterIterator;
|
||||
use RecursiveIterator;
|
||||
|
||||
/**
|
||||
* @internal
|
||||
*/
|
||||
final class EnsureTestCaseIsInitiatedFilter extends RecursiveFilterIterator
|
||||
{
|
||||
/**
|
||||
* @param RecursiveIterator<int, Test> $iterator
|
||||
*/
|
||||
public function __construct(RecursiveIterator $iterator)
|
||||
{
|
||||
parent::__construct($iterator);
|
||||
}
|
||||
|
||||
/**
|
||||
* {@inheritdoc}
|
||||
*/
|
||||
public function accept(): bool
|
||||
{
|
||||
$test = $this->getInnerIterator()->current();
|
||||
|
||||
if ($test instanceof HasPrintableTestCaseName) {
|
||||
/** @phpstan-ignore-next-line */
|
||||
$test->__initializeTestCase();
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
}
|
||||
@ -33,7 +33,7 @@ final class EnsureIgnorableTestCasesAreIgnored implements StartedSubscriber
|
||||
/** @var array<int, WarningTriggered> $testRunnerTriggeredWarningEvents */
|
||||
$testRunnerTriggeredWarningEvents = $property->getValue($collector);
|
||||
|
||||
$testRunnerTriggeredWarningEvents = array_values(array_filter($testRunnerTriggeredWarningEvents, fn (WarningTriggered $event): bool => str_contains($event->message(), 'No tests found in class') === false));
|
||||
$testRunnerTriggeredWarningEvents = array_values(array_filter($testRunnerTriggeredWarningEvents, fn (WarningTriggered $event): bool => $event->message() !== 'No tests found in class "Pest\TestCases\IgnorableTestCase".'));
|
||||
|
||||
$property->setValue($collector, $testRunnerTriggeredWarningEvents);
|
||||
}
|
||||
|
||||
@ -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;
|
||||
}
|
||||
}
|
||||
@ -11,9 +11,12 @@ use Pest\Exceptions\ShouldNotHappen;
|
||||
*/
|
||||
final class Backtrace
|
||||
{
|
||||
private const string FILE = 'file';
|
||||
/**
|
||||
* @var string
|
||||
*/
|
||||
private const FILE = 'file';
|
||||
|
||||
private const int BACKTRACE_OPTIONS = DEBUG_BACKTRACE_IGNORE_ARGS;
|
||||
private const BACKTRACE_OPTIONS = DEBUG_BACKTRACE_IGNORE_ARGS;
|
||||
|
||||
/**
|
||||
* Returns the current test file.
|
||||
@ -23,9 +26,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]);
|
||||
|
||||
|
||||
@ -74,7 +74,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()) {
|
||||
@ -109,10 +109,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, '.', '');
|
||||
|
||||
@ -11,13 +11,13 @@ use function Pest\testDirectory;
|
||||
*/
|
||||
final class DatasetInfo
|
||||
{
|
||||
public const string DATASETS_DIR_NAME = 'Datasets';
|
||||
public const DATASETS_DIR_NAME = 'Datasets';
|
||||
|
||||
public const string DATASETS_FILE_NAME = 'Datasets.php';
|
||||
public const DATASETS_FILE_NAME = 'Datasets.php';
|
||||
|
||||
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);
|
||||
}
|
||||
}
|
||||
|
||||
@ -1,21 +0,0 @@
|
||||
<?php
|
||||
|
||||
declare(strict_types=1);
|
||||
|
||||
namespace Pest\Support;
|
||||
|
||||
final readonly class Description implements \Stringable
|
||||
{
|
||||
/**
|
||||
* Creates a new Description instance.
|
||||
*/
|
||||
public function __construct(private string $description) {}
|
||||
|
||||
/**
|
||||
* Returns the description as a string.
|
||||
*/
|
||||
public function __toString(): string
|
||||
{
|
||||
return $this->description;
|
||||
}
|
||||
}
|
||||
@ -13,7 +13,7 @@ use Throwable;
|
||||
*/
|
||||
final class ExceptionTrace
|
||||
{
|
||||
private const string UNDEFINED_METHOD = 'Call to undefined method P\\';
|
||||
private const UNDEFINED_METHOD = 'Call to undefined method P\\';
|
||||
|
||||
/**
|
||||
* Ensures the given closure reports the good execution context.
|
||||
@ -26,7 +26,6 @@ final class ExceptionTrace
|
||||
return $closure();
|
||||
} catch (Throwable $throwable) {
|
||||
if (Str::startsWith($message = $throwable->getMessage(), self::UNDEFINED_METHOD)) {
|
||||
// @phpstan-ignore-next-line
|
||||
$class = preg_match('/^Call to undefined method ([^:]+)::/', $message, $matches) === false ? null : $matches[1];
|
||||
|
||||
$message = str_replace(self::UNDEFINED_METHOD, 'Call to undefined method ', $message);
|
||||
|
||||
@ -15,7 +15,7 @@ final readonly class Exporter
|
||||
/**
|
||||
* The maximum number of items in an array to export.
|
||||
*/
|
||||
private const int MAX_ARRAY_ITEMS = 3;
|
||||
private const MAX_ARRAY_ITEMS = 3;
|
||||
|
||||
/**
|
||||
* Creates a new Exporter instance.
|
||||
|
||||
@ -13,7 +13,7 @@ use Throwable;
|
||||
*/
|
||||
final class HigherOrderMessage
|
||||
{
|
||||
public const string UNDEFINED_METHOD = 'Method %s does not exist';
|
||||
public const UNDEFINED_METHOD = 'Method %s does not exist';
|
||||
|
||||
/**
|
||||
* An optional condition that will determine if the message will be executed.
|
||||
|
||||
@ -31,8 +31,10 @@ final class HigherOrderTapProxy
|
||||
|
||||
/**
|
||||
* Dynamically pass properties gets to the target.
|
||||
*
|
||||
* @return mixed
|
||||
*/
|
||||
public function __get(string $property): mixed
|
||||
public function __get(string $property)
|
||||
{
|
||||
if (property_exists($this->target, $property)) {
|
||||
return $this->target->{$property};
|
||||
|
||||
@ -1,101 +0,0 @@
|
||||
<?php
|
||||
|
||||
declare(strict_types=1);
|
||||
|
||||
namespace Pest\Support;
|
||||
|
||||
use Illuminate\Support\Env;
|
||||
use Laravel\Tinker\ClassAliasAutoloader;
|
||||
use Pest\TestSuite;
|
||||
use Psy\Configuration;
|
||||
use Psy\Shell as PsyShell;
|
||||
use Psy\VersionUpdater\Checker;
|
||||
|
||||
/**
|
||||
* @internal
|
||||
*/
|
||||
final class Shell
|
||||
{
|
||||
/**
|
||||
* Creates a new interactive shell.
|
||||
*/
|
||||
public static function open(): void
|
||||
{
|
||||
$config = new Configuration;
|
||||
|
||||
$config->setUpdateCheck(Checker::NEVER);
|
||||
|
||||
$config->getPresenter()->addCasters(self::casters());
|
||||
|
||||
$shell = new PsyShell($config);
|
||||
|
||||
$loader = self::tinkered($shell);
|
||||
|
||||
try {
|
||||
$shell->run();
|
||||
} finally {
|
||||
$loader?->unregister(); // @phpstan-ignore-line
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the casters for the Psy Shell.
|
||||
*
|
||||
* @return array<string, callable>
|
||||
*/
|
||||
private static function casters(): array
|
||||
{
|
||||
$casters = [
|
||||
'Illuminate\Support\Collection' => 'Laravel\Tinker\TinkerCaster::castCollection',
|
||||
'Illuminate\Support\HtmlString' => 'Laravel\Tinker\TinkerCaster::castHtmlString',
|
||||
'Illuminate\Support\Stringable' => 'Laravel\Tinker\TinkerCaster::castStringable',
|
||||
];
|
||||
|
||||
if (class_exists('Illuminate\Database\Eloquent\Model')) {
|
||||
$casters['Illuminate\Database\Eloquent\Model'] = 'Laravel\Tinker\TinkerCaster::castModel';
|
||||
}
|
||||
|
||||
if (class_exists('Illuminate\Process\ProcessResult')) {
|
||||
$casters['Illuminate\Process\ProcessResult'] = 'Laravel\Tinker\TinkerCaster::castProcessResult';
|
||||
}
|
||||
|
||||
if (class_exists('Illuminate\Foundation\Application')) {
|
||||
$casters['Illuminate\Foundation\Application'] = 'Laravel\Tinker\TinkerCaster::castApplication';
|
||||
}
|
||||
|
||||
if (function_exists('app') === false) {
|
||||
return $casters; // @phpstan-ignore-line
|
||||
}
|
||||
|
||||
$config = app()->make('config');
|
||||
|
||||
return array_merge($casters, (array) $config->get('tinker.casters', []));
|
||||
}
|
||||
|
||||
/**
|
||||
* Tinkers the current shell, if the Tinker package is available.
|
||||
*/
|
||||
private static function tinkered(PsyShell $shell): ?object
|
||||
{
|
||||
if (function_exists('app') === false
|
||||
|| ! class_exists(Env::class)
|
||||
|| ! class_exists(ClassAliasAutoloader::class)
|
||||
) {
|
||||
return null;
|
||||
}
|
||||
|
||||
$path = Env::get('COMPOSER_VENDOR_DIR', app()->basePath().DIRECTORY_SEPARATOR.'vendor');
|
||||
|
||||
$path .= '/composer/autoload_classmap.php';
|
||||
|
||||
if (! file_exists($path)) {
|
||||
$path = TestSuite::getInstance()->rootPath.DIRECTORY_SEPARATOR.'vendor'.DIRECTORY_SEPARATOR.'composer'.DIRECTORY_SEPARATOR.'autoload_classmap.php';
|
||||
}
|
||||
|
||||
$config = app()->make('config');
|
||||
|
||||
return ClassAliasAutoloader::register(
|
||||
$shell, $path, $config->get('tinker.alias', []), $config->get('tinker.dont_alias', [])
|
||||
);
|
||||
}
|
||||
}
|
||||
@ -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()))
|
||||
));
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@ -13,9 +13,12 @@ final class Str
|
||||
* Pool of alpha-numeric characters for generating (unsafe) random strings
|
||||
* from.
|
||||
*/
|
||||
private const string POOL = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ';
|
||||
private const POOL = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ';
|
||||
|
||||
private const string PREFIX = '__pest_evaluable_';
|
||||
/**
|
||||
* @var string
|
||||
*/
|
||||
private const PREFIX = '__pest_evaluable_';
|
||||
|
||||
/**
|
||||
* Create a (unsecure & non-cryptographically safe) random alpha-numeric
|
||||
@ -79,7 +82,7 @@ final class Str
|
||||
return $subject;
|
||||
}
|
||||
|
||||
return mb_substr($subject, 0, $pos);
|
||||
return substr($subject, 0, $pos);
|
||||
}
|
||||
|
||||
/**
|
||||
@ -101,7 +104,7 @@ final class Str
|
||||
/**
|
||||
* Creates a describe block as `$describeDescription` → `$testDescription` format.
|
||||
*
|
||||
* @param array<int, Description> $describeDescriptions
|
||||
* @param array<int, string> $describeDescriptions
|
||||
*/
|
||||
public static function describe(array $describeDescriptions, string $testDescription): string
|
||||
{
|
||||
@ -117,14 +120,4 @@ final class Str
|
||||
{
|
||||
return (bool) filter_var($value, FILTER_VALIDATE_URL);
|
||||
}
|
||||
|
||||
/**
|
||||
* Converts the given `$target` to a URL-friendly "slug".
|
||||
*/
|
||||
public static function slugify(string $target): string
|
||||
{
|
||||
$target = preg_replace('/[^a-zA-Z0-9]+/', '-', $target);
|
||||
|
||||
return strtolower(trim((string) $target, '-'));
|
||||
}
|
||||
}
|
||||
|
||||
@ -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;
|
||||
}
|
||||
}
|
||||
@ -78,7 +78,6 @@ final class TestSuite
|
||||
$this->afterAll = new AfterAllRepository;
|
||||
$this->rootPath = (string) realpath($rootPath);
|
||||
$this->snapshots = new SnapshotRepository(
|
||||
$this->rootPath,
|
||||
implode(DIRECTORY_SEPARATOR, [$this->rootPath, $this->testPath]),
|
||||
implode(DIRECTORY_SEPARATOR, ['.pest', 'snapshots']),
|
||||
);
|
||||
@ -102,7 +101,7 @@ final class TestSuite
|
||||
}
|
||||
|
||||
if (! self::$instance instanceof self) {
|
||||
throw new InvalidPestCommand;
|
||||
Panic::with(new InvalidPestCommand);
|
||||
}
|
||||
|
||||
return self::$instance;
|
||||
@ -120,7 +119,7 @@ final class TestSuite
|
||||
assert($this->test instanceof TestCase);
|
||||
|
||||
$description = str_replace('__pest_evaluable_', '', $this->test->name());
|
||||
$datasetAsString = str_replace('__pest_evaluable_', '', Str::evaluable($this->test->dataSetAsString()));
|
||||
$datasetAsString = str_replace('__pest_evaluable_', '', Str::evaluable($this->test->dataSetAsStringWithData()));
|
||||
|
||||
return str_replace(' ', '_', $description.$datasetAsString);
|
||||
}
|
||||
|
||||
@ -1,8 +1,5 @@
|
||||
<?php
|
||||
|
||||
use Illuminate\Foundation\Testing\RefreshDatabase;
|
||||
use Tests\TestCase;
|
||||
|
||||
/*
|
||||
|--------------------------------------------------------------------------
|
||||
| Test Case
|
||||
@ -10,12 +7,12 @@ 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.
|
||||
|
|
||||
*/
|
||||
|
||||
pest()->extend(TestCase::class)
|
||||
// ->use(RefreshDatabase::class)
|
||||
pest()->extend(Tests\TestCase::class)
|
||||
// ->use(Illuminate\Foundation\Testing\RefreshDatabase::class)
|
||||
->in('Feature');
|
||||
|
||||
/*
|
||||
|
||||
@ -1,7 +1,5 @@
|
||||
<?php
|
||||
|
||||
use Tests\TestCase;
|
||||
|
||||
/*
|
||||
|--------------------------------------------------------------------------
|
||||
| Test Case
|
||||
@ -9,11 +7,11 @@ 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.
|
||||
|
|
||||
*/
|
||||
|
||||
pest()->extend(TestCase::class)->in('Feature');
|
||||
pest()->extend(Tests\TestCase::class)->in('Feature');
|
||||
|
||||
/*
|
||||
|--------------------------------------------------------------------------
|
||||
|
||||
@ -1,35 +0,0 @@
|
||||
<?php
|
||||
|
||||
use Pest\TestSuite;
|
||||
|
||||
beforeEach(function () {
|
||||
$this->snapshotable = <<<'HTML'
|
||||
<div class="container">
|
||||
<div class="row">
|
||||
<div class="col-md-12">
|
||||
<h1>Snapshot</h1>
|
||||
</div>
|
||||
</div>
|
||||
</div>
|
||||
HTML;
|
||||
});
|
||||
|
||||
test('pass with dataset', function ($data) {
|
||||
TestSuite::getInstance()->snapshots->save($this->snapshotable);
|
||||
[$filename] = TestSuite::getInstance()->snapshots->get();
|
||||
|
||||
expect($filename)->toStartWith('tests/.pest/snapshots-external/')
|
||||
->toEndWith('pass_with_dataset_with_data_set____my_datas_set_value___.snap')
|
||||
->and($this->snapshotable)->toMatchSnapshot();
|
||||
})->with(['my-datas-set-value']);
|
||||
|
||||
describe('within describe', function () {
|
||||
test('pass with dataset', function ($data) {
|
||||
TestSuite::getInstance()->snapshots->save($this->snapshotable);
|
||||
[$filename] = TestSuite::getInstance()->snapshots->get();
|
||||
|
||||
expect($filename)->toStartWith('tests/.pest/snapshots-external/')
|
||||
->toEndWith('pass_with_dataset_with_data_set____my_datas_set_value___.snap')
|
||||
->and($this->snapshotable)->toMatchSnapshot();
|
||||
});
|
||||
})->with(['my-datas-set-value']);
|
||||
@ -1,7 +0,0 @@
|
||||
<div class="container">
|
||||
<div class="row">
|
||||
<div class="col-md-12">
|
||||
<h1>Snapshot</h1>
|
||||
</div>
|
||||
</div>
|
||||
</div>
|
||||
@ -1,7 +0,0 @@
|
||||
<div class="container">
|
||||
<div class="row">
|
||||
<div class="col-md-12">
|
||||
<h1>Snapshot</h1>
|
||||
</div>
|
||||
</div>
|
||||
</div>
|
||||
@ -1,7 +0,0 @@
|
||||
<div class="container">
|
||||
<div class="row">
|
||||
<div class="col-md-12">
|
||||
<h1>Snapshot</h1>
|
||||
</div>
|
||||
</div>
|
||||
</div>
|
||||
Some files were not shown because too many files have changed in this diff Show More
Reference in New Issue
Block a user