├── .temp
    └── .gitkeep
├── LICENSE.md
├── bin
    ├── pest
    └── worker.php
├── composer.json
├── extension.neon
├── overrides
    ├── Event
    │   └── Value
    │   │   └── ThrowableBuilder.php
    ├── Logging
    │   └── JUnit
    │   │   └── JunitXmlLogger.php
    ├── Runner
    │   ├── Filter
    │   │   └── NameFilterIterator.php
    │   ├── ResultCache
    │   │   └── DefaultResultCache.php
    │   └── TestSuiteLoader.php
    └── TextUI
    │   ├── Command
    │       └── Commands
    │       │   └── WarmCodeCoverageCacheCommand.php
    │   ├── Output
    │       └── Default
    │       │   └── ProgressPrinter
    │       │       └── Subscriber
    │       │           └── TestSkippedSubscriber.php
    │   └── TestSuiteFilterProcessor.php
├── phpstan-baseline.neon
├── resources
    ├── base-phpunit.xml
    └── views
    │   ├── components
    │       ├── badge.php
    │       ├── new-line.php
    │       └── two-column-detail.php
    │   ├── usage.php
    │   └── version.php
├── src
    ├── ArchPresets
    │   ├── AbstractPreset.php
    │   ├── Custom.php
    │   ├── Laravel.php
    │   ├── Php.php
    │   ├── Relaxed.php
    │   ├── Security.php
    │   └── Strict.php
    ├── Bootstrappers
    │   ├── BootExcludeList.php
    │   ├── BootFiles.php
    │   ├── BootKernelDump.php
    │   ├── BootOverrides.php
    │   ├── BootSubscribers.php
    │   └── BootView.php
    ├── Collision
    │   └── Events.php
    ├── Concerns
    │   ├── Expectable.php
    │   ├── Extendable.php
    │   ├── Logging
    │   │   └── WritesToConsole.php
    │   ├── Pipeable.php
    │   ├── Retrievable.php
    │   └── Testable.php
    ├── Configuration.php
    ├── Configuration
    │   ├── Presets.php
    │   ├── Printer.php
    │   └── Project.php
    ├── Console
    │   ├── Help.php
    │   └── Thanks.php
    ├── Contracts
    │   ├── ArchPreset.php
    │   ├── Bootstrapper.php
    │   ├── HasPrintableTestCaseName.php
    │   ├── Panicable.php
    │   ├── Plugins
    │   │   ├── AddsOutput.php
    │   │   ├── Bootable.php
    │   │   ├── HandlesArguments.php
    │   │   ├── HandlesOriginalArguments.php
    │   │   └── Terminable.php
    │   ├── TestCaseFilter.php
    │   └── TestCaseMethodFilter.php
    ├── Evaluators
    │   └── Attributes.php
    ├── Exceptions
    │   ├── AfterAllAlreadyExist.php
    │   ├── AfterAllWithinDescribe.php
    │   ├── AfterBeforeTestFunction.php
    │   ├── BeforeAllAlreadyExist.php
    │   ├── BeforeAllWithinDescribe.php
    │   ├── DatasetAlreadyExists.php
    │   ├── DatasetArgumentsMismatch.php
    │   ├── DatasetDoesNotExist.php
    │   ├── DatasetMissing.php
    │   ├── ExpectationNotFound.php
    │   ├── FatalException.php
    │   ├── FileOrFolderNotFound.php
    │   ├── InvalidArgumentException.php
    │   ├── InvalidExpectation.php
    │   ├── InvalidExpectationValue.php
    │   ├── InvalidOption.php
    │   ├── InvalidPestCommand.php
    │   ├── MissingDependency.php
    │   ├── NoDirtyTestsFound.php
    │   ├── ShouldNotHappen.php
    │   ├── TestAlreadyExist.php
    │   ├── TestCaseAlreadyInUse.php
    │   ├── TestCaseClassOrTraitNotFound.php
    │   ├── TestClosureMustNotBeStatic.php
    │   └── TestDescriptionMissing.php
    ├── Expectation.php
    ├── Expectations
    │   ├── EachExpectation.php
    │   ├── HigherOrderExpectation.php
    │   └── OppositeExpectation.php
    ├── Factories
    │   ├── Attribute.php
    │   ├── Concerns
    │   │   └── HigherOrderable.php
    │   ├── Covers
    │   │   ├── CoversClass.php
    │   │   ├── CoversFunction.php
    │   │   └── CoversNothing.php
    │   ├── TestCaseFactory.php
    │   └── TestCaseMethodFactory.php
    ├── Functions.php
    ├── Kernel.php
    ├── KernelDump.php
    ├── Logging
    │   ├── Converter.php
    │   └── TeamCity
    │   │   ├── ServiceMessage.php
    │   │   ├── Subscriber
    │   │       ├── Subscriber.php
    │   │       ├── TestConsideredRiskySubscriber.php
    │   │       ├── TestErroredSubscriber.php
    │   │       ├── TestExecutionFinishedSubscriber.php
    │   │       ├── TestFailedSubscriber.php
    │   │       ├── TestFinishedSubscriber.php
    │   │       ├── TestPreparedSubscriber.php
    │   │       ├── TestSkippedSubscriber.php
    │   │       ├── TestSuiteFinishedSubscriber.php
    │   │       └── TestSuiteStartedSubscriber.php
    │   │   └── TeamCityLogger.php
    ├── Matchers
    │   └── Any.php
    ├── Mixins
    │   └── Expectation.php
    ├── Panic.php
    ├── PendingCalls
    │   ├── AfterEachCall.php
    │   ├── BeforeEachCall.php
    │   ├── Concerns
    │   │   └── Describable.php
    │   ├── DescribeCall.php
    │   ├── TestCall.php
    │   └── UsesCall.php
    ├── Pest.php
    ├── Plugin.php
    ├── Plugins
    │   ├── Actions
    │   │   ├── CallsAddsOutput.php
    │   │   ├── CallsBoot.php
    │   │   ├── CallsHandleArguments.php
    │   │   ├── CallsHandleOriginalArguments.php
    │   │   └── CallsTerminable.php
    │   ├── Bail.php
    │   ├── Cache.php
    │   ├── Concerns
    │   │   └── HandleArguments.php
    │   ├── Configuration.php
    │   ├── Coverage.php
    │   ├── Environment.php
    │   ├── Help.php
    │   ├── Init.php
    │   ├── Memory.php
    │   ├── Only.php
    │   ├── Parallel.php
    │   ├── Parallel
    │   │   ├── Contracts
    │   │   │   └── HandlersWorkerArguments.php
    │   │   ├── Handlers
    │   │   │   ├── Laravel.php
    │   │   │   ├── Parallel.php
    │   │   │   └── Pest.php
    │   │   ├── Paratest
    │   │   │   ├── CleanConsoleOutput.php
    │   │   │   ├── ResultPrinter.php
    │   │   │   └── WrapperRunner.php
    │   │   └── Support
    │   │   │   └── CompactPrinter.php
    │   ├── Printer.php
    │   ├── ProcessIsolation.php
    │   ├── Profile.php
    │   ├── Retry.php
    │   ├── Snapshot.php
    │   ├── Verbose.php
    │   └── Version.php
    ├── Preset.php
    ├── Repositories
    │   ├── AfterAllRepository.php
    │   ├── AfterEachRepository.php
    │   ├── BeforeAllRepository.php
    │   ├── BeforeEachRepository.php
    │   ├── DatasetsRepository.php
    │   ├── SnapshotRepository.php
    │   └── TestRepository.php
    ├── Result.php
    ├── Subscribers
    │   ├── EnsureConfigurationIsAvailable.php
    │   ├── EnsureIgnorableTestCasesAreIgnored.php
    │   ├── EnsureKernelDumpIsFlushed.php
    │   └── EnsureTeamCityEnabled.php
    ├── Support
    │   ├── Arr.php
    │   ├── Backtrace.php
    │   ├── ChainableClosure.php
    │   ├── Closure.php
    │   ├── Container.php
    │   ├── Coverage.php
    │   ├── DatasetInfo.php
    │   ├── ExceptionTrace.php
    │   ├── ExpectationPipeline.php
    │   ├── Exporter.php
    │   ├── HigherOrderCallables.php
    │   ├── HigherOrderMessage.php
    │   ├── HigherOrderMessageCollection.php
    │   ├── HigherOrderTapProxy.php
    │   ├── NullClosure.php
    │   ├── Reflection.php
    │   ├── StateGenerator.php
    │   ├── Str.php
    │   └── View.php
    ├── TestCaseFilters
    │   └── GitDirtyTestCaseFilter.php
    ├── TestCaseMethodFilters
    │   ├── AssigneeTestCaseFilter.php
    │   ├── IssueTestCaseFilter.php
    │   ├── NotesTestCaseFilter.php
    │   ├── PrTestCaseFilter.php
    │   └── TodoTestCaseFilter.php
    ├── TestCases
    │   └── IgnorableTestCase.php
    └── TestSuite.php
└── stubs
    ├── Browser.php
    ├── Dataset.php
    ├── Feature.php
    ├── Unit.php
    ├── init-laravel
        ├── Feature
        │   └── ExampleTest.php.stub
        ├── Pest.php.stub
        ├── TestCase.php.stub
        ├── Unit
        │   └── ExampleTest.php.stub
        └── phpunit.xml.stub
    └── init
        ├── Feature
            └── ExampleTest.php.stub
        ├── Pest.php.stub
        ├── TestCase.php.stub
        ├── Unit
            └── ExampleTest.php.stub
        └── phpunit.xml.stub


/.temp/.gitkeep:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/pestphp/pest/c6244a8712968dbac88eb998e7ff3b5caa556b0d/.temp/.gitkeep


--------------------------------------------------------------------------------
/LICENSE.md:
--------------------------------------------------------------------------------
 1 | The MIT License (MIT)
 2 | 
 3 | Copyright (c) Nuno Maduro <enunomaduro@gmail.com>
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in
13 | all copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
21 | THE SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/bin/worker.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | declare(strict_types=1);
  4 | 
  5 | use ParaTest\WrapperRunner\ApplicationForWrapperWorker;
  6 | use ParaTest\WrapperRunner\WrapperWorker;
  7 | use Pest\Kernel;
  8 | use Pest\Plugins\Actions\CallsHandleArguments;
  9 | use Pest\TestSuite;
 10 | use Symfony\Component\Console\Input\ArgvInput;
 11 | use Symfony\Component\Console\Output\ConsoleOutput;
 12 | use Symfony\Component\Console\Output\OutputInterface;
 13 | 
 14 | $bootPest = (static function (): void {
 15 |     $workerArgv = new ArgvInput;
 16 | 
 17 |     $rootPath = dirname(PHPUNIT_COMPOSER_INSTALL, 2);
 18 |     $testSuite = TestSuite::getInstance($rootPath, $workerArgv->getParameterOption(
 19 |         '--test-directory',
 20 |         'tests'
 21 |     ));
 22 | 
 23 |     $input = new ArgvInput;
 24 | 
 25 |     $output = new ConsoleOutput(OutputInterface::VERBOSITY_NORMAL, true);
 26 | 
 27 |     Kernel::boot($testSuite, $input, $output);
 28 | });
 29 | 
 30 | (static function () use ($bootPest): void {
 31 |     $getopt = getopt('', [
 32 |         'status-file:',
 33 |         'progress-file:',
 34 |         'unexpected-output-file:',
 35 |         'test-result-file:',
 36 |         'result-cache-file:',
 37 |         'teamcity-file:',
 38 |         'testdox-file:',
 39 |         'testdox-color',
 40 |         'testdox-columns:',
 41 |         'testdox-summary',
 42 |         'phpunit-argv:',
 43 |     ]);
 44 | 
 45 |     $composerAutoloadFiles = [
 46 |         dirname(__DIR__, 3).DIRECTORY_SEPARATOR.'autoload.php',
 47 |         dirname(__DIR__, 2).DIRECTORY_SEPARATOR.'vendor'.DIRECTORY_SEPARATOR.'autoload.php',
 48 |         dirname(__DIR__).DIRECTORY_SEPARATOR.'vendor'.DIRECTORY_SEPARATOR.'autoload.php',
 49 |     ];
 50 | 
 51 |     foreach ($composerAutoloadFiles as $file) {
 52 | 
 53 |         if (file_exists($file)) {
 54 |             require_once $file;
 55 |             define('PHPUNIT_COMPOSER_INSTALL', $file);
 56 | 
 57 |             break;
 58 |         }
 59 |     }
 60 | 
 61 |     assert(isset($getopt['status-file']) && is_string($getopt['status-file']));
 62 |     $statusFile = fopen($getopt['status-file'], 'wb');
 63 |     assert(is_resource($statusFile));
 64 | 
 65 |     assert(isset($getopt['progress-file']) && is_string($getopt['progress-file']));
 66 |     assert(isset($getopt['unexpected-output-file']) && is_string($getopt['unexpected-output-file']));
 67 |     assert(isset($getopt['test-result-file']) && is_string($getopt['test-result-file']));
 68 |     assert(! isset($getopt['result-cache-file']) || is_string($getopt['result-cache-file']));
 69 |     assert(! isset($getopt['teamcity-file']) || is_string($getopt['teamcity-file']));
 70 |     assert(! isset($getopt['testdox-file']) || is_string($getopt['testdox-file']));
 71 | 
 72 |     assert(isset($getopt['phpunit-argv']) && is_string($getopt['phpunit-argv']));
 73 |     $phpunitArgv = unserialize($getopt['phpunit-argv'], ['allowed_classes' => false]);
 74 |     assert(is_array($phpunitArgv));
 75 | 
 76 |     $bootPest();
 77 | 
 78 |     $phpunitArgv = CallsHandleArguments::execute($phpunitArgv);
 79 | 
 80 |     $application = new ApplicationForWrapperWorker(
 81 |         $phpunitArgv,
 82 |         $getopt['progress-file'],
 83 |         $getopt['unexpected-output-file'],
 84 |         $getopt['test-result-file'],
 85 |         $getopt['result-cache-file'] ?? null,
 86 |         $getopt['teamcity-file'] ?? null,
 87 |         $getopt['testdox-file'] ?? null,
 88 |         isset($getopt['testdox-color']),
 89 |         $getopt['testdox-columns'] ?? null,
 90 |     );
 91 | 
 92 |     while (true) {
 93 |         if (feof(STDIN)) {
 94 |             $application->end();
 95 |             exit;
 96 |         }
 97 | 
 98 |         $testPath = fgets(STDIN);
 99 |         if ($testPath === false || $testPath === WrapperWorker::COMMAND_EXIT) {
100 |             $application->end();
101 |             exit;
102 |         }
103 | 
104 |         // It must be a 1 byte string to ensure filesize() is equal to the number of tests executed
105 |         $exitCode = $application->runTest(realpath(trim($testPath)));
106 | 
107 |         fwrite($statusFile, (string) $exitCode);
108 |         fflush($statusFile);
109 |     }
110 | })();
111 | 


--------------------------------------------------------------------------------
/extension.neon:
--------------------------------------------------------------------------------
1 | parameters:
2 |     universalObjectCratesClasses:
3 |         - Pest\Support\HigherOrderTapProxy
4 |         - Pest\Expectation
5 | 


--------------------------------------------------------------------------------
/overrides/Event/Value/ThrowableBuilder.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /*
 4 |  * BSD 3-Clause License
 5 |  *
 6 |  * Copyright (c) 2001-2023, Sebastian Bergmann
 7 |  * All rights reserved.
 8 |  *
 9 |  * Redistribution and use in source and binary forms, with or without
10 |  * modification, are permitted provided that the following conditions are met:
11 |  *
12 |  * 1. Redistributions of source code must retain the above copyright notice, this
13 |  *    list of conditions and the following disclaimer.
14 |  *
15 |  * 2. Redistributions in binary form must reproduce the above copyright notice,
16 |  *    this list of conditions and the following disclaimer in the documentation
17 |  *    and/or other materials provided with the distribution.
18 |  *
19 |  * 3. Neither the name of the copyright holder nor the names of its
20 |  *    contributors may be used to endorse or promote products derived from
21 |  *    this software without specific prior written permission.
22 |  *
23 |  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
24 |  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
25 |  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
26 |  * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
27 |  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
28 |  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
29 |  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
30 |  * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
31 |  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
32 |  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
33 |  */
34 | 
35 | declare(strict_types=1);
36 | 
37 | /*
38 |  * This file is part of PHPUnit.
39 |  *
40 |  * (c) Sebastian Bergmann <sebastian@phpunit.de>
41 |  *
42 |  * For the full copyright and license information, please view the LICENSE
43 |  * file that was distributed with this source code.
44 |  */
45 | 
46 | namespace PHPUnit\Event\Code;
47 | 
48 | use NunoMaduro\Collision\Contracts\RenderableOnCollisionEditor;
49 | use PHPUnit\Event\NoPreviousThrowableException;
50 | use PHPUnit\Framework\Exception;
51 | use PHPUnit\Util\Filter;
52 | use PHPUnit\Util\ThrowableToStringMapper;
53 | 
54 | /**
55 |  * @internal This class is not covered by the backward compatibility promise for PHPUnit
56 |  */
57 | final readonly class ThrowableBuilder
58 | {
59 |     /**
60 |      * @throws Exception
61 |      * @throws NoPreviousThrowableException
62 |      */
63 |     public static function from(\Throwable $t): Throwable
64 |     {
65 |         $previous = $t->getPrevious();
66 | 
67 |         if ($previous !== null) {
68 |             $previous = self::from($previous);
69 |         }
70 | 
71 |         $trace = Filter::stackTraceFromThrowableAsString($t);
72 | 
73 |         if ($t instanceof RenderableOnCollisionEditor && $frame = $t->toCollisionEditor()) {
74 |             $file = $frame->getFile();
75 |             $line = $frame->getLine();
76 | 
77 |             $trace = "$file:$line\n$trace";
78 |         }
79 | 
80 |         return new Throwable(
81 |             $t::class,
82 |             $t->getMessage(),
83 |             ThrowableToStringMapper::map($t),
84 |             $trace,
85 |             $previous
86 |         );
87 |     }
88 | }
89 | 


--------------------------------------------------------------------------------
/overrides/TextUI/Command/Commands/WarmCodeCoverageCacheCommand.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | /*
  4 |  * BSD 3-Clause License
  5 |  *
  6 |  * Copyright (c) 2001-2023, Sebastian Bergmann
  7 |  * All rights reserved.
  8 |  *
  9 |  * Redistribution and use in source and binary forms, with or without
 10 |  * modification, are permitted provided that the following conditions are met:
 11 |  *
 12 |  * 1. Redistributions of source code must retain the above copyright notice, this
 13 |  *    list of conditions and the following disclaimer.
 14 |  *
 15 |  * 2. Redistributions in binary form must reproduce the above copyright notice,
 16 |  *    this list of conditions and the following disclaimer in the documentation
 17 |  *    and/or other materials provided with the distribution.
 18 |  *
 19 |  * 3. Neither the name of the copyright holder nor the names of its
 20 |  *    contributors may be used to endorse or promote products derived from
 21 |  *    this software without specific prior written permission.
 22 |  *
 23 |  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 24 |  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 25 |  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 26 |  * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
 27 |  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 28 |  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
 29 |  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
 30 |  * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 31 |  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 32 |  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 33 |  */
 34 | 
 35 | declare(strict_types=1);
 36 | 
 37 | /*
 38 |  * This file is part of PHPUnit.
 39 |  *
 40 |  * (c) Sebastian Bergmann <sebastian@phpunit.de>
 41 |  *
 42 |  * For the full copyright and license information, please view the LICENSE
 43 |  * file that was distributed with this source code.
 44 |  */
 45 | 
 46 | namespace PHPUnit\TextUI\Command;
 47 | 
 48 | use const PHP_EOL;
 49 | 
 50 | use PHPUnit\TextUI\Configuration\CodeCoverageFilterRegistry;
 51 | use PHPUnit\TextUI\Configuration\Configuration;
 52 | use PHPUnit\TextUI\Configuration\NoCoverageCacheDirectoryException;
 53 | use SebastianBergmann\CodeCoverage\StaticAnalysis\CacheWarmer;
 54 | use SebastianBergmann\Timer\NoActiveTimerException;
 55 | use SebastianBergmann\Timer\Timer;
 56 | 
 57 | /**
 58 |  * @internal This class is not covered by the backward compatibility promise for PHPUnit
 59 |  */
 60 | final readonly class WarmCodeCoverageCacheCommand implements Command
 61 | {
 62 |     private Configuration $configuration;
 63 | 
 64 |     private CodeCoverageFilterRegistry $codeCoverageFilterRegistry;
 65 | 
 66 |     public function __construct(Configuration $configuration, CodeCoverageFilterRegistry $codeCoverageFilterRegistry)
 67 |     {
 68 |         $this->configuration = $configuration;
 69 |         $this->codeCoverageFilterRegistry = $codeCoverageFilterRegistry;
 70 |     }
 71 | 
 72 |     /**
 73 |      * @throws NoActiveTimerException
 74 |      * @throws NoCoverageCacheDirectoryException
 75 |      */
 76 |     public function execute(): Result
 77 |     {
 78 |         if (! $this->configuration->hasCoverageCacheDirectory()) {
 79 |             return Result::from(
 80 |                 'Cache for static analysis has not been configured'.PHP_EOL,
 81 |                 Result::FAILURE,
 82 |             );
 83 |         }
 84 | 
 85 |         $this->codeCoverageFilterRegistry->init($this->configuration, true);
 86 | 
 87 |         if (! $this->codeCoverageFilterRegistry->configured()) {
 88 |             return Result::from(
 89 |                 'Filter for code coverage has not been configured'.PHP_EOL,
 90 |                 Result::FAILURE,
 91 |             );
 92 |         }
 93 | 
 94 |         $timer = new Timer;
 95 |         $timer->start();
 96 | 
 97 |         (new CacheWarmer)->warmCache(
 98 |             $this->configuration->coverageCacheDirectory(),
 99 |             ! $this->configuration->disableCodeCoverageIgnore(),
100 |             $this->configuration->ignoreDeprecatedCodeUnitsFromCodeCoverage(),
101 |             $this->codeCoverageFilterRegistry->get(),
102 |         );
103 | 
104 |         return Result::from();
105 |     }
106 | }
107 | 


--------------------------------------------------------------------------------
/overrides/TextUI/Output/Default/ProgressPrinter/Subscriber/TestSkippedSubscriber.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /*
 4 |  * BSD 3-Clause License
 5 |  *
 6 |  * Copyright (c) 2001-2023, Sebastian Bergmann
 7 |  * All rights reserved.
 8 |  *
 9 |  * Redistribution and use in source and binary forms, with or without
10 |  * modification, are permitted provided that the following conditions are met:
11 |  *
12 |  * 1. Redistributions of source code must retain the above copyright notice, this
13 |  *    list of conditions and the following disclaimer.
14 |  *
15 |  * 2. Redistributions in binary form must reproduce the above copyright notice,
16 |  *    this list of conditions and the following disclaimer in the documentation
17 |  *    and/or other materials provided with the distribution.
18 |  *
19 |  * 3. Neither the name of the copyright holder nor the names of its
20 |  *    contributors may be used to endorse or promote products derived from
21 |  *    this software without specific prior written permission.
22 |  *
23 |  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
24 |  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
25 |  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
26 |  * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
27 |  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
28 |  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
29 |  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
30 |  * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
31 |  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
32 |  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
33 |  */
34 | 
35 | declare(strict_types=1);
36 | 
37 | /*
38 |  * This file is part of PHPUnit.
39 |  *
40 |  * (c) Sebastian Bergmann <sebastian@phpunit.de>
41 |  *
42 |  * For the full copyright and license information, please view the LICENSE
43 |  * file that was distributed with this source code.
44 |  */
45 | 
46 | namespace Pest\Logging\TeamCity\Subscriber;
47 | 
48 | use PHPUnit\Event\Test\Skipped;
49 | use PHPUnit\Event\Test\SkippedSubscriber;
50 | use ReflectionClass;
51 | 
52 | /**
53 |  * @internal This class is not covered by the backward compatibility promise for PHPUnit
54 |  */
55 | final class TestSkippedSubscriber extends Subscriber implements SkippedSubscriber
56 | {
57 |     public function notify(Skipped $event): void
58 |     {
59 |         if (str_contains($event->message(), '__TODO__')) {
60 |             $this->printTodoItem();
61 |         }
62 | 
63 |         $this->logger()->testSkipped($event);
64 |     }
65 | 
66 |     /**
67 |      * Prints a "T" to the standard PHPUnit output to indicate a todo item.
68 |      */
69 |     private function printTodoItem(): void
70 |     {
71 |         $mirror = new ReflectionClass($this->printer());
72 |         $printerMirror = $mirror->getMethod('printProgress');
73 |         $printerMirror->invoke($this->printer(), 'T');
74 |     }
75 | }
76 | 


--------------------------------------------------------------------------------
/resources/base-phpunit.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="UTF-8"?>
 2 | <phpunit xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 3 |          xsi:noNamespaceSchemaLocation="vendor/phpunit/phpunit/phpunit.xsd"
 4 |          bootstrap="vendor/autoload.php"
 5 |          colors="true"
 6 | >
 7 |     <testsuites>
 8 |         <testsuite name="Default">
 9 |             <directory>tests/</directory>
10 |         </testsuite>
11 |     </testsuites>
12 |     <source>
13 |         <include>
14 |             <directory>app</directory>
15 |             <directory>src</directory>
16 |         </include>
17 |     </source>
18 |     <php>
19 |         <env name="APP_ENV" value="testing"/>
20 |         <env name="APP_MAINTENANCE_DRIVER" value="file"/>
21 |         <env name="BCRYPT_ROUNDS" value="4"/>
22 |         <env name="CACHE_STORE" value="array"/>
23 |         <!-- <env name="DB_CONNECTION" value="sqlite"/> -->
24 |         <!-- <env name="DB_DATABASE" value=":memory:"/> -->
25 |         <env name="MAIL_MAILER" value="array"/>
26 |         <env name="PULSE_ENABLED" value="false"/>
27 |         <env name="QUEUE_CONNECTION" value="sync"/>
28 |         <env name="SESSION_DRIVER" value="array"/>
29 |         <env name="TELESCOPE_ENABLED" value="false"/>
30 |     </php>
31 | </phpunit>
32 | 


--------------------------------------------------------------------------------
/resources/views/components/badge.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /** @var string $type */
 4 | /** @var string $content */
 5 | [$bgBadgeColor, $bgBadgeText] = match ($type) {
 6 |     'INFO' => ['blue', 'INFO'],
 7 |     'ERROR' => ['red', 'ERROR'],
 8 | };
 9 | 
10 | ?>
11 | 
12 | <div class="my-1">
13 |     <span class="ml-2 px-1 bg-<?php echo $bgBadgeColor ?> font-bold"><?php echo htmlspecialchars($bgBadgeText) ?></span>
14 |     <span class="ml-1">
15 |         <?php echo htmlspecialchars($content) ?>
16 |     </span>
17 | </div>
18 | 


--------------------------------------------------------------------------------
/resources/views/components/new-line.php:
--------------------------------------------------------------------------------
1 | <div></div>
2 | 


--------------------------------------------------------------------------------
/resources/views/components/two-column-detail.php:
--------------------------------------------------------------------------------
 1 | <div class="flex mx-2 max-w-150">
 2 |     <span>
 3 |         <?php echo htmlspecialchars($left) ?>
 4 |     </span>
 5 |     <span class="flex-1 content-repeat-[.] text-gray ml-1"></span>
 6 |     <?php if ($right !== '') { ?>
 7 |         <span class="ml-1 text-gray">
 8 |             <?php echo htmlspecialchars($right) ?>
 9 |         </span>
10 |     <?php } ?>
11 | </div>
12 | 
13 | 


--------------------------------------------------------------------------------
/resources/views/usage.php:
--------------------------------------------------------------------------------
1 | <div class="mx-2">
2 |     <span class="text-yellow font-bold">USAGE:</span><span class="ml-1">pest</span><span class="ml-1 text-gray"><?php echo htmlspecialchars('<file>') ?> [options]</span>
3 | </div>
4 | 
5 | 


--------------------------------------------------------------------------------
/resources/views/version.php:
--------------------------------------------------------------------------------
1 | <div class="my-1 mx-2">
2 |     <span>Pest Testing Framework</span><span class="ml-1 text-blue font-bold"><?php echo htmlspecialchars($version) ?></span><span>.</span>
3 | </div>
4 | 


--------------------------------------------------------------------------------
/src/ArchPresets/AbstractPreset.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Pest\ArchPresets;
 6 | 
 7 | use Pest\Arch\Contracts\ArchExpectation;
 8 | use Pest\Expectation;
 9 | 
10 | /**
11 |  * @internal
12 |  */
13 | abstract class AbstractPreset // @pest-arch-ignore-line
14 | {
15 |     /**
16 |      * The expectations.
17 |      *
18 |      * @var array<int, Expectation<mixed>|ArchExpectation>
19 |      */
20 |     protected array $expectations = [];
21 | 
22 |     /**
23 |      * Creates a new preset instance.
24 |      *
25 |      * @param  array<int, string>  $userNamespaces
26 |      */
27 |     public function __construct(
28 |         private readonly array $userNamespaces,
29 |     ) {
30 |         //
31 |     }
32 | 
33 |     /**
34 |      * Executes the arch preset.
35 |      *
36 |      * @internal
37 |      */
38 |     abstract public function execute(): void;
39 | 
40 |     /**
41 |      * Ignores the given "targets" or "dependencies".
42 |      *
43 |      * @param  array<int, string>|string  $targetsOrDependencies
44 |      */
45 |     final public function ignoring(array|string $targetsOrDependencies): void
46 |     {
47 |         $this->expectations = array_map(
48 |             fn (ArchExpectation|Expectation $expectation): Expectation|ArchExpectation => $expectation instanceof ArchExpectation ? $expectation->ignoring($targetsOrDependencies) : $expectation,
49 |             $this->expectations,
50 |         );
51 |     }
52 | 
53 |     /**
54 |      * Runs the given callback for each namespace.
55 |      *
56 |      * @param  callable(Expectation<string|null>): ArchExpectation  ...$callbacks
57 |      */
58 |     final public function eachUserNamespace(callable ...$callbacks): void
59 |     {
60 |         foreach ($this->userNamespaces as $namespace) {
61 |             foreach ($callbacks as $callback) {
62 |                 $this->expectations[] = $callback(expect($namespace));
63 |             }
64 |         }
65 |     }
66 | 
67 |     /**
68 |      * Flushes the expectations.
69 |      */
70 |     final public function flush(): void
71 |     {
72 |         $this->expectations = [];
73 |     }
74 | }
75 | 


--------------------------------------------------------------------------------
/src/ArchPresets/Custom.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Pest\ArchPresets;
 6 | 
 7 | use Closure;
 8 | use Pest\Arch\Contracts\ArchExpectation;
 9 | use Pest\Expectation;
10 | 
11 | /**
12 |  * @internal
13 |  */
14 | final class Custom extends AbstractPreset
15 | {
16 |     /**
17 |      * Creates a new preset instance.
18 |      *
19 |      * @param  array<int, string>  $userNamespaces
20 |      * @param  Closure(array<int, string>): array<Expectation<mixed>|ArchExpectation>  $execute
21 |      */
22 |     public function __construct(
23 |         private readonly array $userNamespaces,
24 |         private readonly string $name,
25 |         private readonly Closure $execute,
26 |     ) {
27 |         parent::__construct($userNamespaces);
28 |     }
29 | 
30 |     /**
31 |      * Returns the name of the preset.
32 |      */
33 |     public function name(): string
34 |     {
35 |         return $this->name;
36 |     }
37 | 
38 |     /**
39 |      * Executes the arch preset.
40 |      */
41 |     public function execute(): void
42 |     {
43 |         $this->expectations = ($this->execute)($this->userNamespaces);
44 |     }
45 | }
46 | 


--------------------------------------------------------------------------------
/src/ArchPresets/Php.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Pest\ArchPresets;
 6 | 
 7 | /**
 8 |  * @internal
 9 |  */
10 | final class Php extends AbstractPreset
11 | {
12 |     /**
13 |      * Executes the arch preset.
14 |      */
15 |     public function execute(): void
16 |     {
17 |         $this->expectations[] = expect([
18 |             'debug_zval_dump',
19 |             'debug_backtrace',
20 |             'debug_print_backtrace',
21 |             'dump',
22 |             'ray',
23 |             'ds',
24 |             'die',
25 |             'goto',
26 |             'global',
27 |             'var_dump',
28 |             'phpinfo',
29 |             'echo',
30 |             'ereg',
31 |             'eregi',
32 |             'mysql_connect',
33 |             'mysql_pconnect',
34 |             'mysql_query',
35 |             'mysql_select_db',
36 |             'mysql_fetch_array',
37 |             'mysql_fetch_assoc',
38 |             'mysql_fetch_object',
39 |             'mysql_fetch_row',
40 |             'mysql_num_rows',
41 |             'mysql_affected_rows',
42 |             'mysql_free_result',
43 |             'mysql_insert_id',
44 |             'mysql_error',
45 |             'mysql_real_escape_string',
46 |             'print',
47 |             'print_r',
48 |             'var_export',
49 |             'xdebug_break',
50 |             'xdebug_call_class',
51 |             'xdebug_call_file',
52 |             'xdebug_call_int',
53 |             'xdebug_call_line',
54 |             'xdebug_code_coverage_started',
55 |             'xdebug_connect_to_client',
56 |             'xdebug_debug_zval',
57 |             'xdebug_debug_zval_stdout',
58 |             'xdebug_dump_superglobals',
59 |             'xdebug_get_code_coverage',
60 |             'xdebug_get_collected_errors',
61 |             'xdebug_get_function_count',
62 |             'xdebug_get_function_stack',
63 |             'xdebug_get_gc_run_count',
64 |             'xdebug_get_gc_total_collected_roots',
65 |             'xdebug_get_gcstats_filename',
66 |             'xdebug_get_headers',
67 |             'xdebug_get_monitored_functions',
68 |             'xdebug_get_profiler_filename',
69 |             'xdebug_get_stack_depth',
70 |             'xdebug_get_tracefile_name',
71 |             'xdebug_info',
72 |             'xdebug_is_debugger_active',
73 |             'xdebug_memory_usage',
74 |             'xdebug_notify',
75 |             'xdebug_peak_memory_usage',
76 |             'xdebug_print_function_stack',
77 |             'xdebug_set_filter',
78 |             'xdebug_start_code_coverage',
79 |             'xdebug_start_error_collection',
80 |             'xdebug_start_function_monitor',
81 |             'xdebug_start_gcstats',
82 |             'xdebug_start_trace',
83 |             'xdebug_stop_code_coverage',
84 |             'xdebug_stop_error_collection',
85 |             'xdebug_stop_function_monitor',
86 |             'xdebug_stop_gcstats',
87 |             'xdebug_stop_trace',
88 |             'xdebug_time_index',
89 |             'xdebug_var_dump',
90 |             'trap',
91 |         ])->not->toBeUsed();
92 |     }
93 | }
94 | 


--------------------------------------------------------------------------------
/src/ArchPresets/Relaxed.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Pest\ArchPresets;
 6 | 
 7 | use Pest\Arch\Contracts\ArchExpectation;
 8 | use Pest\Expectation;
 9 | 
10 | /**
11 |  * @internal
12 |  */
13 | final class Relaxed extends AbstractPreset
14 | {
15 |     /**
16 |      * Executes the arch preset.
17 |      */
18 |     public function execute(): void
19 |     {
20 |         $this->eachUserNamespace(
21 |             fn (Expectation $namespace): ArchExpectation => $namespace->not->toUseStrictTypes(),
22 |             fn (Expectation $namespace): ArchExpectation => $namespace->classes()->not->toBeFinal(),
23 |             fn (Expectation $namespace): ArchExpectation => $namespace->classes()->not->toHavePrivateMethods(),
24 |         );
25 |     }
26 | }
27 | 


--------------------------------------------------------------------------------
/src/ArchPresets/Security.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Pest\ArchPresets;
 6 | 
 7 | /**
 8 |  * @internal
 9 |  */
10 | final class Security extends AbstractPreset
11 | {
12 |     /**
13 |      * Executes the arch preset.
14 |      */
15 |     public function execute(): void
16 |     {
17 |         $this->expectations[] = expect([
18 |             'md5',
19 |             'sha1',
20 |             'uniqid',
21 |             'rand',
22 |             'mt_rand',
23 |             'tempnam',
24 |             'str_shuffle',
25 |             'shuffle',
26 |             'array_rand',
27 |             'eval',
28 |             'exec',
29 |             'shell_exec',
30 |             'system',
31 |             'passthru',
32 |             'create_function',
33 |             'unserialize',
34 |             'extract',
35 |             'parse_str',
36 |             'mb_parse_str',
37 |             'dl',
38 |             'assert',
39 |         ])->not->toBeUsed();
40 |     }
41 | }
42 | 


--------------------------------------------------------------------------------
/src/ArchPresets/Strict.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Pest\ArchPresets;
 6 | 
 7 | use Pest\Arch\Contracts\ArchExpectation;
 8 | use Pest\Expectation;
 9 | 
10 | /**
11 |  * @internal
12 |  */
13 | final class Strict extends AbstractPreset
14 | {
15 |     /**
16 |      * Executes the arch preset.
17 |      */
18 |     public function execute(): void
19 |     {
20 |         $this->eachUserNamespace(
21 |             fn (Expectation $namespace): ArchExpectation => $namespace->classes()->not->toHaveProtectedMethods(),
22 |             fn (Expectation $namespace): ArchExpectation => $namespace->classes()->not->toBeAbstract(),
23 |             fn (Expectation $namespace): ArchExpectation => $namespace->toUseStrictTypes(),
24 |             fn (Expectation $namespace): ArchExpectation => $namespace->toUseStrictEquality(),
25 |             fn (Expectation $namespace): ArchExpectation => $namespace->classes()->toBeFinal(),
26 |         );
27 | 
28 |         $this->expectations[] = expect([
29 |             'sleep',
30 |             'usleep',
31 |         ])->not->toBeUsed();
32 |     }
33 | }
34 | 


--------------------------------------------------------------------------------
/src/Bootstrappers/BootExcludeList.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Pest\Bootstrappers;
 6 | 
 7 | use Pest\Contracts\Bootstrapper;
 8 | use PHPUnit\Util\ExcludeList;
 9 | 
10 | /**
11 |  * @internal
12 |  */
13 | final class BootExcludeList implements Bootstrapper
14 | {
15 |     /**
16 |      * The directories to exclude.
17 |      *
18 |      * @var array<int, non-empty-string>
19 |      */
20 |     private const EXCLUDE_LIST = [
21 |         'bin',
22 |         'overrides',
23 |         'resources',
24 |         'src',
25 |         'stubs',
26 |     ];
27 | 
28 |     /**
29 |      * Boots the "exclude list" for PHPUnit to ignore Pest files.
30 |      */
31 |     public function boot(): void
32 |     {
33 |         $baseDirectory = dirname(__DIR__, 2);
34 | 
35 |         foreach (self::EXCLUDE_LIST as $directory) {
36 |             ExcludeList::addDirectory($baseDirectory.DIRECTORY_SEPARATOR.$directory);
37 |         }
38 |     }
39 | }
40 | 


--------------------------------------------------------------------------------
/src/Bootstrappers/BootFiles.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Pest\Bootstrappers;
 6 | 
 7 | use Pest\Contracts\Bootstrapper;
 8 | use Pest\Support\DatasetInfo;
 9 | use Pest\Support\Str;
10 | use Pest\TestSuite;
11 | use RecursiveDirectoryIterator;
12 | use RecursiveIteratorIterator;
13 | use SebastianBergmann\FileIterator\Facade as PhpUnitFileIterator;
14 | 
15 | use function Pest\testDirectory;
16 | 
17 | /**
18 |  * @internal
19 |  */
20 | final class BootFiles implements Bootstrapper
21 | {
22 |     /**
23 |      * The structure of the tests directory.
24 |      *
25 |      * @var array<int, string>
26 |      */
27 |     private const STRUCTURE = [
28 |         'Expectations',
29 |         'Expectations.php',
30 |         'Helpers',
31 |         'Helpers.php',
32 |         'Pest.php',
33 |     ];
34 | 
35 |     /**
36 |      * Boots the structure of the tests directory.
37 |      */
38 |     public function boot(): void
39 |     {
40 |         $rootPath = TestSuite::getInstance()->rootPath;
41 |         $testsPath = $rootPath.DIRECTORY_SEPARATOR.testDirectory();
42 | 
43 |         foreach (self::STRUCTURE as $filename) {
44 |             $filename = sprintf('%s%s%s', $testsPath, DIRECTORY_SEPARATOR, $filename);
45 | 
46 |             if (! file_exists($filename)) {
47 |                 continue;
48 |             }
49 | 
50 |             if (is_dir($filename)) {
51 |                 $directory = new RecursiveDirectoryIterator($filename);
52 |                 $iterator = new RecursiveIteratorIterator($directory);
53 |                 /** @var \DirectoryIterator $file */
54 |                 foreach ($iterator as $file) {
55 |                     $this->load($file->__toString());
56 |                 }
57 |             } else {
58 |                 $this->load($filename);
59 |             }
60 |         }
61 | 
62 |         $this->bootDatasets($testsPath);
63 |     }
64 | 
65 |     /**
66 |      * Loads, if possible, the given file.
67 |      */
68 |     private function load(string $filename): void
69 |     {
70 |         if (! Str::endsWith($filename, '.php')) {
71 |             return;
72 |         }
73 |         if (! file_exists($filename)) {
74 |             return;
75 |         }
76 |         include_once $filename;
77 |     }
78 | 
79 |     private function bootDatasets(string $testsPath): void
80 |     {
81 |         assert(strlen($testsPath) > 0);
82 | 
83 |         $files = (new PhpUnitFileIterator)->getFilesAsArray($testsPath, '.php');
84 | 
85 |         foreach ($files as $file) {
86 |             if (DatasetInfo::isADatasetsFile($file) || DatasetInfo::isInsideADatasetsDirectory($file)) {
87 |                 $this->load($file);
88 |             }
89 |         }
90 |     }
91 | }
92 | 


--------------------------------------------------------------------------------
/src/Bootstrappers/BootKernelDump.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Pest\Bootstrappers;
 6 | 
 7 | use Pest\Contracts\Bootstrapper;
 8 | use Pest\KernelDump;
 9 | use Pest\Support\Container;
10 | use Symfony\Component\Console\Output\OutputInterface;
11 | 
12 | /**
13 |  * @internal
14 |  */
15 | final readonly class BootKernelDump implements Bootstrapper
16 | {
17 |     /**
18 |      * Creates a new Boot Kernel Dump instance.
19 |      */
20 |     public function __construct(
21 |         private OutputInterface $output,
22 |     ) {
23 |         // ...
24 |     }
25 | 
26 |     /**
27 |      * Boots the kernel dump.
28 |      */
29 |     public function boot(): void
30 |     {
31 |         Container::getInstance()->add(KernelDump::class, $kernelDump = new KernelDump(
32 |             $this->output,
33 |         ));
34 | 
35 |         $kernelDump->enable();
36 |     }
37 | }
38 | 


--------------------------------------------------------------------------------
/src/Bootstrappers/BootOverrides.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Pest\Bootstrappers;
 6 | 
 7 | use Pest\Contracts\Bootstrapper;
 8 | use Pest\Exceptions\ShouldNotHappen;
 9 | 
10 | /**
11 |  * @internal
12 |  */
13 | final class BootOverrides implements Bootstrapper
14 | {
15 |     /**
16 |      * The list of files to be overridden.
17 |      *
18 |      * @var array<string, string>
19 |      */
20 |     public const FILES = [
21 |         '53c246e5f416a39817ac81124cdd64ea8403038d01d7a202e1ffa486fbdf3fa7' => 'Runner/Filter/NameFilterIterator.php',
22 |         '77ffb7647b583bd82e37962c6fbdc4b04d3344d8a2c1ed103e625ed1ff7cb5c2' => 'Runner/ResultCache/DefaultResultCache.php',
23 |         'd0e81317889ad88c707db4b08a94cadee4c9010d05ff0a759f04e71af5efed89' => 'Runner/TestSuiteLoader.php',
24 |         '3bb609b0d3bf6dee8df8d6cd62a3c8ece823c4bb941eaaae39e3cb267171b9d2' => 'TextUI/Command/Commands/WarmCodeCoverageCacheCommand.php',
25 |         '8abdad6413329c6fe0d7d44a8b9926e390af32c0b3123f3720bb9c5bbc6fbb7e' => 'TextUI/Output/Default/ProgressPrinter/Subscriber/TestSkippedSubscriber.php',
26 |         'b4250fc3ffad5954624cb5e682fd940b874e8d3422fa1ee298bd7225e1aa5fc2' => 'TextUI/TestSuiteFilterProcessor.php',
27 |         '8cfcb4999af79463eca51a42058e502ea4ddc776cba5677bf2f8eb6093e21a5c' => 'Event/Value/ThrowableBuilder.php',
28 |         '86cd9bcaa53cdd59c5b13e58f30064a015c549501e7629d93b96893d4dee1eb1' => 'Logging/JUnit/JunitXmlLogger.php',
29 |     ];
30 | 
31 |     /**
32 |      * Boots the list of files to be overridden.
33 |      */
34 |     public function boot(): void
35 |     {
36 |         foreach (self::FILES as $file) {
37 |             $file = __DIR__."/../../overrides/$file";
38 | 
39 |             if (! file_exists($file)) {
40 |                 throw ShouldNotHappen::fromMessage(sprintf('File [%s] does not exist.', $file));
41 |             }
42 | 
43 |             require_once $file;
44 |         }
45 |     }
46 | }
47 | 


--------------------------------------------------------------------------------
/src/Bootstrappers/BootSubscribers.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Pest\Bootstrappers;
 6 | 
 7 | use Pest\Contracts\Bootstrapper;
 8 | use Pest\Subscribers;
 9 | use Pest\Support\Container;
10 | use PHPUnit\Event;
11 | use PHPUnit\Event\Subscriber;
12 | 
13 | /**
14 |  * @internal
15 |  */
16 | final readonly class BootSubscribers implements Bootstrapper
17 | {
18 |     /**
19 |      * The list of Subscribers.
20 |      *
21 |      * @var array<int, class-string<Subscriber>>
22 |      */
23 |     private const SUBSCRIBERS = [
24 |         Subscribers\EnsureConfigurationIsAvailable::class,
25 |         Subscribers\EnsureIgnorableTestCasesAreIgnored::class,
26 |         Subscribers\EnsureKernelDumpIsFlushed::class,
27 |         Subscribers\EnsureTeamCityEnabled::class,
28 |     ];
29 | 
30 |     /**
31 |      * Creates a new instance of the Boot Subscribers.
32 |      */
33 |     public function __construct(
34 |         private Container $container,
35 |     ) {}
36 | 
37 |     /**
38 |      * Boots the list of Subscribers.
39 |      */
40 |     public function boot(): void
41 |     {
42 |         foreach (self::SUBSCRIBERS as $subscriber) {
43 |             $instance = $this->container->get($subscriber);
44 | 
45 |             assert($instance instanceof Subscriber);
46 | 
47 |             Event\Facade::instance()->registerSubscriber($instance);
48 |         }
49 |     }
50 | }
51 | 


--------------------------------------------------------------------------------
/src/Bootstrappers/BootView.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Pest\Bootstrappers;
 6 | 
 7 | use Pest\Contracts\Bootstrapper;
 8 | use Pest\Support\View;
 9 | use Symfony\Component\Console\Output\OutputInterface;
10 | 
11 | /**
12 |  * @internal
13 |  */
14 | final readonly class BootView implements Bootstrapper
15 | {
16 |     /**
17 |      * Creates a new instance of the Boot View.
18 |      */
19 |     public function __construct(
20 |         private OutputInterface $output
21 |     ) {
22 |         // ..
23 |     }
24 | 
25 |     /**
26 |      * Boots the view renderer.
27 |      */
28 |     public function boot(): void
29 |     {
30 |         View::renderUsing($this->output);
31 |     }
32 | }
33 | 


--------------------------------------------------------------------------------
/src/Collision/Events.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | declare(strict_types=1);
  4 | 
  5 | namespace Pest\Collision;
  6 | 
  7 | use NunoMaduro\Collision\Adapters\Phpunit\TestResult;
  8 | use Pest\Configuration\Project;
  9 | use Symfony\Component\Console\Output\OutputInterface;
 10 | 
 11 | use function Termwind\render;
 12 | use function Termwind\renderUsing;
 13 | 
 14 | /**
 15 |  * @internal
 16 |  */
 17 | final class Events
 18 | {
 19 |     /**
 20 |      * Sets the output.
 21 |      */
 22 |     private static ?OutputInterface $output = null;
 23 | 
 24 |     /**
 25 |      * Sets the output.
 26 |      */
 27 |     public static function setOutput(OutputInterface $output): void
 28 |     {
 29 |         self::$output = $output;
 30 |     }
 31 | 
 32 |     /**
 33 |      * Fires before the test method description is printed.
 34 |      */
 35 |     public static function beforeTestMethodDescription(TestResult $result, string $description): string
 36 |     {
 37 |         if (($context = $result->context) === []) {
 38 |             return $description;
 39 |         }
 40 | 
 41 |         renderUsing(self::$output);
 42 | 
 43 |         [
 44 |             'assignees' => $assignees,
 45 |             'issues' => $issues,
 46 |             'prs' => $prs,
 47 |         ] = $context;
 48 | 
 49 |         if (($link = Project::getInstance()->issues) !== '') {
 50 |             $issuesDescription = array_map(fn (int $issue): string => sprintf('<a href="%s">#%s</a>', sprintf($link, $issue), $issue), $issues);
 51 |         }
 52 | 
 53 |         if (($link = Project::getInstance()->prs) !== '') {
 54 |             $prsDescription = array_map(fn (int $pr): string => sprintf('<a href="%s">#%s</a>', sprintf($link, $pr), $pr), $prs);
 55 |         }
 56 | 
 57 |         if (($link = Project::getInstance()->assignees) !== '' && count($assignees) > 0) {
 58 |             $assigneesDescription = array_map(fn (string $assignee): string => sprintf(
 59 |                 '<a href="%s">@%s</a>',
 60 |                 sprintf($link, $assignee),
 61 |                 $assignee,
 62 |             ), $assignees);
 63 |         }
 64 | 
 65 |         if (count($assignees) > 0 || count($issues) > 0 || count($prs) > 0) {
 66 |             $description .= ' '.implode(', ', array_merge(
 67 |                 $issuesDescription ?? [],
 68 |                 $prsDescription ?? [],
 69 |                 isset($assigneesDescription) ? ['['.implode(', ', $assigneesDescription).']'] : [],
 70 |             ));
 71 |         }
 72 | 
 73 |         return $description;
 74 |     }
 75 | 
 76 |     /**
 77 |      * Fires after the test method description is printed.
 78 |      */
 79 |     public static function afterTestMethodDescription(TestResult $result): void
 80 |     {
 81 |         if (($context = $result->context) === []) {
 82 |             return;
 83 |         }
 84 | 
 85 |         renderUsing(self::$output);
 86 | 
 87 |         [
 88 |             'notes' => $notes,
 89 |         ] = $context;
 90 | 
 91 |         foreach ($notes as $note) {
 92 |             render(sprintf(<<<'HTML'
 93 |                 <div class="ml-2">
 94 |                     <span class="text-gray"> // %s</span>
 95 |                 </div>
 96 |                 HTML, $note,
 97 |             ));
 98 |         }
 99 |     }
100 | }
101 | 


--------------------------------------------------------------------------------
/src/Concerns/Expectable.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Pest\Concerns;
 6 | 
 7 | use Pest\Expectation;
 8 | 
 9 | /**
10 |  * @internal
11 |  */
12 | trait Expectable
13 | {
14 |     /**
15 |      * @template TValue
16 |      *
17 |      * Creates a new Expectation.
18 |      *
19 |      * @param  TValue  $value
20 |      * @return Expectation<TValue>
21 |      */
22 |     public function expect(mixed $value): Expectation
23 |     {
24 |         return new Expectation($value);
25 |     }
26 | }
27 | 


--------------------------------------------------------------------------------
/src/Concerns/Extendable.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Pest\Concerns;
 6 | 
 7 | use Closure;
 8 | 
 9 | /**
10 |  * @internal
11 |  */
12 | trait Extendable
13 | {
14 |     /**
15 |      * The list of extends.
16 |      *
17 |      * @var array<string, Closure>
18 |      */
19 |     private static array $extends = [];
20 | 
21 |     /**
22 |      * Register a new extend.
23 |      */
24 |     public function extend(string $name, Closure $extend): void
25 |     {
26 |         static::$extends[$name] = $extend;
27 |     }
28 | 
29 |     /**
30 |      * Checks if given extend name is registered.
31 |      */
32 |     public static function hasExtend(string $name): bool
33 |     {
34 |         return array_key_exists($name, static::$extends);
35 |     }
36 | }
37 | 


--------------------------------------------------------------------------------
/src/Concerns/Logging/WritesToConsole.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Pest\Concerns\Logging;
 6 | 
 7 | /**
 8 |  * @internal
 9 |  */
10 | trait WritesToConsole
11 | {
12 |     /**
13 |      * Writes the given success message to the console.
14 |      */
15 |     private function writeSuccess(string $message): void
16 |     {
17 |         $this->writePestTestOutput($message, 'fg-green, bold', '✓');
18 |     }
19 | 
20 |     /**
21 |      * Writes the given error message to the console.
22 |      */
23 |     private function writeError(string $message): void
24 |     {
25 |         $this->writePestTestOutput($message, 'fg-red, bold', '⨯');
26 |     }
27 | 
28 |     /**
29 |      * Writes the given warning message to the console.
30 |      */
31 |     private function writeWarning(string $message): void
32 |     {
33 |         $this->writePestTestOutput($message, 'fg-yellow, bold', '-');
34 |     }
35 | 
36 |     /**
37 |      * Writes the give message to the console.
38 |      */
39 |     private function writePestTestOutput(string $message, string $color, string $symbol): void
40 |     {
41 |         $this->writeWithColor($color, "$symbol ", false);
42 |         $this->write($message);
43 |         $this->writeNewLine();
44 |     }
45 | }
46 | 


--------------------------------------------------------------------------------
/src/Concerns/Pipeable.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Pest\Concerns;
 6 | 
 7 | use Closure;
 8 | 
 9 | /**
10 |  * @internal
11 |  */
12 | trait Pipeable
13 | {
14 |     /**
15 |      * The list of pipes.
16 |      *
17 |      * @var array<string, array<Closure(Closure, mixed ...$arguments): void>>
18 |      */
19 |     private static array $pipes = [];
20 | 
21 |     /**
22 |      * The list of interceptors.
23 |      *
24 |      * @var array<string, array<Closure(Closure, mixed ...$arguments): void>>
25 |      */
26 |     private static array $interceptors = [];
27 | 
28 |     /**
29 |      * Register a pipe to be applied before an expectation is checked.
30 |      */
31 |     public function pipe(string $name, Closure $pipe): void
32 |     {
33 |         self::$pipes[$name][] = $pipe;
34 |     }
35 | 
36 |     /**
37 |      * Register an interceptor that should replace an existing expectation.
38 |      *
39 |      * @param  string|Closure(mixed $value, mixed ...$arguments):bool  $filter
40 |      */
41 |     public function intercept(string $name, string|Closure $filter, Closure $handler): void
42 |     {
43 |         if (is_string($filter)) {
44 |             $filter = fn ($value): bool => $value instanceof $filter;
45 |         }
46 | 
47 |         self::$interceptors[$name][] = $handler;
48 | 
49 |         $this->pipe($name, function ($next, ...$arguments) use ($handler, $filter): void {
50 |             /* @phpstan-ignore-next-line */
51 |             if ($filter($this->value, ...$arguments)) {
52 |                 // @phpstan-ignore-next-line
53 |                 $handler->bindTo($this, $this::class)(...$arguments);
54 | 
55 |                 return;
56 |             }
57 | 
58 |             $next();
59 |         });
60 |     }
61 | 
62 |     /**
63 |      * Get the list of pipes by the given name.
64 |      *
65 |      * @return array<int, Closure>
66 |      */
67 |     private function pipes(string $name, object $context, string $scope): array
68 |     {
69 |         return array_map(fn (Closure $pipe): \Closure => $pipe->bindTo($context, $scope), self::$pipes[$name] ?? []);
70 |     }
71 | }
72 | 


--------------------------------------------------------------------------------
/src/Concerns/Retrievable.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Pest\Concerns;
 6 | 
 7 | /**
 8 |  * @internal
 9 |  */
10 | trait Retrievable
11 | {
12 |     /**
13 |      * @template TRetrievableValue
14 |      *
15 |      * Safely retrieve the value at the given key from an object or array.
16 |      * @template TRetrievableValue
17 |      *
18 |      * @param  array<string, TRetrievableValue>|object  $value
19 |      * @param  TRetrievableValue|null  $default
20 |      * @return TRetrievableValue|null
21 |      */
22 |     private function retrieve(string $key, mixed $value, mixed $default = null): mixed
23 |     {
24 |         if (is_array($value)) {
25 |             return $value[$key] ?? $default;
26 |         }
27 | 
28 |         // @phpstan-ignore-next-line
29 |         return $value->$key ?? $default;
30 |     }
31 | }
32 | 


--------------------------------------------------------------------------------
/src/Configuration.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | declare(strict_types=1);
  4 | 
  5 | namespace Pest;
  6 | 
  7 | use Pest\PendingCalls\UsesCall;
  8 | 
  9 | /**
 10 |  * @internal
 11 |  *
 12 |  * @mixin UsesCall
 13 |  */
 14 | final readonly class Configuration
 15 | {
 16 |     /**
 17 |      * The filename of the configuration.
 18 |      */
 19 |     private string $filename;
 20 | 
 21 |     /**
 22 |      * Creates a new configuration instance.
 23 |      */
 24 |     public function __construct(
 25 |         string $filename,
 26 |     ) {
 27 |         $this->filename = str_ends_with($filename, DIRECTORY_SEPARATOR.'Pest.php') ? dirname($filename) : $filename;
 28 |     }
 29 | 
 30 |     /**
 31 |      * Use the given classes and traits in the given targets.
 32 |      */
 33 |     public function in(string ...$targets): UsesCall
 34 |     {
 35 |         return (new UsesCall($this->filename, []))->in(...$targets);
 36 |     }
 37 | 
 38 |     /**
 39 |      * Depending on where is called, it will extend the given classes and traits globally or locally.
 40 |      */
 41 |     public function extend(string ...$classAndTraits): UsesCall
 42 |     {
 43 |         return new UsesCall(
 44 |             $this->filename,
 45 |             array_values($classAndTraits)
 46 |         );
 47 |     }
 48 | 
 49 |     /**
 50 |      * Depending on where is called, it will extend the given classes and traits globally or locally.
 51 |      */
 52 |     public function extends(string ...$classAndTraits): UsesCall
 53 |     {
 54 |         return $this->extend(...$classAndTraits);
 55 |     }
 56 | 
 57 |     /**
 58 |      * Depending on where is called, it will add the given groups globally or locally.
 59 |      */
 60 |     public function group(string ...$groups): UsesCall
 61 |     {
 62 |         return (new UsesCall($this->filename, []))->group(...$groups);
 63 |     }
 64 | 
 65 |     /**
 66 |      * Depending on where is called, it will extend the given classes and traits globally or locally.
 67 |      */
 68 |     public function use(string ...$classAndTraits): UsesCall
 69 |     {
 70 |         return $this->extend(...$classAndTraits);
 71 |     }
 72 | 
 73 |     /**
 74 |      * Depending on where is called, it will extend the given classes and traits globally or locally.
 75 |      */
 76 |     public function uses(string ...$classAndTraits): UsesCall
 77 |     {
 78 |         return $this->extends(...$classAndTraits);
 79 |     }
 80 | 
 81 |     /**
 82 |      * Gets the printer configuration.
 83 |      */
 84 |     public function printer(): Configuration\Printer
 85 |     {
 86 |         return new Configuration\Printer;
 87 |     }
 88 | 
 89 |     /**
 90 |      * Gets the presets configuration.
 91 |      */
 92 |     public function presets(): Configuration\Presets
 93 |     {
 94 |         return new Configuration\Presets;
 95 |     }
 96 | 
 97 |     /**
 98 |      * Gets the project configuration.
 99 |      */
100 |     public function project(): Configuration\Project
101 |     {
102 |         return Configuration\Project::getInstance();
103 |     }
104 | 
105 |     /**
106 |      * Proxies calls to the uses method.
107 |      *
108 |      * @param  array<array-key, mixed>  $arguments
109 |      */
110 |     public function __call(string $name, array $arguments): mixed
111 |     {
112 |         return $this->uses()->$name(...$arguments); // @phpstan-ignore-line
113 |     }
114 | }
115 | 


--------------------------------------------------------------------------------
/src/Configuration/Presets.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Pest\Configuration;
 6 | 
 7 | use Closure;
 8 | use Pest\Preset;
 9 | 
10 | final class Presets
11 | {
12 |     /**
13 |      * Creates a custom preset instance, and adds it to the list of presets.
14 |      */
15 |     public function custom(string $name, Closure $execute): void
16 |     {
17 |         Preset::custom($name, $execute);
18 |     }
19 | }
20 | 


--------------------------------------------------------------------------------
/src/Configuration/Printer.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Pest\Configuration;
 6 | 
 7 | use NunoMaduro\Collision\Adapters\Phpunit\Printers\DefaultPrinter;
 8 | 
 9 | /**
10 |  * @internal
11 |  */
12 | final readonly class Printer
13 | {
14 |     /**
15 |      * Sets the theme to compact.
16 |      */
17 |     public function compact(): self
18 |     {
19 |         DefaultPrinter::compact(true);
20 | 
21 |         return $this;
22 |     }
23 | }
24 | 


--------------------------------------------------------------------------------
/src/Configuration/Project.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | declare(strict_types=1);
  4 | 
  5 | namespace Pest\Configuration;
  6 | 
  7 | /**
  8 |  * @internal
  9 |  */
 10 | final class Project
 11 | {
 12 |     /**
 13 |      * The assignees link.
 14 |      *
 15 |      * @internal
 16 |      */
 17 |     public string $assignees = '';
 18 | 
 19 |     /**
 20 |      * The issues link.
 21 |      *
 22 |      * @internal
 23 |      */
 24 |     public string $issues = '';
 25 | 
 26 |     /**
 27 |      * The PRs link.
 28 |      *
 29 |      * @internal
 30 |      */
 31 |     public string $prs = '';
 32 | 
 33 |     /**
 34 |      * The singleton instance.
 35 |      */
 36 |     private static ?self $instance = null;
 37 | 
 38 |     /**
 39 |      * Creates a new instance of the project.
 40 |      */
 41 |     public static function getInstance(): self
 42 |     {
 43 |         return self::$instance ??= new self;
 44 |     }
 45 | 
 46 |     /**
 47 |      * Sets the test project to GitHub.
 48 |      */
 49 |     public function github(string $project): self
 50 |     {
 51 |         $this->issues = "https://github.com/{$project}/issues/%s";
 52 |         $this->prs = "https://github.com/{$project}/pull/%s";
 53 | 
 54 |         $this->assignees = 'https://github.com/%s';
 55 | 
 56 |         return $this;
 57 |     }
 58 | 
 59 |     /**
 60 |      * Sets the test project to GitLab.
 61 |      */
 62 |     public function gitlab(string $project): self
 63 |     {
 64 |         $this->issues = "https://gitlab.com/{$project}/issues/%s";
 65 |         $this->prs = "https://gitlab.com/{$project}/merge_requests/%s";
 66 | 
 67 |         $this->assignees = 'https://gitlab.com/%s';
 68 | 
 69 |         return $this;
 70 |     }
 71 | 
 72 |     /**
 73 |      * Sets the test project to Bitbucket.
 74 |      */
 75 |     public function bitbucket(string $project): self
 76 |     {
 77 |         $this->issues = "https://bitbucket.org/{$project}/issues/%s";
 78 |         $this->prs = "https://bitbucket.org/{$project}/pull-requests/%s";
 79 | 
 80 |         $this->assignees = 'https://bitbucket.org/%s';
 81 | 
 82 |         return $this;
 83 |     }
 84 | 
 85 |     /**
 86 |      * Sets the test project to Jira.
 87 |      */
 88 |     public function jira(string $namespace, string $project): self
 89 |     {
 90 |         $this->issues = "https://{$namespace}.atlassian.net/browse/{$project}-%s";
 91 | 
 92 |         $this->assignees = "https://{$namespace}.atlassian.net/secure/ViewProfile.jspa?name=%s";
 93 | 
 94 |         return $this;
 95 |     }
 96 | 
 97 |     /**
 98 |      * Sets the test project to custom.
 99 |      */
100 |     public function custom(string $issues, string $prs, string $assignees): self
101 |     {
102 |         $this->issues = $issues;
103 |         $this->prs = $prs;
104 | 
105 |         $this->assignees = $assignees;
106 | 
107 |         return $this;
108 |     }
109 | }
110 | 


--------------------------------------------------------------------------------
/src/Console/Help.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Pest\Console;
 6 | 
 7 | use Symfony\Component\Console\Output\OutputInterface;
 8 | 
 9 | /**
10 |  * @internal
11 |  */
12 | final readonly class Help
13 | {
14 |     /**
15 |      * The Command messages.
16 |      *
17 |      * @var array<int, string>
18 |      */
19 |     private const HELP_MESSAGES = [
20 |         '<comment>Pest Options:</comment>',
21 |         '  <info>--init</info>                      Initialise a standard Pest configuration',
22 |         '  <info>--coverage</info>                  Enable coverage and output to standard output',
23 |         '  <info>--min=<fg=cyan><N></></info>                   Set the minimum required coverage percentage (<N>), and fail if not met',
24 |         '  <info>--group=<fg=cyan><name></></info>              Only runs tests from the specified group(s)',
25 |     ];
26 | 
27 |     /**
28 |      * Creates a new Console Command instance.
29 |      */
30 |     public function __construct(private OutputInterface $output)
31 |     {
32 |         // ..
33 |     }
34 | 
35 |     /**
36 |      * Executes the Console Command.
37 |      */
38 |     public function __invoke(): void
39 |     {
40 |         foreach (self::HELP_MESSAGES as $message) {
41 |             $this->output->writeln($message);
42 |         }
43 |     }
44 | }
45 | 


--------------------------------------------------------------------------------
/src/Console/Thanks.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Pest\Console;
 6 | 
 7 | use Pest\Bootstrappers\BootView;
 8 | use Pest\Support\View;
 9 | use Symfony\Component\Console\Helper\SymfonyQuestionHelper;
10 | use Symfony\Component\Console\Input\ArrayInput;
11 | use Symfony\Component\Console\Input\InputInterface;
12 | use Symfony\Component\Console\Output\OutputInterface;
13 | use Symfony\Component\Console\Question\ConfirmationQuestion;
14 | 
15 | /**
16 |  * @internal
17 |  */
18 | final readonly class Thanks
19 | {
20 |     /**
21 |      * The support options.
22 |      *
23 |      * @var array<string, string>
24 |      */
25 |     private const FUNDING_MESSAGES = [
26 |         'Star' => 'https://github.com/pestphp/pest',
27 |         'YouTube' => 'https://youtube.com/@nunomaduro',
28 |         'TikTok' => 'https://tiktok.com/@nunomaduro',
29 |         'Twitch' => 'https://twitch.tv/enunomaduro',
30 |         'LinkedIn' => 'https://linkedin.com/in/nunomaduro',
31 |         'Instagram' => 'https://instagram.com/enunomaduro',
32 |         'X' => 'https://x.com/enunomaduro',
33 |         'Sponsor' => 'https://github.com/sponsors/nunomaduro',
34 |     ];
35 | 
36 |     /**
37 |      * Creates a new Console Command instance.
38 |      */
39 |     public function __construct(
40 |         private InputInterface $input,
41 |         private OutputInterface $output
42 |     ) {
43 |         // ..
44 |     }
45 | 
46 |     /**
47 |      * Executes the Console Command.
48 |      */
49 |     public function __invoke(): void
50 |     {
51 |         $bootstrapper = new BootView($this->output);
52 |         $bootstrapper->boot();
53 | 
54 |         $wantsToSupport = false;
55 | 
56 |         if (getenv('PEST_NO_SUPPORT') !== 'true' && $this->input->isInteractive()) {
57 |             $wantsToSupport = (new SymfonyQuestionHelper)->ask(
58 |                 new ArrayInput([]),
59 |                 $this->output,
60 |                 new ConfirmationQuestion(
61 |                     ' <options=bold>Wanna show Pest some love by starring it on GitHub?</>',
62 |                     false,
63 |                 )
64 |             );
65 | 
66 |             View::render('components.new-line');
67 | 
68 |             foreach (self::FUNDING_MESSAGES as $message => $link) {
69 |                 View::render('components.two-column-detail', [
70 |                     'left' => $message,
71 |                     'right' => $link,
72 |                 ]);
73 |             }
74 | 
75 |             View::render('components.new-line');
76 |         }
77 | 
78 |         if ($wantsToSupport === true) {
79 |             if (PHP_OS_FAMILY === 'Darwin') {
80 |                 exec('open https://github.com/pestphp/pest');
81 |             }
82 |             if (PHP_OS_FAMILY === 'Windows') {
83 |                 exec('start https://github.com/pestphp/pest');
84 |             }
85 |             if (PHP_OS_FAMILY === 'Linux') {
86 |                 exec('xdg-open https://github.com/pestphp/pest');
87 |             }
88 |         }
89 |     }
90 | }
91 | 


--------------------------------------------------------------------------------
/src/Contracts/ArchPreset.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Pest\Contracts;
 6 | 
 7 | /**
 8 |  * @internal
 9 |  */
10 | interface ArchPreset {}
11 | 


--------------------------------------------------------------------------------
/src/Contracts/Bootstrapper.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Pest\Contracts;
 6 | 
 7 | /**
 8 |  * @internal
 9 |  */
10 | interface Bootstrapper
11 | {
12 |     /**
13 |      * Boots the bootstrapper.
14 |      */
15 |     public function boot(): void;
16 | }
17 | 


--------------------------------------------------------------------------------
/src/Contracts/HasPrintableTestCaseName.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Pest\Contracts;
 6 | 
 7 | use NunoMaduro\Collision\Contracts\Adapters\Phpunit\HasPrintableTestCaseName as BaseHasPrintableTestCaseName;
 8 | 
 9 | /**
10 |  * @internal
11 |  */
12 | interface HasPrintableTestCaseName extends BaseHasPrintableTestCaseName
13 | {
14 |     // ..
15 | }
16 | 


--------------------------------------------------------------------------------
/src/Contracts/Panicable.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Pest\Contracts;
 6 | 
 7 | use Symfony\Component\Console\Output\OutputInterface;
 8 | 
 9 | /**
10 |  * @internal
11 |  */
12 | interface Panicable
13 | {
14 |     /**
15 |      * Renders the panic on the given output.
16 |      */
17 |     public function render(OutputInterface $output): void;
18 | 
19 |     /**
20 |      * The exit code to be used.
21 |      */
22 |     public function exitCode(): int;
23 | }
24 | 


--------------------------------------------------------------------------------
/src/Contracts/Plugins/AddsOutput.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Pest\Contracts\Plugins;
 6 | 
 7 | /**
 8 |  * @internal
 9 |  */
10 | interface AddsOutput
11 | {
12 |     /**
13 |      * Adds output after the Test Suite execution.
14 |      */
15 |     public function addOutput(int $exitCode): int;
16 | }
17 | 


--------------------------------------------------------------------------------
/src/Contracts/Plugins/Bootable.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Pest\Contracts\Plugins;
 6 | 
 7 | /**
 8 |  * @internal
 9 |  */
10 | interface Bootable
11 | {
12 |     /**
13 |      * Boots the plugin.
14 |      */
15 |     public function boot(): void;
16 | }
17 | 


--------------------------------------------------------------------------------
/src/Contracts/Plugins/HandlesArguments.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Pest\Contracts\Plugins;
 6 | 
 7 | /**
 8 |  * @internal
 9 |  */
10 | interface HandlesArguments
11 | {
12 |     /**
13 |      * Adds arguments before the Test Suite execution.
14 |      *
15 |      * @param  array<int, string>  $arguments
16 |      * @return array<int, string>
17 |      */
18 |     public function handleArguments(array $arguments): array;
19 | }
20 | 


--------------------------------------------------------------------------------
/src/Contracts/Plugins/HandlesOriginalArguments.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Pest\Contracts\Plugins;
 6 | 
 7 | /**
 8 |  * @internal
 9 |  */
10 | interface HandlesOriginalArguments
11 | {
12 |     /**
13 |      * Adds original arguments before the Test Suite execution.
14 |      *
15 |      * @param  array<int, string>  $arguments
16 |      */
17 |     public function handleOriginalArguments(array $arguments): void;
18 | }
19 | 


--------------------------------------------------------------------------------
/src/Contracts/Plugins/Terminable.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Pest\Contracts\Plugins;
 6 | 
 7 | /**
 8 |  * @internal
 9 |  */
10 | interface Terminable
11 | {
12 |     /**
13 |      * Terminates the plugin.
14 |      */
15 |     public function terminate(): void;
16 | }
17 | 


--------------------------------------------------------------------------------
/src/Contracts/TestCaseFilter.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Pest\Contracts;
 6 | 
 7 | interface TestCaseFilter
 8 | {
 9 |     /**
10 |      * Whether the test case is accepted.
11 |      */
12 |     public function accept(string $testCaseFilename): bool;
13 | }
14 | 


--------------------------------------------------------------------------------
/src/Contracts/TestCaseMethodFilter.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Pest\Contracts;
 6 | 
 7 | use Pest\Factories\TestCaseMethodFactory;
 8 | 
 9 | interface TestCaseMethodFilter
10 | {
11 |     /**
12 |      * Whether the test case method is accepted.
13 |      */
14 |     public function accept(TestCaseMethodFactory $factory): bool;
15 | }
16 | 


--------------------------------------------------------------------------------
/src/Evaluators/Attributes.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Pest\Evaluators;
 6 | 
 7 | use Pest\Factories\Attribute;
 8 | 
 9 | /**
10 |  * @internal
11 |  */
12 | final class Attributes
13 | {
14 |     /**
15 |      * Evaluates the given attributes and returns the code.
16 |      *
17 |      * @param  iterable<int, Attribute>  $attributes
18 |      */
19 |     public static function code(iterable $attributes): string
20 |     {
21 |         return implode(PHP_EOL, array_map(function (Attribute $attribute): string {
22 |             $name = $attribute->name;
23 | 
24 |             if ($attribute->arguments === []) {
25 |                 return "    #[\\{$name}]";
26 |             }
27 | 
28 |             $arguments = array_map(fn (string $argument): string => var_export($argument, true), iterator_to_array($attribute->arguments));
29 | 
30 |             return sprintf('    #[\\%s(%s)]', $name, implode(', ', $arguments));
31 |         }, iterator_to_array($attributes)));
32 |     }
33 | }
34 | 


--------------------------------------------------------------------------------
/src/Exceptions/AfterAllAlreadyExist.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Pest\Exceptions;
 6 | 
 7 | use InvalidArgumentException;
 8 | use NunoMaduro\Collision\Contracts\RenderlessEditor;
 9 | use NunoMaduro\Collision\Contracts\RenderlessTrace;
10 | use Symfony\Component\Console\Exception\ExceptionInterface;
11 | 
12 | /**
13 |  * @internal
14 |  */
15 | final class AfterAllAlreadyExist extends InvalidArgumentException implements ExceptionInterface, RenderlessEditor, RenderlessTrace
16 | {
17 |     /**
18 |      * Creates a new Exception instance.
19 |      */
20 |     public function __construct(string $filename)
21 |     {
22 |         parent::__construct(sprintf('The afterAll already exists in the filename `%s`.', $filename));
23 |     }
24 | }
25 | 


--------------------------------------------------------------------------------
/src/Exceptions/AfterAllWithinDescribe.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Pest\Exceptions;
 6 | 
 7 | use InvalidArgumentException;
 8 | use NunoMaduro\Collision\Contracts\RenderlessEditor;
 9 | use NunoMaduro\Collision\Contracts\RenderlessTrace;
10 | use Symfony\Component\Console\Exception\ExceptionInterface;
11 | 
12 | /**
13 |  * @internal
14 |  */
15 | final class AfterAllWithinDescribe extends InvalidArgumentException implements ExceptionInterface, RenderlessEditor, RenderlessTrace
16 | {
17 |     /**
18 |      * Creates a new Exception instance.
19 |      */
20 |     public function __construct(string $filename)
21 |     {
22 |         parent::__construct(sprintf('The afterAll method can not be used within describe functions. Filename `%s`.', $filename));
23 |     }
24 | }
25 | 


--------------------------------------------------------------------------------
/src/Exceptions/AfterBeforeTestFunction.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Pest\Exceptions;
 6 | 
 7 | use InvalidArgumentException;
 8 | use NunoMaduro\Collision\Contracts\RenderlessEditor;
 9 | use NunoMaduro\Collision\Contracts\RenderlessTrace;
10 | use Symfony\Component\Console\Exception\ExceptionInterface;
11 | 
12 | /**
13 |  * @internal
14 |  */
15 | final class AfterBeforeTestFunction extends InvalidArgumentException implements ExceptionInterface, RenderlessEditor, RenderlessTrace
16 | {
17 |     /**
18 |      * Creates a new Exception instance.
19 |      */
20 |     public function __construct(string $filename)
21 |     {
22 |         parent::__construct('After method cannot be used with before the [test|it] functions in the filename `['.$filename.']`.');
23 |     }
24 | }
25 | 


--------------------------------------------------------------------------------
/src/Exceptions/BeforeAllAlreadyExist.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Pest\Exceptions;
 6 | 
 7 | use InvalidArgumentException;
 8 | use NunoMaduro\Collision\Contracts\RenderlessEditor;
 9 | use NunoMaduro\Collision\Contracts\RenderlessTrace;
10 | use Symfony\Component\Console\Exception\ExceptionInterface;
11 | 
12 | /**
13 |  * @internal
14 |  */
15 | final class BeforeAllAlreadyExist extends InvalidArgumentException implements ExceptionInterface, RenderlessEditor, RenderlessTrace
16 | {
17 |     /**
18 |      * Creates a new Exception instance.
19 |      */
20 |     public function __construct(string $filename)
21 |     {
22 |         parent::__construct(sprintf('The beforeAll already exists in the filename `%s`.', $filename));
23 |     }
24 | }
25 | 


--------------------------------------------------------------------------------
/src/Exceptions/BeforeAllWithinDescribe.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Pest\Exceptions;
 6 | 
 7 | use InvalidArgumentException;
 8 | use NunoMaduro\Collision\Contracts\RenderlessEditor;
 9 | use NunoMaduro\Collision\Contracts\RenderlessTrace;
10 | use Symfony\Component\Console\Exception\ExceptionInterface;
11 | 
12 | /**
13 |  * @internal
14 |  */
15 | final class BeforeAllWithinDescribe extends InvalidArgumentException implements ExceptionInterface, RenderlessEditor, RenderlessTrace
16 | {
17 |     /**
18 |      * Creates a new Exception instance.
19 |      */
20 |     public function __construct(string $filename)
21 |     {
22 |         parent::__construct(sprintf('The beforeAll method can not be used within describe functions. Filename `%s`.', $filename));
23 |     }
24 | }
25 | 


--------------------------------------------------------------------------------
/src/Exceptions/DatasetAlreadyExists.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Pest\Exceptions;
 6 | 
 7 | use InvalidArgumentException;
 8 | use NunoMaduro\Collision\Contracts\RenderlessEditor;
 9 | use NunoMaduro\Collision\Contracts\RenderlessTrace;
10 | use Symfony\Component\Console\Exception\ExceptionInterface;
11 | 
12 | /**
13 |  * @internal
14 |  */
15 | final class DatasetAlreadyExists extends InvalidArgumentException implements ExceptionInterface, RenderlessEditor, RenderlessTrace
16 | {
17 |     /**
18 |      * Creates a new Exception instance.
19 |      */
20 |     public function __construct(string $name, string $scope)
21 |     {
22 |         parent::__construct(sprintf('A dataset with the name `%s` already exists in scope [%s].', $name, $scope));
23 |     }
24 | }
25 | 


--------------------------------------------------------------------------------
/src/Exceptions/DatasetArgumentsMismatch.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Pest\Exceptions;
 6 | 
 7 | use Exception;
 8 | 
 9 | final class DatasetArgumentsMismatch extends Exception
10 | {
11 |     public function __construct(int $requiredCount, int $suppliedCount)
12 |     {
13 |         if ($requiredCount <= $suppliedCount) {
14 |             parent::__construct('Test argument names and dataset keys do not match');
15 |         } else {
16 |             parent::__construct(sprintf('Test expects %d arguments but dataset only provides %d', $requiredCount, $suppliedCount));
17 |         }
18 |     }
19 | 
20 |     //
21 | }
22 | 


--------------------------------------------------------------------------------
/src/Exceptions/DatasetDoesNotExist.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Pest\Exceptions;
 6 | 
 7 | use InvalidArgumentException;
 8 | use NunoMaduro\Collision\Contracts\RenderlessEditor;
 9 | use NunoMaduro\Collision\Contracts\RenderlessTrace;
10 | use Symfony\Component\Console\Exception\ExceptionInterface;
11 | 
12 | /**
13 |  * @internal
14 |  */
15 | final class DatasetDoesNotExist extends InvalidArgumentException implements ExceptionInterface, RenderlessEditor, RenderlessTrace
16 | {
17 |     /**
18 |      * Creates a new Exception instance.
19 |      */
20 |     public function __construct(string $name)
21 |     {
22 |         parent::__construct(sprintf("A dataset with the name `%s` does not exist. You can create it using `dataset('%s', ['a', 'b']);`.", $name, $name));
23 |     }
24 | }
25 | 


--------------------------------------------------------------------------------
/src/Exceptions/DatasetMissing.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Pest\Exceptions;
 6 | 
 7 | use BadFunctionCallException;
 8 | use NunoMaduro\Collision\Contracts\RenderlessEditor;
 9 | use NunoMaduro\Collision\Contracts\RenderlessTrace;
10 | use Symfony\Component\Console\Exception\ExceptionInterface;
11 | 
12 | /**
13 |  * @internal
14 |  */
15 | final class DatasetMissing extends BadFunctionCallException implements ExceptionInterface, RenderlessEditor, RenderlessTrace
16 | {
17 |     /**
18 |      * Creates a new Exception instance.
19 |      *
20 |      * @param  array<string, string>  $arguments
21 |      */
22 |     public function __construct(string $file, string $name, array $arguments)
23 |     {
24 |         parent::__construct(sprintf(
25 |             "A test with the description '%s' has %d argument(s) ([%s]) and no dataset(s) provided in %s",
26 |             $name,
27 |             count($arguments),
28 |             implode(', ', array_map(static fn (string $arg, string $type): string => sprintf('%s $%s', $type, $arg), array_keys($arguments), $arguments)),
29 |             $file,
30 |         ));
31 |     }
32 | }
33 | 


--------------------------------------------------------------------------------
/src/Exceptions/ExpectationNotFound.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Pest\Exceptions;
 6 | 
 7 | use Exception;
 8 | 
 9 | /**
10 |  * @internal
11 |  */
12 | final class ExpectationNotFound extends Exception
13 | {
14 |     /**
15 |      * Creates a new ExpectationNotFound instance from the given name.
16 |      */
17 |     public static function fromName(string $name): ExpectationNotFound
18 |     {
19 |         return new self("Expectation [$name] does not exist.");
20 |     }
21 | }
22 | 


--------------------------------------------------------------------------------
/src/Exceptions/FatalException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Pest\Exceptions;
 6 | 
 7 | use NunoMaduro\Collision\Contracts\RenderlessTrace;
 8 | use RuntimeException;
 9 | 
10 | /**
11 |  * @internal
12 |  */
13 | final class FatalException extends RuntimeException implements RenderlessTrace
14 | {
15 |     //
16 | }
17 | 


--------------------------------------------------------------------------------
/src/Exceptions/FileOrFolderNotFound.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Pest\Exceptions;
 6 | 
 7 | use InvalidArgumentException;
 8 | use NunoMaduro\Collision\Contracts\RenderlessEditor;
 9 | use NunoMaduro\Collision\Contracts\RenderlessTrace;
10 | use Symfony\Component\Console\Exception\ExceptionInterface;
11 | 
12 | /**
13 |  * @internal
14 |  */
15 | final class FileOrFolderNotFound extends InvalidArgumentException implements ExceptionInterface, RenderlessEditor, RenderlessTrace
16 | {
17 |     /**
18 |      * Creates a new Exception instance.
19 |      */
20 |     public function __construct(string $filename)
21 |     {
22 |         parent::__construct(sprintf('The file or folder with the name `%s` could not be found.', $filename));
23 |     }
24 | }
25 | 


--------------------------------------------------------------------------------
/src/Exceptions/InvalidArgumentException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Pest\Exceptions;
 6 | 
 7 | use InvalidArgumentException as BaseInvalidArgumentException;
 8 | use NunoMaduro\Collision\Contracts\RenderlessEditor;
 9 | use NunoMaduro\Collision\Contracts\RenderlessTrace;
10 | use Symfony\Component\Console\Exception\ExceptionInterface;
11 | 
12 | /**
13 |  * @internal
14 |  */
15 | final class InvalidArgumentException extends BaseInvalidArgumentException implements ExceptionInterface, RenderlessEditor, RenderlessTrace
16 | {
17 |     /**
18 |      * Creates a new Exception instance.
19 |      */
20 |     public function __construct(string $message)
21 |     {
22 |         parent::__construct($message, 1);
23 |     }
24 | }
25 | 


--------------------------------------------------------------------------------
/src/Exceptions/InvalidExpectation.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Pest\Exceptions;
 6 | 
 7 | use LogicException;
 8 | use NunoMaduro\Collision\Contracts\RenderlessEditor;
 9 | use NunoMaduro\Collision\Contracts\RenderlessTrace;
10 | use Symfony\Component\Console\Exception\ExceptionInterface;
11 | 
12 | /**
13 |  * @internal
14 |  */
15 | final class InvalidExpectation extends LogicException implements ExceptionInterface, RenderlessEditor, RenderlessTrace
16 | {
17 |     /**
18 |      * @param  array<int, string>  $methods
19 |      *
20 |      * @throws self
21 |      */
22 |     public static function fromMethods(array $methods): never
23 |     {
24 |         throw new self(sprintf('Expectation [%s] is not valid.', implode('->', $methods)));
25 |     }
26 | }
27 | 


--------------------------------------------------------------------------------
/src/Exceptions/InvalidExpectationValue.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Pest\Exceptions;
 6 | 
 7 | use InvalidArgumentException;
 8 | 
 9 | /**
10 |  * @internal
11 |  */
12 | final class InvalidExpectationValue extends InvalidArgumentException
13 | {
14 |     /**
15 |      * @throws self
16 |      */
17 |     public static function expected(string $type): never
18 |     {
19 |         throw new self(sprintf('Invalid expectation value type. Expected [%s].', $type));
20 |     }
21 | }
22 | 


--------------------------------------------------------------------------------
/src/Exceptions/InvalidOption.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Pest\Exceptions;
 6 | 
 7 | use InvalidArgumentException;
 8 | use NunoMaduro\Collision\Contracts\RenderlessEditor;
 9 | use NunoMaduro\Collision\Contracts\RenderlessTrace;
10 | use Symfony\Component\Console\Exception\ExceptionInterface;
11 | 
12 | /**
13 |  * @internal
14 |  */
15 | final class InvalidOption extends InvalidArgumentException implements ExceptionInterface, RenderlessEditor, RenderlessTrace
16 | {
17 |     /**
18 |      * Creates a new Exception instance.
19 |      */
20 |     public function __construct(string $message)
21 |     {
22 |         parent::__construct($message, 1);
23 |     }
24 | }
25 | 


--------------------------------------------------------------------------------
/src/Exceptions/InvalidPestCommand.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Pest\Exceptions;
 6 | 
 7 | use InvalidArgumentException;
 8 | use NunoMaduro\Collision\Contracts\RenderlessEditor;
 9 | use NunoMaduro\Collision\Contracts\RenderlessTrace;
10 | use Symfony\Component\Console\Exception\ExceptionInterface;
11 | 
12 | /**
13 |  * @internal
14 |  */
15 | final class InvalidPestCommand extends InvalidArgumentException implements ExceptionInterface, RenderlessEditor, RenderlessTrace
16 | {
17 |     /**
18 |      * Creates a new Exception instance.
19 |      */
20 |     public function __construct()
21 |     {
22 |         parent::__construct('Please run [./vendor/bin/pest] instead.');
23 |     }
24 | }
25 | 


--------------------------------------------------------------------------------
/src/Exceptions/MissingDependency.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Pest\Exceptions;
 6 | 
 7 | use InvalidArgumentException;
 8 | use NunoMaduro\Collision\Contracts\RenderlessEditor;
 9 | use NunoMaduro\Collision\Contracts\RenderlessTrace;
10 | use Symfony\Component\Console\Exception\ExceptionInterface;
11 | 
12 | /**
13 |  * @internal
14 |  */
15 | final class MissingDependency extends InvalidArgumentException implements ExceptionInterface, RenderlessEditor, RenderlessTrace
16 | {
17 |     /**
18 |      * Creates a new Exception instance.
19 |      */
20 |     public function __construct(string $feature, string $dependency)
21 |     {
22 |         parent::__construct(sprintf('The feature "%s" requires "%s".', $feature, $dependency));
23 |     }
24 | }
25 | 


--------------------------------------------------------------------------------
/src/Exceptions/NoDirtyTestsFound.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Pest\Exceptions;
 6 | 
 7 | use InvalidArgumentException;
 8 | use NunoMaduro\Collision\Contracts\RenderlessEditor;
 9 | use NunoMaduro\Collision\Contracts\RenderlessTrace;
10 | use Pest\Contracts\Panicable;
11 | use Symfony\Component\Console\Exception\ExceptionInterface;
12 | use Symfony\Component\Console\Output\OutputInterface;
13 | 
14 | /**
15 |  * @internal
16 |  */
17 | final class NoDirtyTestsFound extends InvalidArgumentException implements ExceptionInterface, Panicable, RenderlessEditor, RenderlessTrace
18 | {
19 |     /**
20 |      * Renders the panic on the given output.
21 |      */
22 |     public function render(OutputInterface $output): void
23 |     {
24 |         $output->writeln([
25 |             '',
26 |             '  <fg=white;options=bold;bg=blue> INFO </> No "dirty" tests found.',
27 |             '',
28 |         ]);
29 |     }
30 | 
31 |     /**
32 |      * The exit code to be used.
33 |      */
34 |     public function exitCode(): int
35 |     {
36 |         return 0;
37 |     }
38 | }
39 | 


--------------------------------------------------------------------------------
/src/Exceptions/ShouldNotHappen.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Pest\Exceptions;
 6 | 
 7 | use Exception;
 8 | use RuntimeException;
 9 | 
10 | /**
11 |  * @internal
12 |  */
13 | final class ShouldNotHappen extends RuntimeException
14 | {
15 |     /**
16 |      * Creates a new Exception instance.
17 |      */
18 |     public function __construct(Exception $exception)
19 |     {
20 |         $message = $exception->getMessage();
21 | 
22 |         parent::__construct(sprintf(<<<'EOF'
23 | This should not happen - please create an new issue here: https://github.com/pestphp/pest.
24 | 
25 |   Issue: %s
26 |   PHP version: %s
27 |   Operating system: %s
28 | EOF
29 |             , $message, phpversion(), PHP_OS), 1, $exception);
30 |     }
31 | 
32 |     /**
33 |      * Creates a new instance of should not happen without a specific exception.
34 |      */
35 |     public static function fromMessage(string $message): ShouldNotHappen
36 |     {
37 |         return new ShouldNotHappen(new Exception($message));
38 |     }
39 | }
40 | 


--------------------------------------------------------------------------------
/src/Exceptions/TestAlreadyExist.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Pest\Exceptions;
 6 | 
 7 | use InvalidArgumentException;
 8 | use NunoMaduro\Collision\Contracts\RenderlessEditor;
 9 | use NunoMaduro\Collision\Contracts\RenderlessTrace;
10 | use Symfony\Component\Console\Exception\ExceptionInterface;
11 | 
12 | /**
13 |  * @internal
14 |  */
15 | final class TestAlreadyExist extends InvalidArgumentException implements ExceptionInterface, RenderlessEditor, RenderlessTrace
16 | {
17 |     /**
18 |      * Creates a new Exception instance.
19 |      */
20 |     public function __construct(string $fileName, string $description)
21 |     {
22 |         parent::__construct(sprintf('A test with the description `%s` already exists in the filename `%s`.', $description, $fileName));
23 |     }
24 | }
25 | 


--------------------------------------------------------------------------------
/src/Exceptions/TestCaseAlreadyInUse.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Pest\Exceptions;
 6 | 
 7 | use InvalidArgumentException;
 8 | use NunoMaduro\Collision\Contracts\RenderlessEditor;
 9 | use NunoMaduro\Collision\Contracts\RenderlessTrace;
10 | use Symfony\Component\Console\Exception\ExceptionInterface;
11 | 
12 | /**
13 |  * @internal
14 |  */
15 | final class TestCaseAlreadyInUse extends InvalidArgumentException implements ExceptionInterface, RenderlessEditor, RenderlessTrace
16 | {
17 |     /**
18 |      * Creates a new Exception instance.
19 |      */
20 |     public function __construct(string $inUse, string $newOne, string $folder)
21 |     {
22 |         parent::__construct(sprintf('Test case `%s` can not be used. The folder `%s` already uses the test case `%s`',
23 |             $newOne, $folder, $inUse));
24 |     }
25 | }
26 | 


--------------------------------------------------------------------------------
/src/Exceptions/TestCaseClassOrTraitNotFound.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Pest\Exceptions;
 6 | 
 7 | use InvalidArgumentException;
 8 | use NunoMaduro\Collision\Contracts\RenderlessEditor;
 9 | use NunoMaduro\Collision\Contracts\RenderlessTrace;
10 | use Symfony\Component\Console\Exception\ExceptionInterface;
11 | 
12 | /**
13 |  * @internal
14 |  */
15 | final class TestCaseClassOrTraitNotFound extends InvalidArgumentException implements ExceptionInterface, RenderlessEditor, RenderlessTrace
16 | {
17 |     /**
18 |      * Creates a new Exception instance.
19 |      */
20 |     public function __construct(string $testCaseClass)
21 |     {
22 |         parent::__construct(sprintf('The class `%s` was not found.', $testCaseClass));
23 |     }
24 | }
25 | 


--------------------------------------------------------------------------------
/src/Exceptions/TestClosureMustNotBeStatic.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Pest\Exceptions;
 6 | 
 7 | use InvalidArgumentException;
 8 | use NunoMaduro\Collision\Contracts\RenderlessEditor;
 9 | use NunoMaduro\Collision\Contracts\RenderlessTrace;
10 | use Pest\Factories\TestCaseMethodFactory;
11 | use Symfony\Component\Console\Exception\ExceptionInterface;
12 | 
13 | /**
14 |  * @internal
15 |  */
16 | final class TestClosureMustNotBeStatic extends InvalidArgumentException implements ExceptionInterface, RenderlessEditor, RenderlessTrace
17 | {
18 |     /**
19 |      * Creates a new Exception instance.
20 |      */
21 |     public function __construct(TestCaseMethodFactory $method)
22 |     {
23 |         parent::__construct(
24 |             sprintf(
25 |                 'Test closure must not be static. Please remove the `static` keyword from the `%s` method in `%s`.',
26 |                 $method->description,
27 |                 $method->filename
28 |             )
29 |         );
30 |     }
31 | }
32 | 


--------------------------------------------------------------------------------
/src/Exceptions/TestDescriptionMissing.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Pest\Exceptions;
 6 | 
 7 | use InvalidArgumentException;
 8 | use NunoMaduro\Collision\Contracts\RenderlessEditor;
 9 | use NunoMaduro\Collision\Contracts\RenderlessTrace;
10 | use Symfony\Component\Console\Exception\ExceptionInterface;
11 | 
12 | /**
13 |  * @internal
14 |  */
15 | final class TestDescriptionMissing extends InvalidArgumentException implements ExceptionInterface, RenderlessEditor, RenderlessTrace
16 | {
17 |     /**
18 |      * Creates a new Exception instance.
19 |      */
20 |     public function __construct(string $fileName)
21 |     {
22 |         parent::__construct(sprintf('Test description is missing in the filename `%s`.', $fileName));
23 |     }
24 | }
25 | 


--------------------------------------------------------------------------------
/src/Expectations/EachExpectation.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Pest\Expectations;
 6 | 
 7 | use Pest\Expectation;
 8 | 
 9 | use function expect;
10 | 
11 | /**
12 |  * @internal
13 |  *
14 |  * @template TValue
15 |  *
16 |  * @mixin Expectation<TValue>
17 |  */
18 | final class EachExpectation
19 | {
20 |     /**
21 |      * Indicates if the expectation is the opposite.
22 |      */
23 |     private bool $opposite = false;
24 | 
25 |     /**
26 |      * Creates an expectation on each item of the iterable "value".
27 |      *
28 |      * @param  Expectation<TValue>  $original
29 |      */
30 |     public function __construct(private readonly Expectation $original) {}
31 | 
32 |     /**
33 |      * Creates a new expectation.
34 |      *
35 |      * @template TAndValue
36 |      *
37 |      * @param  TAndValue  $value
38 |      * @return Expectation<TAndValue>
39 |      */
40 |     public function and(mixed $value): Expectation
41 |     {
42 |         return $this->original->and($value);
43 |     }
44 | 
45 |     /**
46 |      * Creates the opposite expectation for the value.
47 |      *
48 |      * @return self<TValue>
49 |      */
50 |     public function not(): self
51 |     {
52 |         $this->opposite = true;
53 | 
54 |         return $this;
55 |     }
56 | 
57 |     /**
58 |      * Dynamically calls methods on the class with the given arguments on each item.
59 |      *
60 |      * @param  array<int|string, mixed>  $arguments
61 |      * @return self<TValue>
62 |      */
63 |     public function __call(string $name, array $arguments): self
64 |     {
65 |         foreach ($this->original->value as $item) {
66 |             /* @phpstan-ignore-next-line */
67 |             $this->opposite ? expect($item)->not()->$name(...$arguments) : expect($item)->$name(...$arguments);
68 |         }
69 | 
70 |         $this->opposite = false;
71 | 
72 |         return $this;
73 |     }
74 | 
75 |     /**
76 |      * Dynamically calls methods on the class without any arguments on each item.
77 |      *
78 |      * @return self<TValue>
79 |      */
80 |     public function __get(string $name): self
81 |     {
82 |         /* @phpstan-ignore-next-line */
83 |         return $this->$name();
84 |     }
85 | }
86 | 


--------------------------------------------------------------------------------
/src/Factories/Attribute.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Pest\Factories;
 6 | 
 7 | /**
 8 |  * @internal
 9 |  */
10 | final class Attribute
11 | {
12 |     /**
13 |      * @param  iterable<int, string>  $arguments
14 |      */
15 |     public function __construct(public string $name, public iterable $arguments)
16 |     {
17 |         //
18 |     }
19 | }
20 | 


--------------------------------------------------------------------------------
/src/Factories/Concerns/HigherOrderable.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Pest\Factories\Concerns;
 6 | 
 7 | use Pest\Support\HigherOrderMessageCollection;
 8 | 
 9 | trait HigherOrderable
10 | {
11 |     /**
12 |      * The higher order messages that are chainable.
13 |      */
14 |     public HigherOrderMessageCollection $chains;
15 | 
16 |     /**
17 |      * The higher order messages that are "factory" proxyable.
18 |      */
19 |     public HigherOrderMessageCollection $factoryProxies;
20 | 
21 |     /**
22 |      * The higher order messages that are proxyable.
23 |      */
24 |     public HigherOrderMessageCollection $proxies;
25 | 
26 |     /**
27 |      * Boot the higher order properties.
28 |      */
29 |     private function bootHigherOrderable(): void
30 |     {
31 |         $this->chains = new HigherOrderMessageCollection;
32 |         $this->factoryProxies = new HigherOrderMessageCollection;
33 |         $this->proxies = new HigherOrderMessageCollection;
34 |     }
35 | }
36 | 


--------------------------------------------------------------------------------
/src/Factories/Covers/CoversClass.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Pest\Factories\Covers;
 6 | 
 7 | /**
 8 |  * @internal
 9 |  */
10 | final class CoversClass
11 | {
12 |     public function __construct(public string $class) {}
13 | }
14 | 


--------------------------------------------------------------------------------
/src/Factories/Covers/CoversFunction.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Pest\Factories\Covers;
 6 | 
 7 | /**
 8 |  * @internal
 9 |  */
10 | final class CoversFunction
11 | {
12 |     public function __construct(public string $function) {}
13 | }
14 | 


--------------------------------------------------------------------------------
/src/Factories/Covers/CoversNothing.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Pest\Factories\Covers;
 6 | 
 7 | /**
 8 |  * @internal
 9 |  */
10 | final class CoversNothing {}
11 | 


--------------------------------------------------------------------------------
/src/KernelDump.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | declare(strict_types=1);
  4 | 
  5 | namespace Pest;
  6 | 
  7 | use Pest\Support\View;
  8 | use Symfony\Component\Console\Output\OutputInterface;
  9 | 
 10 | final class KernelDump
 11 | {
 12 |     /**
 13 |      * The output buffer, if any.
 14 |      */
 15 |     private string $buffer = '';
 16 | 
 17 |     /**
 18 |      * Creates a new Kernel Dump instance.
 19 |      */
 20 |     public function __construct(
 21 |         private readonly OutputInterface $output,
 22 |     ) {
 23 |         // ...
 24 |     }
 25 | 
 26 |     /**
 27 |      * Enable the output buffering.
 28 |      */
 29 |     public function enable(): void
 30 |     {
 31 |         ob_start(function (string $message): string {
 32 |             $this->buffer .= $message;
 33 | 
 34 |             return '';
 35 |         });
 36 |     }
 37 | 
 38 |     /**
 39 |      * Disable the output buffering.
 40 |      */
 41 |     public function disable(): void
 42 |     {
 43 |         @ob_clean();
 44 | 
 45 |         if ($this->buffer !== '') {
 46 |             $this->flush();
 47 |         }
 48 |     }
 49 | 
 50 |     /**
 51 |      * Terminate the output buffering.
 52 |      */
 53 |     public function terminate(): void
 54 |     {
 55 |         $this->disable();
 56 |     }
 57 | 
 58 |     /**
 59 |      * Flushes the buffer.
 60 |      */
 61 |     private function flush(): void
 62 |     {
 63 |         View::renderUsing($this->output);
 64 | 
 65 |         if ($this->isOpeningHeadline($this->buffer)) {
 66 |             $this->buffer = implode(PHP_EOL, array_slice(explode(PHP_EOL, $this->buffer), 2));
 67 |         }
 68 | 
 69 |         $type = 'INFO';
 70 | 
 71 |         if ($this->isInternalError($this->buffer)) {
 72 |             $type = 'ERROR';
 73 |             $this->buffer = str_replace(
 74 |                 sprintf('An error occurred inside PHPUnit.%s%sMessage:  ', PHP_EOL, PHP_EOL), '', $this->buffer,
 75 |             );
 76 |         }
 77 | 
 78 |         $this->buffer = trim($this->buffer);
 79 |         $this->buffer = rtrim($this->buffer, '.').'.';
 80 | 
 81 |         $lines = explode(PHP_EOL, $this->buffer);
 82 | 
 83 |         $lines = array_reverse($lines);
 84 |         $firstLine = array_pop($lines);
 85 |         $lines = array_reverse($lines);
 86 | 
 87 |         View::render('components.badge', [
 88 |             'type' => $type,
 89 |             'content' => $firstLine,
 90 |         ]);
 91 | 
 92 |         $this->output->writeln($lines);
 93 | 
 94 |         $this->buffer = '';
 95 |     }
 96 | 
 97 |     /**
 98 |      * Checks if the given output contains an opening headline.
 99 |      */
100 |     private function isOpeningHeadline(string $output): bool
101 |     {
102 |         return str_contains($output, 'by Sebastian Bergmann and contributors.');
103 |     }
104 | 
105 |     /**
106 |      * Checks if the given output contains an opening headline.
107 |      */
108 |     private function isInternalError(string $output): bool
109 |     {
110 |         return str_contains($output, 'An error occurred inside PHPUnit.')
111 |             || str_contains($output, 'Fatal error');
112 |     }
113 | }
114 | 


--------------------------------------------------------------------------------
/src/Logging/TeamCity/ServiceMessage.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | declare(strict_types=1);
  4 | 
  5 | namespace Pest\Logging\TeamCity;
  6 | 
  7 | /**
  8 |  * @internal
  9 |  */
 10 | final class ServiceMessage
 11 | {
 12 |     /**
 13 |      * The flow ID.
 14 |      */
 15 |     private static ?int $flowId = null;
 16 | 
 17 |     /**
 18 |      * @param  array<string, string|int|null>  $parameters
 19 |      */
 20 |     public function __construct(
 21 |         private readonly string $type,
 22 |         private readonly array $parameters,
 23 |     ) {}
 24 | 
 25 |     public function toString(): string
 26 |     {
 27 |         $paramsToString = '';
 28 | 
 29 |         foreach ([...$this->parameters, 'flowId' => self::$flowId] as $key => $value) {
 30 |             $value = $this->escapeServiceMessage((string) $value);
 31 |             $paramsToString .= " $key='$value'";
 32 |         }
 33 | 
 34 |         return "##teamcity[$this->type$paramsToString]";
 35 |     }
 36 | 
 37 |     public static function testSuiteStarted(string $name, ?string $location): self
 38 |     {
 39 |         return new self('testSuiteStarted', [
 40 |             'name' => $name,
 41 |             'locationHint' => $location === null ? null : "pest_qn://$location",
 42 |         ]);
 43 |     }
 44 | 
 45 |     public static function testSuiteCount(int $count): self
 46 |     {
 47 |         return new self('testCount', [
 48 |             'count' => $count,
 49 |         ]);
 50 |     }
 51 | 
 52 |     public static function testSuiteFinished(string $name): self
 53 |     {
 54 |         return new self('testSuiteFinished', [
 55 |             'name' => $name,
 56 |         ]);
 57 |     }
 58 | 
 59 |     public static function testStarted(string $name, string $location): self
 60 |     {
 61 |         return new self('testStarted', [
 62 |             'name' => $name,
 63 |             'locationHint' => "pest_qn://$location",
 64 |         ]);
 65 |     }
 66 | 
 67 |     /**
 68 |      * @param  int  $duration  in milliseconds
 69 |      */
 70 |     public static function testFinished(string $name, int $duration): self
 71 |     {
 72 |         return new self('testFinished', [
 73 |             'name' => $name,
 74 |             'duration' => $duration,
 75 |         ]);
 76 |     }
 77 | 
 78 |     public static function testStdOut(string $name, string $data): self
 79 |     {
 80 |         if (! str_ends_with($data, "\n")) {
 81 |             $data .= "\n";
 82 |         }
 83 | 
 84 |         return new self('testStdOut', [
 85 |             'name' => $name,
 86 |             'out' => $data,
 87 |         ]);
 88 |     }
 89 | 
 90 |     public static function testFailed(string $name, string $message, string $details): self
 91 |     {
 92 |         return new self('testFailed', [
 93 |             'name' => $name,
 94 |             'message' => $message,
 95 |             'details' => $details,
 96 |         ]);
 97 |     }
 98 | 
 99 |     public static function testStdErr(string $name, string $data): self
100 |     {
101 |         if (! str_ends_with($data, "\n")) {
102 |             $data .= "\n";
103 |         }
104 | 
105 |         return new self('testStdErr', [
106 |             'name' => $name,
107 |             'out' => $data,
108 |         ]);
109 |     }
110 | 
111 |     public static function testIgnored(string $name, string $message, ?string $details = null): self
112 |     {
113 |         return new self('testIgnored', [
114 |             'name' => $name,
115 |             'message' => $message,
116 |             'details' => $details,
117 |         ]);
118 |     }
119 | 
120 |     public static function comparisonFailure(string $name, string $message, string $details, string $actual, string $expected): self
121 |     {
122 |         return new self('testFailed', [
123 |             'name' => $name,
124 |             'message' => $message,
125 |             'details' => $details,
126 |             'type' => 'comparisonFailure',
127 |             'actual' => $actual,
128 |             'expected' => $expected,
129 |         ]);
130 |     }
131 | 
132 |     private function escapeServiceMessage(string $text): string
133 |     {
134 |         return str_replace(
135 |             ['|', "'", "\n", "\r", ']', '['],
136 |             ['||', "|'", '|n', '|r', '|]', '|['],
137 |             $text
138 |         );
139 |     }
140 | 
141 |     public static function setFlowId(int $flowId): void
142 |     {
143 |         self::$flowId = $flowId;
144 |     }
145 | }
146 | 


--------------------------------------------------------------------------------
/src/Logging/TeamCity/Subscriber/Subscriber.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Pest\Logging\TeamCity\Subscriber;
 6 | 
 7 | use Pest\Logging\TeamCity\TeamCityLogger;
 8 | 
 9 | /**
10 |  * @internal
11 |  */
12 | abstract class Subscriber // @pest-arch-ignore-line
13 | {
14 |     /**
15 |      * Creates a new Subscriber instance.
16 |      */
17 |     public function __construct(private readonly TeamCityLogger $logger) {}
18 | 
19 |     /**
20 |      * Creates a new TeamCityLogger instance.
21 |      */
22 |     final protected function logger(): TeamCityLogger // @pest-arch-ignore-line
23 |     {
24 |         return $this->logger;
25 |     }
26 | }
27 | 


--------------------------------------------------------------------------------
/src/Logging/TeamCity/Subscriber/TestConsideredRiskySubscriber.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Pest\Logging\TeamCity\Subscriber;
 6 | 
 7 | use PHPUnit\Event\Test\ConsideredRisky;
 8 | use PHPUnit\Event\Test\ConsideredRiskySubscriber;
 9 | 
10 | /**
11 |  * @internal
12 |  */
13 | final class TestConsideredRiskySubscriber extends Subscriber implements ConsideredRiskySubscriber
14 | {
15 |     public function notify(ConsideredRisky $event): void
16 |     {
17 |         $this->logger()->testConsideredRisky($event);
18 |     }
19 | }
20 | 


--------------------------------------------------------------------------------
/src/Logging/TeamCity/Subscriber/TestErroredSubscriber.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Pest\Logging\TeamCity\Subscriber;
 6 | 
 7 | use PHPUnit\Event\Test\Errored;
 8 | use PHPUnit\Event\Test\ErroredSubscriber;
 9 | 
10 | /**
11 |  * @internal
12 |  */
13 | final class TestErroredSubscriber extends Subscriber implements ErroredSubscriber
14 | {
15 |     public function notify(Errored $event): void
16 |     {
17 |         $this->logger()->testErrored($event);
18 |     }
19 | }
20 | 


--------------------------------------------------------------------------------
/src/Logging/TeamCity/Subscriber/TestExecutionFinishedSubscriber.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Pest\Logging\TeamCity\Subscriber;
 6 | 
 7 | use PHPUnit\Event\TestRunner\ExecutionFinished;
 8 | use PHPUnit\Event\TestRunner\ExecutionFinishedSubscriber;
 9 | 
10 | /**
11 |  * @internal
12 |  */
13 | final class TestExecutionFinishedSubscriber extends Subscriber implements ExecutionFinishedSubscriber
14 | {
15 |     public function notify(ExecutionFinished $event): void
16 |     {
17 |         $this->logger()->testExecutionFinished($event);
18 |     }
19 | }
20 | 


--------------------------------------------------------------------------------
/src/Logging/TeamCity/Subscriber/TestFailedSubscriber.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Pest\Logging\TeamCity\Subscriber;
 6 | 
 7 | use PHPUnit\Event\Test\Failed;
 8 | use PHPUnit\Event\Test\FailedSubscriber;
 9 | 
10 | /**
11 |  * @internal
12 |  */
13 | final class TestFailedSubscriber extends Subscriber implements FailedSubscriber
14 | {
15 |     public function notify(Failed $event): void
16 |     {
17 |         $this->logger()->testFailed($event);
18 |     }
19 | }
20 | 


--------------------------------------------------------------------------------
/src/Logging/TeamCity/Subscriber/TestFinishedSubscriber.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Pest\Logging\TeamCity\Subscriber;
 6 | 
 7 | use PHPUnit\Event\Test\Finished;
 8 | use PHPUnit\Event\Test\FinishedSubscriber;
 9 | 
10 | /**
11 |  * @internal
12 |  */
13 | final class TestFinishedSubscriber extends Subscriber implements FinishedSubscriber
14 | {
15 |     public function notify(Finished $event): void
16 |     {
17 |         $this->logger()->testFinished($event);
18 |     }
19 | }
20 | 


--------------------------------------------------------------------------------
/src/Logging/TeamCity/Subscriber/TestPreparedSubscriber.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Pest\Logging\TeamCity\Subscriber;
 6 | 
 7 | use PHPUnit\Event\Test\Prepared;
 8 | use PHPUnit\Event\Test\PreparedSubscriber;
 9 | 
10 | /**
11 |  * @internal
12 |  */
13 | final class TestPreparedSubscriber extends Subscriber implements PreparedSubscriber
14 | {
15 |     public function notify(Prepared $event): void
16 |     {
17 |         $this->logger()->testPrepared($event);
18 |     }
19 | }
20 | 


--------------------------------------------------------------------------------
/src/Logging/TeamCity/Subscriber/TestSkippedSubscriber.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Pest\Logging\TeamCity\Subscriber;
 6 | 
 7 | use PHPUnit\Event\Test\Skipped;
 8 | use PHPUnit\Event\Test\SkippedSubscriber;
 9 | 
10 | /**
11 |  * @internal
12 |  */
13 | final class TestSkippedSubscriber extends Subscriber implements SkippedSubscriber
14 | {
15 |     public function notify(Skipped $event): void
16 |     {
17 |         $this->logger()->testSkipped($event);
18 |     }
19 | }
20 | 


--------------------------------------------------------------------------------
/src/Logging/TeamCity/Subscriber/TestSuiteFinishedSubscriber.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Pest\Logging\TeamCity\Subscriber;
 6 | 
 7 | use PHPUnit\Event\TestSuite\Finished;
 8 | use PHPUnit\Event\TestSuite\FinishedSubscriber;
 9 | 
10 | /**
11 |  * @internal
12 |  */
13 | final class TestSuiteFinishedSubscriber extends Subscriber implements FinishedSubscriber
14 | {
15 |     public function notify(Finished $event): void
16 |     {
17 |         $this->logger()->testSuiteFinished($event);
18 |     }
19 | }
20 | 


--------------------------------------------------------------------------------
/src/Logging/TeamCity/Subscriber/TestSuiteStartedSubscriber.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Pest\Logging\TeamCity\Subscriber;
 6 | 
 7 | use PHPUnit\Event\TestSuite\Started;
 8 | use PHPUnit\Event\TestSuite\StartedSubscriber;
 9 | 
10 | /**
11 |  * @internal
12 |  */
13 | final class TestSuiteStartedSubscriber extends Subscriber implements StartedSubscriber
14 | {
15 |     public function notify(Started $event): void
16 |     {
17 |         $this->logger()->testSuiteStarted($event);
18 |     }
19 | }
20 | 


--------------------------------------------------------------------------------
/src/Matchers/Any.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Pest\Matchers;
 6 | 
 7 | /**
 8 |  * @internal
 9 |  */
10 | final class Any {}
11 | 


--------------------------------------------------------------------------------
/src/Panic.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Pest;
 6 | 
 7 | use NunoMaduro\Collision\Writer;
 8 | use Pest\Exceptions\TestDescriptionMissing;
 9 | use Pest\Support\Container;
10 | use Symfony\Component\Console\Output\ConsoleOutput;
11 | use Symfony\Component\Console\Output\OutputInterface;
12 | use Throwable;
13 | use Whoops\Exception\Inspector;
14 | 
15 | final readonly class Panic
16 | {
17 |     /**
18 |      * Creates a new Panic instance.
19 |      */
20 |     private function __construct(
21 |         private Throwable $throwable
22 |     ) {
23 |         // ...
24 |     }
25 | 
26 |     /**
27 |      * Creates a new Panic instance, and exits the application.
28 |      */
29 |     public static function with(Throwable $throwable): never
30 |     {
31 |         if ($throwable instanceof TestDescriptionMissing && ! is_null($previous = $throwable->getPrevious())) {
32 |             $throwable = $previous;
33 |         }
34 | 
35 |         $panic = new self($throwable);
36 | 
37 |         $panic->handle();
38 | 
39 |         exit(1);
40 |     }
41 | 
42 |     /**
43 |      * Handles the panic.
44 |      */
45 |     private function handle(): void
46 |     {
47 |         try {
48 |             $output = Container::getInstance()->get(OutputInterface::class);
49 |         } catch (Throwable) {
50 |             $output = new ConsoleOutput;
51 |         }
52 | 
53 |         assert($output instanceof OutputInterface);
54 | 
55 |         if ($this->throwable instanceof Contracts\Panicable) {
56 |             $this->throwable->render($output);
57 | 
58 |             exit($this->throwable->exitCode());
59 |         }
60 | 
61 |         $writer = new Writer(null, $output);
62 | 
63 |         $inspector = new Inspector($this->throwable);
64 | 
65 |         $writer->write($inspector);
66 |         $output->writeln('');
67 | 
68 |         exit(1);
69 |     }
70 | }
71 | 


--------------------------------------------------------------------------------
/src/PendingCalls/AfterEachCall.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Pest\PendingCalls;
 6 | 
 7 | use Closure;
 8 | use Pest\PendingCalls\Concerns\Describable;
 9 | use Pest\Support\Arr;
10 | use Pest\Support\Backtrace;
11 | use Pest\Support\ChainableClosure;
12 | use Pest\Support\HigherOrderMessageCollection;
13 | use Pest\Support\NullClosure;
14 | use Pest\TestSuite;
15 | 
16 | /**
17 |  * @internal
18 |  */
19 | final class AfterEachCall
20 | {
21 |     use Describable;
22 | 
23 |     /**
24 |      * The "afterEach" closure.
25 |      */
26 |     private readonly Closure $closure;
27 | 
28 |     /**
29 |      * The calls that should be proxied.
30 |      */
31 |     private readonly HigherOrderMessageCollection $proxies;
32 | 
33 |     /**
34 |      * Creates a new Pending Call.
35 |      */
36 |     public function __construct(
37 |         private readonly TestSuite $testSuite,
38 |         private readonly string $filename,
39 |         ?Closure $closure = null
40 |     ) {
41 |         $this->closure = $closure instanceof Closure ? $closure : NullClosure::create();
42 | 
43 |         $this->proxies = new HigherOrderMessageCollection;
44 | 
45 |         $this->describing = DescribeCall::describing();
46 |     }
47 | 
48 |     /**
49 |      * Creates the Call.
50 |      */
51 |     public function __destruct()
52 |     {
53 |         $describing = $this->describing;
54 | 
55 |         $proxies = $this->proxies;
56 | 
57 |         $afterEachTestCase = ChainableClosure::boundWhen(
58 |             fn (): bool => $describing === [] || in_array(Arr::last($describing), $this->__describing, true),
59 |             ChainableClosure::bound(fn () => $proxies->chain($this), $this->closure)->bindTo($this, self::class),
60 |         )->bindTo($this, self::class);
61 | 
62 |         assert($afterEachTestCase instanceof Closure);
63 | 
64 |         $this->testSuite->afterEach->set(
65 |             $this->filename,
66 |             $this,
67 |             $afterEachTestCase,
68 |         );
69 |     }
70 | 
71 |     /**
72 |      * Saves the calls to be used on the target.
73 |      *
74 |      * @param  array<int, mixed>  $arguments
75 |      */
76 |     public function __call(string $name, array $arguments): self
77 |     {
78 |         $this->proxies
79 |             ->add(Backtrace::file(), Backtrace::line(), $name, $arguments);
80 | 
81 |         return $this;
82 |     }
83 | }
84 | 


--------------------------------------------------------------------------------
/src/PendingCalls/BeforeEachCall.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | declare(strict_types=1);
  4 | 
  5 | namespace Pest\PendingCalls;
  6 | 
  7 | use Closure;
  8 | use Pest\Exceptions\AfterBeforeTestFunction;
  9 | use Pest\PendingCalls\Concerns\Describable;
 10 | use Pest\Support\Arr;
 11 | use Pest\Support\Backtrace;
 12 | use Pest\Support\ChainableClosure;
 13 | use Pest\Support\HigherOrderMessageCollection;
 14 | use Pest\Support\NullClosure;
 15 | use Pest\TestSuite;
 16 | 
 17 | /**
 18 |  * @internal
 19 |  *
 20 |  * @mixin TestCall
 21 |  */
 22 | final class BeforeEachCall
 23 | {
 24 |     use Describable;
 25 | 
 26 |     /**
 27 |      * Holds the before each closure.
 28 |      */
 29 |     private readonly Closure $closure;
 30 | 
 31 |     /**
 32 |      * The test call proxies.
 33 |      */
 34 |     private readonly HigherOrderMessageCollection $testCallProxies;
 35 | 
 36 |     /**
 37 |      * The test case proxies.
 38 |      */
 39 |     private readonly HigherOrderMessageCollection $testCaseProxies;
 40 | 
 41 |     /**
 42 |      * Creates a new Pending Call.
 43 |      */
 44 |     public function __construct(
 45 |         public readonly TestSuite $testSuite,
 46 |         private readonly string $filename,
 47 |         ?Closure $closure = null
 48 |     ) {
 49 |         $this->closure = $closure instanceof Closure ? $closure : NullClosure::create();
 50 | 
 51 |         $this->testCallProxies = new HigherOrderMessageCollection;
 52 |         $this->testCaseProxies = new HigherOrderMessageCollection;
 53 | 
 54 |         $this->describing = DescribeCall::describing();
 55 |     }
 56 | 
 57 |     /**
 58 |      * Creates the Call.
 59 |      */
 60 |     public function __destruct()
 61 |     {
 62 |         $describing = $this->describing;
 63 |         $testCaseProxies = $this->testCaseProxies;
 64 | 
 65 |         $beforeEachTestCall = function (TestCall $testCall) use ($describing): void {
 66 | 
 67 |             if ($this->describing !== []) {
 68 |                 if (Arr::last($describing) !== Arr::last($this->describing)) {
 69 |                     return;
 70 |                 }
 71 | 
 72 |                 if (! in_array(Arr::last($describing), $testCall->describing, true)) {
 73 |                     return;
 74 |                 }
 75 |             }
 76 | 
 77 |             $this->testCallProxies->chain($testCall);
 78 |         };
 79 | 
 80 |         $beforeEachTestCase = ChainableClosure::boundWhen(
 81 |             fn (): bool => $describing === [] || in_array(Arr::last($describing), $this->__describing, true),
 82 |             ChainableClosure::bound(fn () => $testCaseProxies->chain($this), $this->closure)->bindTo($this, self::class),
 83 |         )->bindTo($this, self::class);
 84 | 
 85 |         assert($beforeEachTestCase instanceof Closure);
 86 | 
 87 |         $this->testSuite->beforeEach->set(
 88 |             $this->filename,
 89 |             $this,
 90 |             $beforeEachTestCall,
 91 |             $beforeEachTestCase,
 92 |         );
 93 |     }
 94 | 
 95 |     /**
 96 |      * Runs the given closure after the test.
 97 |      */
 98 |     public function after(Closure $closure): self
 99 |     {
100 |         if ($this->describing === []) {
101 |             throw new AfterBeforeTestFunction($this->filename);
102 |         }
103 | 
104 |         return $this->__call('after', [$closure]);
105 |     }
106 | 
107 |     /**
108 |      * Saves the calls to be used on the target.
109 |      *
110 |      * @param  array<int, mixed>  $arguments
111 |      */
112 |     public function __call(string $name, array $arguments): self
113 |     {
114 |         if (method_exists(TestCall::class, $name)) {
115 |             $this->testCallProxies
116 |                 ->add(Backtrace::file(), Backtrace::line(), $name, $arguments);
117 | 
118 |             return $this;
119 |         }
120 | 
121 |         $this->testCaseProxies
122 |             ->add(Backtrace::file(), Backtrace::line(), $name, $arguments);
123 | 
124 |         return $this;
125 |     }
126 | }
127 | 


--------------------------------------------------------------------------------
/src/PendingCalls/Concerns/Describable.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Pest\PendingCalls\Concerns;
 6 | 
 7 | /**
 8 |  * @internal
 9 |  */
10 | trait Describable
11 | {
12 |     /**
13 |      * Note: this is property is not used; however, it gets added automatically by rector php.
14 |      *
15 |      * @var array<int, string>
16 |      */
17 |     public array $__describing;
18 | 
19 |     /**
20 |      * The describing of the test case.
21 |      *
22 |      * @var array<int, string>
23 |      */
24 |     public array $describing = [];
25 | }
26 | 


--------------------------------------------------------------------------------
/src/PendingCalls/DescribeCall.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Pest\PendingCalls;
 6 | 
 7 | use Closure;
 8 | use Pest\Support\Backtrace;
 9 | use Pest\TestSuite;
10 | 
11 | /**
12 |  * @internal
13 |  */
14 | final class DescribeCall
15 | {
16 |     /**
17 |      * The current describe call.
18 |      *
19 |      * @var array<int, string>
20 |      */
21 |     private static array $describing = [];
22 | 
23 |     /**
24 |      * The describe "before each" call.
25 |      */
26 |     private ?BeforeEachCall $currentBeforeEachCall = null;
27 | 
28 |     /**
29 |      * Creates a new Pending Call.
30 |      */
31 |     public function __construct(
32 |         public readonly TestSuite $testSuite,
33 |         public readonly string $filename,
34 |         public readonly string $description,
35 |         public readonly Closure $tests
36 |     ) {
37 |         //
38 |     }
39 | 
40 |     /**
41 |      * What is the current describing.
42 |      *
43 |      * @return array<int, string>
44 |      */
45 |     public static function describing(): array
46 |     {
47 |         return self::$describing;
48 |     }
49 | 
50 |     /**
51 |      * Creates the Call.
52 |      */
53 |     public function __destruct()
54 |     {
55 |         unset($this->currentBeforeEachCall);
56 | 
57 |         self::$describing[] = $this->description;
58 | 
59 |         try {
60 |             ($this->tests)();
61 |         } finally {
62 |             array_pop(self::$describing);
63 |         }
64 |     }
65 | 
66 |     /**
67 |      * Dynamically calls methods on each test call.
68 |      *
69 |      * @param  array<int, mixed>  $arguments
70 |      */
71 |     public function __call(string $name, array $arguments): self
72 |     {
73 |         $filename = Backtrace::file();
74 | 
75 |         if (! $this->currentBeforeEachCall instanceof \Pest\PendingCalls\BeforeEachCall) {
76 |             $this->currentBeforeEachCall = new BeforeEachCall(TestSuite::getInstance(), $filename);
77 | 
78 |             $this->currentBeforeEachCall->describing[] = $this->description;
79 |         }
80 | 
81 |         $this->currentBeforeEachCall->{$name}(...$arguments);
82 | 
83 |         return $this;
84 |     }
85 | }
86 | 


--------------------------------------------------------------------------------
/src/Pest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Pest;
 6 | 
 7 | function version(): string
 8 | {
 9 |     return '3.8.2';
10 | }
11 | 
12 | function testDirectory(string $file = ''): string
13 | {
14 |     return TestSuite::getInstance()->testPath.DIRECTORY_SEPARATOR.$file;
15 | }
16 | 


--------------------------------------------------------------------------------
/src/Plugin.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Pest;
 6 | 
 7 | final class Plugin
 8 | {
 9 |     /**
10 |      * The lazy callables to be executed once the test suite boots.
11 |      *
12 |      * @var array<int, callable>
13 |      *
14 |      * @internal
15 |      */
16 |     public static array $callables = [];
17 | 
18 |     /**
19 |      * Lazy loads an `uses` call on the context of plugins.
20 |      *
21 |      * @param  class-string  ...$traits
22 |      */
23 |     public static function uses(string ...$traits): void
24 |     {
25 |         self::$callables[] = function () use ($traits): void {
26 |             uses(...$traits)->in(TestSuite::getInstance()->rootPath);
27 |         };
28 |     }
29 | }
30 | 


--------------------------------------------------------------------------------
/src/Plugins/Actions/CallsAddsOutput.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Pest\Plugins\Actions;
 6 | 
 7 | use Pest\Contracts\Plugins;
 8 | use Pest\Plugin\Loader;
 9 | 
10 | /**
11 |  * @internal
12 |  */
13 | final class CallsAddsOutput
14 | {
15 |     /**
16 |      * Executes the Plugin action.
17 |      *
18 |      * Provides an opportunity for any plugins that want to provide additional output after test execution.
19 |      */
20 |     public static function execute(int $exitCode): int
21 |     {
22 |         $plugins = Loader::getPlugins(Plugins\AddsOutput::class);
23 | 
24 |         /** @var Plugins\AddsOutput $plugin */
25 |         foreach ($plugins as $plugin) {
26 |             $exitCode = $plugin->addOutput($exitCode);
27 |         }
28 | 
29 |         return $exitCode;
30 |     }
31 | }
32 | 


--------------------------------------------------------------------------------
/src/Plugins/Actions/CallsBoot.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Pest\Plugins\Actions;
 6 | 
 7 | use Pest\Contracts\Plugins;
 8 | use Pest\Plugin\Loader;
 9 | 
10 | /**
11 |  * @internal
12 |  */
13 | final class CallsBoot
14 | {
15 |     /**
16 |      * Executes the Plugin action.
17 |      *
18 |      * Provides an opportunity for any plugins to boot.
19 |      */
20 |     public static function execute(): void
21 |     {
22 |         $plugins = Loader::getPlugins(Plugins\Bootable::class);
23 | 
24 |         /** @var Plugins\Bootable $plugin */
25 |         foreach ($plugins as $plugin) {
26 |             $plugin->boot();
27 |         }
28 |     }
29 | }
30 | 


--------------------------------------------------------------------------------
/src/Plugins/Actions/CallsHandleArguments.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Pest\Plugins\Actions;
 6 | 
 7 | use Pest\Contracts\Plugins;
 8 | use Pest\Plugin\Loader;
 9 | 
10 | /**
11 |  * @internal
12 |  */
13 | final class CallsHandleArguments
14 | {
15 |     /**
16 |      * Executes the Plugin action.
17 |      *
18 |      * Transform the input arguments by passing it to the relevant plugins.
19 |      *
20 |      * @param  array<int, string>  $argv
21 |      * @return array<int, string>
22 |      */
23 |     public static function execute(array $argv): array
24 |     {
25 |         $plugins = Loader::getPlugins(Plugins\HandlesArguments::class);
26 | 
27 |         /** @var Plugins\HandlesArguments $plugin */
28 |         foreach ($plugins as $plugin) {
29 |             $argv = $plugin->handleArguments($argv);
30 |         }
31 | 
32 |         return $argv;
33 |     }
34 | }
35 | 


--------------------------------------------------------------------------------
/src/Plugins/Actions/CallsHandleOriginalArguments.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Pest\Plugins\Actions;
 6 | 
 7 | use Pest\Contracts\Plugins;
 8 | use Pest\Plugin\Loader;
 9 | 
10 | /**
11 |  * @internal
12 |  */
13 | final class CallsHandleOriginalArguments
14 | {
15 |     /**
16 |      * Executes the Plugin action.
17 |      *
18 |      * Transform the input arguments by passing it to the relevant plugins.
19 |      *
20 |      * @param  array<int, string>  $argv
21 |      */
22 |     public static function execute(array $argv): void
23 |     {
24 |         $plugins = Loader::getPlugins(Plugins\HandlesOriginalArguments::class);
25 | 
26 |         /** @var Plugins\HandlesOriginalArguments $plugin */
27 |         foreach ($plugins as $plugin) {
28 |             $plugin->handleOriginalArguments($argv);
29 |         }
30 |     }
31 | }
32 | 


--------------------------------------------------------------------------------
/src/Plugins/Actions/CallsTerminable.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Pest\Plugins\Actions;
 6 | 
 7 | use Pest\Contracts\Plugins;
 8 | use Pest\Plugin\Loader;
 9 | 
10 | /**
11 |  * @internal
12 |  */
13 | final class CallsTerminable
14 | {
15 |     /**
16 |      * Executes the Plugin action.
17 |      *
18 |      * Provides an opportunity for any plugins to terminate.
19 |      */
20 |     public static function execute(): void
21 |     {
22 |         $plugins = Loader::getPlugins(Plugins\Terminable::class);
23 | 
24 |         /** @var Plugins\Terminable $plugin */
25 |         foreach ($plugins as $plugin) {
26 |             $plugin->terminate();
27 |         }
28 |     }
29 | }
30 | 


--------------------------------------------------------------------------------
/src/Plugins/Bail.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Pest\Plugins;
 6 | 
 7 | use Pest\Contracts\Plugins\HandlesArguments;
 8 | use Pest\Plugins\Concerns\HandleArguments;
 9 | 
10 | /**
11 |  * @internal
12 |  */
13 | final class Bail implements HandlesArguments
14 | {
15 |     use HandleArguments;
16 | 
17 |     /**
18 |      * Handles the arguments, adding the `--stop-on-defect` when the `--bail` argument is present.
19 |      */
20 |     public function handleArguments(array $arguments): array
21 |     {
22 |         if ($this->hasArgument('--bail', $arguments)) {
23 |             $arguments = $this->popArgument('--bail', $arguments);
24 | 
25 |             $arguments = $this->pushArgument('--stop-on-failure', $arguments);
26 |             $arguments = $this->pushArgument('--stop-on-error', $arguments);
27 |         }
28 | 
29 |         return $arguments;
30 |     }
31 | }
32 | 


--------------------------------------------------------------------------------
/src/Plugins/Cache.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Pest\Plugins;
 6 | 
 7 | use Pest\Contracts\Plugins\HandlesArguments;
 8 | use Pest\Plugins\Concerns\HandleArguments;
 9 | use PHPUnit\TextUI\CliArguments\Builder as CliConfigurationBuilder;
10 | use PHPUnit\TextUI\CliArguments\XmlConfigurationFileFinder;
11 | use PHPUnit\TextUI\XmlConfiguration\DefaultConfiguration;
12 | use PHPUnit\TextUI\XmlConfiguration\Loader;
13 | 
14 | /**
15 |  * @internal
16 |  */
17 | final class Cache implements HandlesArguments
18 | {
19 |     use HandleArguments;
20 | 
21 |     /**
22 |      * The temporary folder.
23 |      */
24 |     private const TEMPORARY_FOLDER = __DIR__
25 |         .DIRECTORY_SEPARATOR
26 |         .'..'
27 |         .DIRECTORY_SEPARATOR
28 |         .'..'
29 |         .DIRECTORY_SEPARATOR
30 |         .'.temp';
31 | 
32 |     /**
33 |      * Handles the arguments, adding the cache directory and the cache result arguments.
34 |      */
35 |     public function handleArguments(array $arguments): array
36 |     {
37 |         if (! $this->hasArgument('--cache-directory', $arguments)) {
38 | 
39 |             $cliConfiguration = (new CliConfigurationBuilder)->fromParameters([]);
40 |             $configurationFile = (new XmlConfigurationFileFinder)->find($cliConfiguration);
41 |             $xmlConfiguration = DefaultConfiguration::create();
42 | 
43 |             if (is_string($configurationFile)) {
44 |                 $xmlConfiguration = (new Loader)->load($configurationFile);
45 |             }
46 | 
47 |             if (! $xmlConfiguration->phpunit()->hasCacheDirectory()) {
48 |                 $arguments = $this->pushArgument('--cache-directory', $arguments);
49 |                 $arguments = $this->pushArgument((string) realpath(self::TEMPORARY_FOLDER), $arguments);
50 |             }
51 |         }
52 | 
53 |         if (! $this->hasArgument('--parallel', $arguments)) {
54 |             return $this->pushArgument('--cache-result', $arguments);
55 |         }
56 | 
57 |         return $arguments;
58 |     }
59 | }
60 | 


--------------------------------------------------------------------------------
/src/Plugins/Concerns/HandleArguments.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Pest\Plugins\Concerns;
 6 | 
 7 | /**
 8 |  * @internal
 9 |  */
10 | trait HandleArguments
11 | {
12 |     /**
13 |      * Checks if the given argument exists on the arguments.
14 |      *
15 |      * @param  array<int, string>  $arguments
16 |      */
17 |     public function hasArgument(string $argument, array $arguments): bool
18 |     {
19 |         foreach ($arguments as $arg) {
20 |             if ($arg === $argument) {
21 |                 return true;
22 |             }
23 | 
24 |             if (str_starts_with((string) $arg, "$argument=")) { // @phpstan-ignore-line
25 |                 return true;
26 |             }
27 |         }
28 | 
29 |         return false;
30 |     }
31 | 
32 |     /**
33 |      * Adds the given argument and value to the list of arguments.
34 |      *
35 |      * @param  array<int, string>  $arguments
36 |      * @return array<int, string>
37 |      */
38 |     public function pushArgument(string $argument, array $arguments): array
39 |     {
40 |         $arguments[] = $argument;
41 | 
42 |         return $arguments;
43 |     }
44 | 
45 |     /**
46 |      * Pops the given argument from the arguments.
47 |      *
48 |      * @param  array<int, string>  $arguments
49 |      * @return array<int, string>
50 |      */
51 |     public function popArgument(string $argument, array $arguments): array
52 |     {
53 |         $arguments = array_flip($arguments);
54 | 
55 |         unset($arguments[$argument]);
56 | 
57 |         return array_values(array_flip($arguments));
58 |     }
59 | }
60 | 


--------------------------------------------------------------------------------
/src/Plugins/Configuration.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Pest\Plugins;
 6 | 
 7 | use DOMDocument;
 8 | use Pest\Contracts\Plugins\HandlesArguments;
 9 | use Pest\Contracts\Plugins\Terminable;
10 | use Pest\Plugins\Concerns\HandleArguments;
11 | use PHPUnit\TextUI\CliArguments\Builder as CliConfigurationBuilder;
12 | use PHPUnit\TextUI\CliArguments\XmlConfigurationFileFinder;
13 | 
14 | /**
15 |  * @internal
16 |  */
17 | final class Configuration implements HandlesArguments, Terminable
18 | {
19 |     use HandleArguments;
20 | 
21 |     /**
22 |      * The base PHPUnit file.
23 |      */
24 |     public const BASE_PHPUNIT_FILE = __DIR__
25 |         .DIRECTORY_SEPARATOR
26 |         .'..'
27 |         .DIRECTORY_SEPARATOR
28 |         .'..'
29 |         .DIRECTORY_SEPARATOR
30 |         .'resources/base-phpunit.xml';
31 | 
32 |     /**
33 |      * Handles the arguments, adding the cache directory and the cache result arguments.
34 |      */
35 |     public function handleArguments(array $arguments): array
36 |     {
37 |         if ($this->hasArgument('--configuration', $arguments) || $this->hasCustomConfigurationFile()) {
38 |             return $arguments;
39 |         }
40 | 
41 |         $arguments = $this->pushArgument('--configuration', $arguments);
42 | 
43 |         return $this->pushArgument((string) realpath($this->fromGeneratedConfigurationFile()), $arguments);
44 |     }
45 | 
46 |     /**
47 |      * Get the configuration file from the generated configuration file.
48 |      */
49 |     private function fromGeneratedConfigurationFile(): string
50 |     {
51 |         $path = $this->getTempPhpunitXmlPath();
52 |         if (file_exists($path)) {
53 |             unlink($path);
54 |         }
55 | 
56 |         $doc = new DOMDocument;
57 |         $doc->load(self::BASE_PHPUNIT_FILE);
58 | 
59 |         $contents = $doc->saveXML();
60 | 
61 |         assert(is_int(file_put_contents($path, $contents)));
62 | 
63 |         return $path;
64 |     }
65 | 
66 |     /**
67 |      * Check if the configuration file is custom.
68 |      */
69 |     private function hasCustomConfigurationFile(): bool
70 |     {
71 |         $cliConfiguration = (new CliConfigurationBuilder)->fromParameters([]);
72 |         $configurationFile = (new XmlConfigurationFileFinder)->find($cliConfiguration);
73 | 
74 |         return is_string($configurationFile);
75 |     }
76 | 
77 |     /**
78 |      * Get the temporary phpunit.xml path.
79 |      */
80 |     private function getTempPhpunitXmlPath(): string
81 |     {
82 |         return getcwd().'/.pest.xml';
83 |     }
84 | 
85 |     /**
86 |      * Terminates the plugin.
87 |      */
88 |     public function terminate(): void
89 |     {
90 |         $path = $this->getTempPhpunitXmlPath();
91 | 
92 |         if (file_exists($path)) {
93 |             unlink($path);
94 |         }
95 |     }
96 | }
97 | 


--------------------------------------------------------------------------------
/src/Plugins/Environment.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Pest\Plugins;
 6 | 
 7 | use Pest\Contracts\Plugins\HandlesArguments;
 8 | 
 9 | /**
10 |  * @internal
11 |  */
12 | final class Environment implements HandlesArguments
13 | {
14 |     /**
15 |      * The continuous integration environment.
16 |      */
17 |     public const CI = 'ci';
18 | 
19 |     /**
20 |      * The local environment.
21 |      */
22 |     public const LOCAL = 'local';
23 | 
24 |     /**
25 |      * The current environment.
26 |      */
27 |     private static ?string $name = null;
28 | 
29 |     /**
30 |      * {@inheritdoc}
31 |      */
32 |     public function handleArguments(array $arguments): array
33 |     {
34 |         foreach ($arguments as $index => $argument) {
35 |             if ($argument === '--ci') {
36 |                 unset($arguments[$index]);
37 | 
38 |                 self::$name = self::CI;
39 |             }
40 |         }
41 | 
42 |         return array_values($arguments);
43 |     }
44 | 
45 |     /**
46 |      * Gets the environment name.
47 |      */
48 |     public static function name(?string $name = null): string
49 |     {
50 |         if (is_string($name)) {
51 |             self::$name = $name;
52 |         }
53 | 
54 |         return self::$name ?? self::LOCAL;
55 |     }
56 | }
57 | 


--------------------------------------------------------------------------------
/src/Plugins/Init.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | declare(strict_types=1);
  4 | 
  5 | namespace Pest\Plugins;
  6 | 
  7 | use Composer\InstalledVersions;
  8 | use Pest\Console\Thanks;
  9 | use Pest\Contracts\Plugins\HandlesArguments;
 10 | use Pest\Support\View;
 11 | use Pest\TestSuite;
 12 | use Symfony\Component\Console\Input\InputInterface;
 13 | use Symfony\Component\Console\Output\OutputInterface;
 14 | 
 15 | /**
 16 |  * @internal
 17 |  */
 18 | final readonly class Init implements HandlesArguments
 19 | {
 20 |     /**
 21 |      * The option the triggers the init job.
 22 |      */
 23 |     private const INIT_OPTION = '--init';
 24 | 
 25 |     /**
 26 |      * The files that will be created.
 27 |      */
 28 |     private const STUBS = [
 29 |         'phpunit.xml.stub' => 'phpunit.xml',
 30 |         'Pest.php.stub' => 'tests/Pest.php',
 31 |         'TestCase.php.stub' => 'tests/TestCase.php',
 32 |         'Unit/ExampleTest.php.stub' => 'tests/Unit/ExampleTest.php',
 33 |         'Feature/ExampleTest.php.stub' => 'tests/Feature/ExampleTest.php',
 34 |     ];
 35 | 
 36 |     /**
 37 |      * Creates a new Plugin instance.
 38 |      */
 39 |     public function __construct(
 40 |         private TestSuite $testSuite,
 41 |         private InputInterface $input,
 42 |         private OutputInterface $output
 43 |     ) {
 44 |         // ..
 45 |     }
 46 | 
 47 |     /**
 48 |      * {@inheritdoc}
 49 |      */
 50 |     public function handleArguments(array $arguments): array
 51 |     {
 52 |         if (! array_key_exists(1, $arguments)) {
 53 |             return $arguments;
 54 |         }
 55 |         if ($arguments[1] !== self::INIT_OPTION) {
 56 |             return $arguments;
 57 |         }
 58 | 
 59 |         unset($arguments[1]);
 60 | 
 61 |         $this->init();
 62 | 
 63 |         exit(0);
 64 |     }
 65 | 
 66 |     /**
 67 |      * Initializes the tests directory.
 68 |      */
 69 |     public function init(): void
 70 |     {
 71 |         $testsBaseDir = "{$this->testSuite->rootPath}/tests";
 72 | 
 73 |         if (! is_dir($testsBaseDir)) {
 74 |             mkdir($testsBaseDir);
 75 |         }
 76 | 
 77 |         View::render('components.badge', [
 78 |             'type' => 'INFO',
 79 |             'content' => 'Preparing tests directory.',
 80 |         ]);
 81 | 
 82 |         foreach (self::STUBS as $from => $to) {
 83 |             if ($this->isLaravelInstalled()) {
 84 |                 $fromPath = __DIR__."/../../stubs/init-laravel/{$from}";
 85 |             } else {
 86 |                 $fromPath = __DIR__."/../../stubs/init/{$from}";
 87 |             }
 88 | 
 89 |             $toPath = "{$this->testSuite->rootPath}/{$to}";
 90 | 
 91 |             if (file_exists($toPath)) {
 92 |                 View::render('components.two-column-detail', [
 93 |                     'left' => $to,
 94 |                     'right' => 'File already exists.',
 95 |                 ]);
 96 | 
 97 |                 continue;
 98 |             }
 99 | 
100 |             if (! is_dir(dirname($toPath))) {
101 |                 mkdir(dirname($toPath));
102 |             }
103 | 
104 |             copy($fromPath, $toPath);
105 | 
106 |             View::render('components.two-column-detail', [
107 |                 'left' => $to,
108 |                 'right' => 'File created.',
109 |             ]);
110 |         }
111 | 
112 |         View::render('components.new-line');
113 | 
114 |         (new Thanks($this->input, $this->output))();
115 |     }
116 | 
117 |     /**
118 |      * Checks if laravel is installed through Composer
119 |      */
120 |     private function isLaravelInstalled(): bool
121 |     {
122 |         return InstalledVersions::isInstalled('laravel/framework');
123 |     }
124 | }
125 | 


--------------------------------------------------------------------------------
/src/Plugins/Memory.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Pest\Plugins;
 6 | 
 7 | use Pest\Contracts\Plugins\AddsOutput;
 8 | use Pest\Contracts\Plugins\HandlesArguments;
 9 | use Symfony\Component\Console\Output\OutputInterface;
10 | 
11 | /**
12 |  * @internal
13 |  */
14 | final class Memory implements AddsOutput, HandlesArguments
15 | {
16 |     use Concerns\HandleArguments;
17 | 
18 |     /**
19 |      * If memory should be displayed.
20 |      */
21 |     private bool $enabled = false;
22 | 
23 |     /**
24 |      * Creates a new Plugin instance.
25 |      */
26 |     public function __construct(
27 |         private readonly OutputInterface $output
28 |     ) {
29 |         // ..
30 |     }
31 | 
32 |     /**
33 |      * {@inheritdoc}
34 |      */
35 |     public function handleArguments(array $arguments): array
36 |     {
37 |         $this->enabled = $this->hasArgument('--memory', $arguments);
38 | 
39 |         return $this->popArgument('--memory', $arguments);
40 |     }
41 | 
42 |     /**
43 |      * {@inheritdoc}
44 |      */
45 |     public function addOutput(int $exitCode): int
46 |     {
47 |         if ($this->enabled) {
48 |             $this->output->writeln(sprintf(
49 |                 '  <fg=gray>Memory:</>   <fg=default>%s MB</>',
50 |                 round(memory_get_usage(true) / 1000 ** 2, 3)
51 |             ));
52 |         }
53 | 
54 |         return $exitCode;
55 |     }
56 | }
57 | 


--------------------------------------------------------------------------------
/src/Plugins/Only.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Pest\Plugins;
 6 | 
 7 | use Pest\Contracts\Plugins\Terminable;
 8 | use Pest\PendingCalls\TestCall;
 9 | 
10 | /**
11 |  * @internal
12 |  */
13 | final class Only implements Terminable
14 | {
15 |     /**
16 |      * The temporary folder.
17 |      */
18 |     private const TEMPORARY_FOLDER = __DIR__
19 |         .DIRECTORY_SEPARATOR
20 |         .'..'
21 |         .DIRECTORY_SEPARATOR
22 |         .'..'
23 |         .DIRECTORY_SEPARATOR
24 |         .'.temp';
25 | 
26 |     /**
27 |      * {@inheritDoc}
28 |      */
29 |     public function terminate(): void
30 |     {
31 |         if (Parallel::isWorker()) {
32 |             return;
33 |         }
34 | 
35 |         $lockFile = self::TEMPORARY_FOLDER.DIRECTORY_SEPARATOR.'only.lock';
36 | 
37 |         if (file_exists($lockFile)) {
38 |             unlink($lockFile);
39 |         }
40 |     }
41 | 
42 |     /**
43 |      * Creates the lock file.
44 |      */
45 |     public static function enable(TestCall $testCall, string $group = '__pest_only'): void
46 |     {
47 |         $testCall->group($group);
48 | 
49 |         if (Environment::name() === Environment::CI || Parallel::isWorker()) {
50 |             return;
51 |         }
52 | 
53 |         $lockFile = self::TEMPORARY_FOLDER.DIRECTORY_SEPARATOR.'only.lock';
54 | 
55 |         if (file_exists($lockFile) && $group === '__pest_only') {
56 |             file_put_contents($lockFile, $group);
57 | 
58 |             return;
59 |         }
60 | 
61 |         if (! file_exists($lockFile)) {
62 |             touch($lockFile);
63 | 
64 |             file_put_contents($lockFile, $group);
65 |         }
66 |     }
67 | 
68 |     /**
69 |      * Checks if "only" mode is enabled.
70 |      */
71 |     public static function isEnabled(): bool
72 |     {
73 |         $lockFile = self::TEMPORARY_FOLDER.DIRECTORY_SEPARATOR.'only.lock';
74 | 
75 |         return file_exists($lockFile);
76 |     }
77 | 
78 |     /**
79 |      * Returns the group name.
80 |      */
81 |     public static function group(): string
82 |     {
83 |         $lockFile = self::TEMPORARY_FOLDER.DIRECTORY_SEPARATOR.'only.lock';
84 | 
85 |         if (! file_exists($lockFile)) {
86 |             return '__pest_only';
87 |         }
88 | 
89 |         return file_get_contents($lockFile) ?: '__pest_only'; // @phpstan-ignore-line
90 |     }
91 | }
92 | 


--------------------------------------------------------------------------------
/src/Plugins/Parallel/Contracts/HandlersWorkerArguments.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Pest\Plugins\Parallel\Contracts;
 6 | 
 7 | interface HandlersWorkerArguments
 8 | {
 9 |     /**
10 |      * @param  array<int, string>  $arguments
11 |      * @return array<int, string>
12 |      */
13 |     public function handleWorkerArguments(array $arguments): array;
14 | }
15 | 


--------------------------------------------------------------------------------
/src/Plugins/Parallel/Handlers/Laravel.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | declare(strict_types=1);
  4 | 
  5 | namespace Pest\Plugins\Parallel\Handlers;
  6 | 
  7 | use Closure;
  8 | use Composer\InstalledVersions;
  9 | use Illuminate\Testing\ParallelRunner;
 10 | use ParaTest\Options;
 11 | use ParaTest\RunnerInterface;
 12 | use Pest\Contracts\Plugins\HandlesArguments;
 13 | use Pest\Plugins\Concerns\HandleArguments;
 14 | use Pest\Plugins\Parallel\Paratest\WrapperRunner;
 15 | use Symfony\Component\Console\Output\OutputInterface;
 16 | 
 17 | /**
 18 |  * @internal
 19 |  */
 20 | final class Laravel implements HandlesArguments
 21 | {
 22 |     use HandleArguments;
 23 | 
 24 |     /**
 25 |      * {@inheritdoc}
 26 |      */
 27 |     public function handleArguments(array $arguments): array
 28 |     {
 29 |         return $this->whenUsingLaravel($arguments, function (array $arguments): array {
 30 |             $this->ensureRunnerIsResolvable();
 31 | 
 32 |             $arguments = $this->ensureEnvironmentVariables($arguments);
 33 | 
 34 |             return $this->ensureRunner($arguments);
 35 |         });
 36 |     }
 37 | 
 38 |     /**
 39 |      * Executes the given closure when running Laravel.
 40 |      *
 41 |      * @param  array<int, string>  $arguments
 42 |      * @param  CLosure(array<int, string>): array<int, string>  $closure
 43 |      * @return array<int, string>
 44 |      */
 45 |     private function whenUsingLaravel(array $arguments, Closure $closure): array
 46 |     {
 47 |         $isLaravelApplication = InstalledVersions::isInstalled('laravel/framework', false);
 48 |         $isLaravelPackage = class_exists(\Orchestra\Testbench\TestCase::class);
 49 | 
 50 |         if ($isLaravelApplication && ! $isLaravelPackage) {
 51 |             return $closure($arguments);
 52 |         }
 53 | 
 54 |         return $arguments;
 55 |     }
 56 | 
 57 |     /**
 58 |      * Ensures the runner is resolvable.
 59 |      */
 60 |     private function ensureRunnerIsResolvable(): void
 61 |     {
 62 |         ParallelRunner::resolveRunnerUsing( // @phpstan-ignore-line
 63 |             fn (Options $options, OutputInterface $output): RunnerInterface => new WrapperRunner($options, $output)
 64 |         );
 65 |     }
 66 | 
 67 |     /**
 68 |      * Ensures the environment variables are set.
 69 |      *
 70 |      * @param  array<int, string>  $arguments
 71 |      * @return array<int, string>
 72 |      */
 73 |     private function ensureEnvironmentVariables(array $arguments): array
 74 |     {
 75 |         $_ENV['LARAVEL_PARALLEL_TESTING'] = 1;
 76 | 
 77 |         if ($this->hasArgument('--recreate-databases', $arguments)) {
 78 |             $_ENV['LARAVEL_PARALLEL_TESTING_RECREATE_DATABASES'] = 1;
 79 |         }
 80 | 
 81 |         if ($this->hasArgument('--drop-databases', $arguments)) {
 82 |             $_ENV['LARAVEL_PARALLEL_TESTING_DROP_DATABASES'] = 1;
 83 |         }
 84 | 
 85 |         $arguments = $this->popArgument('--recreate-databases', $arguments);
 86 | 
 87 |         return $this->popArgument('--drop-databases', $arguments);
 88 |     }
 89 | 
 90 |     /**
 91 |      * Ensure the runner is set.
 92 |      *
 93 |      * @param  array<int, string>  $arguments
 94 |      * @return array<int, string>
 95 |      */
 96 |     private function ensureRunner(array $arguments): array
 97 |     {
 98 |         foreach ($arguments as $value) {
 99 |             if (str_starts_with($value, '--runner')) {
100 |                 $arguments = $this->popArgument($value, $arguments);
101 |             }
102 |         }
103 | 
104 |         return $this->pushArgument('--runner=\Illuminate\Testing\ParallelRunner', $arguments);
105 |     }
106 | }
107 | 


--------------------------------------------------------------------------------
/src/Plugins/Parallel/Handlers/Parallel.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Pest\Plugins\Parallel\Handlers;
 6 | 
 7 | use Pest\Contracts\Plugins\HandlesArguments;
 8 | use Pest\Plugins\Concerns\HandleArguments;
 9 | use Pest\Plugins\Parallel\Paratest\WrapperRunner;
10 | 
11 | /**
12 |  * @internal
13 |  */
14 | final class Parallel implements HandlesArguments
15 | {
16 |     use HandleArguments;
17 | 
18 |     /**
19 |      * The list of arguments to remove.
20 |      */
21 |     private const ARGS_TO_REMOVE = [
22 |         '--parallel',
23 |         '-p',
24 |         '--no-output',
25 |         '--cache-result',
26 |     ];
27 | 
28 |     /**
29 |      * Handles the arguments, removing the ones that are not needed, and adds the "runner" argument.
30 |      */
31 |     public function handleArguments(array $arguments): array
32 |     {
33 |         $args = array_reduce(self::ARGS_TO_REMOVE, fn (array $args, string $arg): array => $this->popArgument($arg, $args), $arguments);
34 | 
35 |         return $this->pushArgument('--runner='.WrapperRunner::class, $args);
36 |     }
37 | }
38 | 


--------------------------------------------------------------------------------
/src/Plugins/Parallel/Handlers/Pest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Pest\Plugins\Parallel\Handlers;
 6 | 
 7 | use Pest\Plugins\Concerns\HandleArguments;
 8 | use Pest\Plugins\Parallel\Contracts\HandlersWorkerArguments;
 9 | 
10 | final class Pest implements HandlersWorkerArguments
11 | {
12 |     use HandleArguments;
13 | 
14 |     /**
15 |      * Handles the arguments, adding the "PEST_PARALLEL" environment variable to the global $_SERVER.
16 |      */
17 |     public function handleWorkerArguments(array $arguments): array
18 |     {
19 |         $_SERVER['PEST_PARALLEL'] = '1';
20 | 
21 |         return $arguments;
22 |     }
23 | }
24 | 


--------------------------------------------------------------------------------
/src/Plugins/Parallel/Paratest/CleanConsoleOutput.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Pest\Plugins\Parallel\Paratest;
 6 | 
 7 | use Symfony\Component\Console\Output\ConsoleOutput;
 8 | 
 9 | final class CleanConsoleOutput extends ConsoleOutput
10 | {
11 |     /**
12 |      * {@inheritdoc}
13 |      */
14 |     protected function doWrite(string $message, bool $newline): void // @pest-arch-ignore-line
15 |     {
16 |         if ($this->isOpeningHeadline($message)) {
17 |             return;
18 |         }
19 | 
20 |         parent::doWrite($message, $newline);
21 |     }
22 | 
23 |     /**
24 |      * Removes the opening headline, witch is not needed.
25 |      */
26 |     private function isOpeningHeadline(string $message): bool
27 |     {
28 |         return str_contains($message, 'by Sebastian Bergmann and contributors.');
29 |     }
30 | }
31 | 


--------------------------------------------------------------------------------
/src/Plugins/Printer.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Pest\Plugins;
 6 | 
 7 | use Pest\Contracts\Plugins\HandlesArguments;
 8 | 
 9 | /**
10 |  * @internal
11 |  */
12 | final class Printer implements HandlesArguments
13 | {
14 |     use Concerns\HandleArguments;
15 | 
16 |     /**
17 |      * {@inheritDoc}
18 |      */
19 |     public function handleArguments(array $arguments): array
20 |     {
21 |         if (! array_key_exists('COLLISION_PRINTER', $_SERVER)) {
22 |             return $arguments;
23 |         }
24 | 
25 |         if (in_array('--no-output', $arguments, true)) {
26 |             return $arguments;
27 |         }
28 | 
29 |         return $this->pushArgument('--no-output', $arguments);
30 |     }
31 | }
32 | 


--------------------------------------------------------------------------------
/src/Plugins/ProcessIsolation.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Pest\Plugins;
 6 | 
 7 | use Pest\Contracts\Plugins\HandlesArguments;
 8 | use Pest\Exceptions\InvalidOption;
 9 | 
10 | /**
11 |  * @internal
12 |  */
13 | final class ProcessIsolation implements HandlesArguments
14 | {
15 |     use Concerns\HandleArguments;
16 | 
17 |     /**
18 |      * {@inheritDoc}
19 |      */
20 |     public function handleArguments(array $arguments): array
21 |     {
22 |         if ($this->hasArgument('--process-isolation', $arguments)) {
23 |             throw new InvalidOption('The [--process-isolation] option is not supported.');
24 |         }
25 | 
26 |         return $arguments;
27 |     }
28 | }
29 | 


--------------------------------------------------------------------------------
/src/Plugins/Profile.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Pest\Plugins;
 6 | 
 7 | use Pest\Contracts\Plugins\HandlesArguments;
 8 | use Pest\Exceptions\InvalidOption;
 9 | 
10 | /**
11 |  * @internal
12 |  */
13 | final class Profile implements HandlesArguments
14 | {
15 |     use Concerns\HandleArguments;
16 | 
17 |     /**
18 |      * {@inheritDoc}
19 |      */
20 |     public function handleArguments(array $arguments): array
21 |     {
22 |         if (! $this->hasArgument('--profile', $arguments)) {
23 |             return $arguments;
24 |         }
25 | 
26 |         if ($this->hasArgument('--parallel', $arguments)) {
27 |             throw new InvalidOption('The [--profile] option is not supported when running in parallel.');
28 |         }
29 | 
30 |         return $arguments;
31 |     }
32 | }
33 | 


--------------------------------------------------------------------------------
/src/Plugins/Retry.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Pest\Plugins;
 6 | 
 7 | use Pest\Contracts\Plugins\HandlesArguments;
 8 | use Pest\Exceptions\InvalidOption;
 9 | 
10 | /**
11 |  * @internal
12 |  */
13 | final class Retry implements HandlesArguments
14 | {
15 |     use Concerns\HandleArguments;
16 | 
17 |     /**
18 |      * {@inheritDoc}
19 |      */
20 |     public function handleArguments(array $arguments): array
21 |     {
22 |         if (! $this->hasArgument('--retry', $arguments)) {
23 |             return $arguments;
24 |         }
25 | 
26 |         if ($this->hasArgument('--parallel', $arguments)) {
27 |             throw new InvalidOption('The [--retry] option is not supported when running in parallel.');
28 |         }
29 | 
30 |         $arguments = $this->popArgument('--retry', $arguments);
31 | 
32 |         $arguments = $this->pushArgument('--order-by=defects', $arguments);
33 | 
34 |         return $this->pushArgument('--stop-on-failure', $arguments);
35 |     }
36 | }
37 | 


--------------------------------------------------------------------------------
/src/Plugins/Snapshot.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Pest\Plugins;
 6 | 
 7 | use Pest\Contracts\Plugins\HandlesArguments;
 8 | use Pest\Exceptions\InvalidOption;
 9 | use Pest\TestSuite;
10 | 
11 | /**
12 |  * @internal
13 |  */
14 | final class Snapshot implements HandlesArguments
15 | {
16 |     use Concerns\HandleArguments;
17 | 
18 |     /**
19 |      * {@inheritDoc}
20 |      */
21 |     public function handleArguments(array $arguments): array
22 |     {
23 |         if (! $this->hasArgument('--update-snapshots', $arguments)) {
24 |             return $arguments;
25 |         }
26 | 
27 |         if ($this->hasArgument('--parallel', $arguments)) {
28 |             throw new InvalidOption('The [--update-snapshots] option is not supported when running in parallel.');
29 |         }
30 | 
31 |         TestSuite::getInstance()->snapshots->flush();
32 | 
33 |         return $this->popArgument('--update-snapshots', $arguments);
34 |     }
35 | }
36 | 


--------------------------------------------------------------------------------
/src/Plugins/Verbose.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Pest\Plugins;
 6 | 
 7 | use Pest\Contracts\Plugins\HandlesArguments;
 8 | 
 9 | /**
10 |  * @internal
11 |  */
12 | final class Verbose implements HandlesArguments
13 | {
14 |     use Concerns\HandleArguments;
15 | 
16 |     /**
17 |      * The list of verbosity levels.
18 |      */
19 |     private const VERBOSITY_LEVELS = ['v', 'vv', 'vvv', 'q'];
20 | 
21 |     /**
22 |      * {@inheritDoc}
23 |      */
24 |     public function handleArguments(array $arguments): array
25 |     {
26 |         foreach (self::VERBOSITY_LEVELS as $level) {
27 |             if ($this->hasArgument('-'.$level, $arguments)) {
28 |                 $arguments = $this->popArgument('-'.$level, $arguments);
29 |             }
30 |         }
31 | 
32 |         if ($this->hasArgument('--quiet', $arguments)) {
33 |             return $this->popArgument('--quiet', $arguments);
34 |         }
35 | 
36 |         return $arguments;
37 |     }
38 | }
39 | 


--------------------------------------------------------------------------------
/src/Plugins/Version.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Pest\Plugins;
 6 | 
 7 | use Pest\Contracts\Plugins\HandlesArguments;
 8 | use Pest\Support\View;
 9 | 
10 | use function Pest\version;
11 | 
12 | /**
13 |  * @internal
14 |  */
15 | final class Version implements HandlesArguments
16 | {
17 |     use Concerns\HandleArguments;
18 | 
19 |     /**
20 |      * {@inheritDoc}
21 |      */
22 |     public function handleArguments(array $arguments): array
23 |     {
24 |         if ($this->hasArgument('--version', $arguments)) {
25 |             View::render('version', [
26 |                 'version' => version(),
27 |             ]);
28 | 
29 |             exit(0);
30 |         }
31 | 
32 |         return $arguments;
33 |     }
34 | }
35 | 


--------------------------------------------------------------------------------
/src/Repositories/AfterAllRepository.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Pest\Repositories;
 6 | 
 7 | use Closure;
 8 | use Pest\Exceptions\AfterAllAlreadyExist;
 9 | use Pest\Support\NullClosure;
10 | use Pest\Support\Reflection;
11 | 
12 | /**
13 |  * @internal
14 |  */
15 | final class AfterAllRepository
16 | {
17 |     /**
18 |      * @var array<string, Closure>
19 |      */
20 |     private array $state = [];
21 | 
22 |     /**
23 |      * Runs the given closure for each after all.
24 |      */
25 |     public function each(callable $each): void
26 |     {
27 |         foreach ($this->state as $filename => $closure) {
28 |             $each($filename, $closure);
29 |         }
30 |     }
31 | 
32 |     /**
33 |      * Sets a after all closure.
34 |      */
35 |     public function set(Closure $closure): void
36 |     {
37 |         $filename = Reflection::getFileNameFromClosure($closure);
38 | 
39 |         if (array_key_exists($filename, $this->state)) {
40 |             throw new AfterAllAlreadyExist($filename);
41 |         }
42 | 
43 |         $this->state[$filename] = $closure;
44 |     }
45 | 
46 |     /**
47 |      * Gets a after all closure by the given filename.
48 |      */
49 |     public function get(string $filename): Closure
50 |     {
51 |         return $this->state[$filename] ?? NullClosure::create();
52 |     }
53 | }
54 | 


--------------------------------------------------------------------------------
/src/Repositories/AfterEachRepository.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Pest\Repositories;
 6 | 
 7 | use Closure;
 8 | use Mockery;
 9 | use Pest\PendingCalls\AfterEachCall;
10 | use Pest\Support\ChainableClosure;
11 | use Pest\Support\NullClosure;
12 | 
13 | /**
14 |  * @internal
15 |  */
16 | final class AfterEachRepository
17 | {
18 |     /**
19 |      * @var array<string, Closure>
20 |      */
21 |     private array $state = [];
22 | 
23 |     /**
24 |      * Sets a after each closure.
25 |      */
26 |     public function set(string $filename, AfterEachCall $afterEachCall, Closure $afterEachTestCase): void
27 |     {
28 |         if (array_key_exists($filename, $this->state)) {
29 |             $fromAfterEachTestCase = $this->state[$filename];
30 | 
31 |             $afterEachTestCase = ChainableClosure::bound($fromAfterEachTestCase, $afterEachTestCase)
32 |                 ->bindTo($afterEachCall, $afterEachCall::class);
33 |         }
34 | 
35 |         assert($afterEachTestCase instanceof Closure);
36 | 
37 |         $this->state[$filename] = $afterEachTestCase;
38 |     }
39 | 
40 |     /**
41 |      * Gets an after each closure by the given filename.
42 |      */
43 |     public function get(string $filename): Closure
44 |     {
45 |         $afterEach = $this->state[$filename] ?? NullClosure::create();
46 | 
47 |         return ChainableClosure::bound(function (): void {
48 |             if (class_exists(Mockery::class)) {
49 |                 if ($container = Mockery::getContainer()) {
50 |                     /* @phpstan-ignore-next-line */
51 |                     $this->addToAssertionCount($container->mockery_getExpectationCount());
52 |                 }
53 | 
54 |                 Mockery::close();
55 |             }
56 |         }, $afterEach);
57 |     }
58 | }
59 | 


--------------------------------------------------------------------------------
/src/Repositories/BeforeAllRepository.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Pest\Repositories;
 6 | 
 7 | use Closure;
 8 | use Pest\Exceptions\BeforeAllAlreadyExist;
 9 | use Pest\Support\NullClosure;
10 | use Pest\Support\Reflection;
11 | 
12 | /**
13 |  * @internal
14 |  */
15 | final class BeforeAllRepository
16 | {
17 |     /**
18 |      * @var array<string, Closure>
19 |      */
20 |     private array $state = [];
21 | 
22 |     /**
23 |      * Runs one before all closure, and unsets it from the repository.
24 |      */
25 |     public function pop(string $filename): Closure
26 |     {
27 |         $closure = $this->get($filename);
28 | 
29 |         unset($this->state[$filename]);
30 | 
31 |         return $closure;
32 |     }
33 | 
34 |     /**
35 |      * Sets a before all closure.
36 |      */
37 |     public function set(Closure $closure): void
38 |     {
39 |         $filename = Reflection::getFileNameFromClosure($closure);
40 | 
41 |         if (array_key_exists($filename, $this->state)) {
42 |             throw new BeforeAllAlreadyExist($filename);
43 |         }
44 | 
45 |         $this->state[$filename] = $closure;
46 |     }
47 | 
48 |     /**
49 |      * Gets a before all closure by the given filename.
50 |      */
51 |     public function get(string $filename): Closure
52 |     {
53 |         return $this->state[$filename] ?? NullClosure::create();
54 |     }
55 | }
56 | 


--------------------------------------------------------------------------------
/src/Repositories/BeforeEachRepository.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Pest\Repositories;
 6 | 
 7 | use Closure;
 8 | use Pest\PendingCalls\BeforeEachCall;
 9 | use Pest\Support\ChainableClosure;
10 | use Pest\Support\NullClosure;
11 | 
12 | /**
13 |  * @internal
14 |  */
15 | final class BeforeEachRepository
16 | {
17 |     /**
18 |      * @var array<string, array{0: Closure, 1: Closure}>
19 |      */
20 |     private array $state = [];
21 | 
22 |     /**
23 |      * Sets a before each closure.
24 |      */
25 |     public function set(string $filename, BeforeEachCall $beforeEachCall, Closure $beforeEachTestCall, Closure $beforeEachTestCase): void
26 |     {
27 |         if (array_key_exists($filename, $this->state)) {
28 |             [$fromBeforeEachTestCall, $fromBeforeEachTestCase] = $this->state[$filename];
29 | 
30 |             $beforeEachTestCall = ChainableClosure::unbound($fromBeforeEachTestCall, $beforeEachTestCall);
31 |             $beforeEachTestCase = ChainableClosure::bound($fromBeforeEachTestCase, $beforeEachTestCase)->bindTo($beforeEachCall, $beforeEachCall::class);
32 |             assert($beforeEachTestCase instanceof Closure);
33 |         }
34 | 
35 |         $this->state[$filename] = [$beforeEachTestCall, $beforeEachTestCase];
36 |     }
37 | 
38 |     /**
39 |      * Gets a before each closure by the given filename.
40 |      *
41 |      * @return array{0: Closure, 1: Closure}
42 |      */
43 |     public function get(string $filename): array
44 |     {
45 |         $closures = $this->state[$filename] ?? [];
46 | 
47 |         return [
48 |             $closures[0] ?? NullClosure::create(),
49 |             $closures[1] ?? NullClosure::create(),
50 |         ];
51 |     }
52 | }
53 | 


--------------------------------------------------------------------------------
/src/Result.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Pest;
 6 | 
 7 | use NunoMaduro\Collision\Adapters\Phpunit\Support\ResultReflection;
 8 | use PHPUnit\TestRunner\TestResult\TestResult;
 9 | use PHPUnit\TextUI\Configuration\Configuration;
10 | 
11 | /**
12 |  * @internal
13 |  */
14 | final class Result
15 | {
16 |     private const SUCCESS_EXIT = 0;
17 | 
18 |     private const FAILURE_EXIT = 1;
19 | 
20 |     private const EXCEPTION_EXIT = 2;
21 | 
22 |     /**
23 |      * If the exit code is different from 0.
24 |      */
25 |     public static function failed(Configuration $configuration, TestResult $result): bool
26 |     {
27 |         return ! self::ok($configuration, $result);
28 |     }
29 | 
30 |     /**
31 |      * If the exit code is exactly 0.
32 |      */
33 |     public static function ok(Configuration $configuration, TestResult $result): bool
34 |     {
35 |         return self::exitCode($configuration, $result) === self::SUCCESS_EXIT;
36 |     }
37 | 
38 |     /**
39 |      * Get the test execution's exit code.
40 |      */
41 |     public static function exitCode(Configuration $configuration, TestResult $result): int
42 |     {
43 |         if ($result->wasSuccessfulIgnoringPhpunitWarnings()) {
44 |             if ($configuration->failOnWarning()) {
45 |                 $warnings = $result->numberOfTestsWithTestTriggeredPhpunitWarningEvents()
46 |                     + count($result->warnings())
47 |                     + count($result->phpWarnings());
48 | 
49 |                 if ($warnings > 0) {
50 |                     return self::FAILURE_EXIT;
51 |                 }
52 |             }
53 | 
54 |             if (! $result->hasTestTriggeredPhpunitWarningEvents()) {
55 |                 return self::SUCCESS_EXIT;
56 |             }
57 |         }
58 | 
59 |         if ($configuration->failOnEmptyTestSuite() && ResultReflection::numberOfTests($result) === 0) {
60 |             return self::FAILURE_EXIT;
61 |         }
62 | 
63 |         if ($result->wasSuccessfulIgnoringPhpunitWarnings()) {
64 |             if ($configuration->failOnRisky() && $result->hasTestConsideredRiskyEvents()) {
65 |                 $returnCode = self::FAILURE_EXIT;
66 |             }
67 | 
68 |             if ($configuration->failOnIncomplete() && $result->hasTestMarkedIncompleteEvents()) {
69 |                 $returnCode = self::FAILURE_EXIT;
70 |             }
71 | 
72 |             if ($configuration->failOnSkipped() && $result->hasTestSkippedEvents()) {
73 |                 $returnCode = self::FAILURE_EXIT;
74 |             }
75 |         }
76 | 
77 |         if ($result->hasTestErroredEvents()) {
78 |             return self::EXCEPTION_EXIT;
79 |         }
80 | 
81 |         return self::FAILURE_EXIT;
82 |     }
83 | }
84 | 


--------------------------------------------------------------------------------
/src/Subscribers/EnsureConfigurationIsAvailable.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Pest\Subscribers;
 6 | 
 7 | use Pest\Support\Container;
 8 | use PHPUnit\Event\TestRunner\Configured;
 9 | use PHPUnit\Event\TestRunner\ConfiguredSubscriber;
10 | use PHPUnit\TextUI\Configuration\Configuration;
11 | 
12 | /**
13 |  * @internal
14 |  */
15 | final class EnsureConfigurationIsAvailable implements ConfiguredSubscriber
16 | {
17 |     /**
18 |      * Runs the subscriber.
19 |      */
20 |     public function notify(Configured $event): void
21 |     {
22 |         Container::getInstance()->add(Configuration::class, $event->configuration());
23 |     }
24 | }
25 | 


--------------------------------------------------------------------------------
/src/Subscribers/EnsureIgnorableTestCasesAreIgnored.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Pest\Subscribers;
 6 | 
 7 | use PHPUnit\Event\TestRunner\Started;
 8 | use PHPUnit\Event\TestRunner\StartedSubscriber;
 9 | use PHPUnit\Event\TestRunner\WarningTriggered;
10 | use PHPUnit\TestRunner\TestResult\Collector;
11 | use PHPUnit\TestRunner\TestResult\Facade;
12 | use ReflectionClass;
13 | 
14 | /**
15 |  * @internal
16 |  */
17 | final class EnsureIgnorableTestCasesAreIgnored implements StartedSubscriber
18 | {
19 |     /**
20 |      * Runs the subscriber.
21 |      */
22 |     public function notify(Started $event): void
23 |     {
24 |         $reflection = new ReflectionClass(Facade::class);
25 |         $property = $reflection->getProperty('collector');
26 |         $property->setAccessible(true);
27 |         $collector = $property->getValue();
28 | 
29 |         assert($collector instanceof Collector);
30 | 
31 |         $reflection = new ReflectionClass($collector);
32 |         $property = $reflection->getProperty('testRunnerTriggeredWarningEvents');
33 |         $property->setAccessible(true);
34 | 
35 |         /** @var array<int, WarningTriggered> $testRunnerTriggeredWarningEvents */
36 |         $testRunnerTriggeredWarningEvents = $property->getValue($collector);
37 | 
38 |         $testRunnerTriggeredWarningEvents = array_values(array_filter($testRunnerTriggeredWarningEvents, fn (WarningTriggered $event): bool => $event->message() !== 'No tests found in class "Pest\TestCases\IgnorableTestCase".'));
39 | 
40 |         $property->setValue($collector, $testRunnerTriggeredWarningEvents);
41 |     }
42 | }
43 | 


--------------------------------------------------------------------------------
/src/Subscribers/EnsureKernelDumpIsFlushed.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Pest\Subscribers;
 6 | 
 7 | use Pest\KernelDump;
 8 | use Pest\Support\Container;
 9 | use PHPUnit\Event\TestRunner\Started;
10 | use PHPUnit\Event\TestRunner\StartedSubscriber;
11 | 
12 | /**
13 |  * @internal
14 |  */
15 | final class EnsureKernelDumpIsFlushed implements StartedSubscriber
16 | {
17 |     /**
18 |      * Runs the subscriber.
19 |      */
20 |     public function notify(Started $event): void
21 |     {
22 |         $kernelDump = Container::getInstance()->get(KernelDump::class);
23 | 
24 |         assert($kernelDump instanceof KernelDump);
25 | 
26 |         $kernelDump->disable();
27 |     }
28 | }
29 | 


--------------------------------------------------------------------------------
/src/Subscribers/EnsureTeamCityEnabled.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Pest\Subscribers;
 6 | 
 7 | use Pest\Logging\Converter;
 8 | use Pest\Logging\TeamCity\TeamCityLogger;
 9 | use Pest\TestSuite;
10 | use PHPUnit\Event\TestRunner\Configured;
11 | use PHPUnit\Event\TestRunner\ConfiguredSubscriber;
12 | use Symfony\Component\Console\Input\InputInterface;
13 | use Symfony\Component\Console\Output\OutputInterface;
14 | 
15 | /**
16 |  * @internal
17 |  */
18 | final readonly class EnsureTeamCityEnabled implements ConfiguredSubscriber
19 | {
20 |     /**
21 |      * Creates a new Configured Subscriber instance.
22 |      */
23 |     public function __construct(
24 |         private InputInterface $input,
25 |         private OutputInterface $output,
26 |         private TestSuite $testSuite,
27 |     ) {}
28 | 
29 |     /**
30 |      * Runs the subscriber.
31 |      */
32 |     public function notify(Configured $event): void
33 |     {
34 |         if (! $this->input->hasParameterOption('--teamcity')) {
35 |             return;
36 |         }
37 | 
38 |         $flowId = getenv('FLOW_ID');
39 |         $flowId = is_string($flowId) ? (int) $flowId : getmypid();
40 | 
41 |         new TeamCityLogger(
42 |             $this->output,
43 |             new Converter($this->testSuite->rootPath),
44 |             $flowId === false ? null : $flowId,
45 |             getenv('COLLISION_IGNORE_DURATION') !== false
46 |         );
47 |     }
48 | }
49 | 


--------------------------------------------------------------------------------
/src/Support/Arr.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Pest\Support;
 6 | 
 7 | /**
 8 |  * @internal
 9 |  */
10 | final class Arr
11 | {
12 |     /**
13 |      * Checks if the given array has the given key.
14 |      *
15 |      * @param  array<array-key, mixed>  $array
16 |      */
17 |     public static function has(array $array, string|int $key): bool
18 |     {
19 |         $key = (string) $key;
20 | 
21 |         if (array_key_exists($key, $array)) {
22 |             return true;
23 |         }
24 | 
25 |         foreach (explode('.', $key) as $segment) {
26 |             if (is_array($array) && array_key_exists($segment, $array)) {
27 |                 $array = $array[$segment];
28 |             } else {
29 |                 return false;
30 |             }
31 |         }
32 | 
33 |         return true;
34 |     }
35 | 
36 |     /**
37 |      * Gets the given key value.
38 |      *
39 |      * @param  array<array-key, mixed>  $array
40 |      */
41 |     public static function get(array $array, string|int $key, mixed $default = null): mixed
42 |     {
43 |         $key = (string) $key;
44 | 
45 |         if (array_key_exists($key, $array)) {
46 |             return $array[$key];
47 |         }
48 | 
49 |         if (! str_contains($key, '.')) {
50 |             return $array[$key] ?? $default;
51 |         }
52 | 
53 |         foreach (explode('.', $key) as $segment) {
54 |             if (is_array($array) && array_key_exists($segment, $array)) {
55 |                 $array = $array[$segment];
56 |             } else {
57 |                 return $default;
58 |             }
59 |         }
60 | 
61 |         return $array;
62 |     }
63 | 
64 |     /**
65 |      * Flatten a multi-dimensional associative array with dots.
66 |      *
67 |      * @param  array<array-key, mixed>  $array
68 |      * @return array<int|string, mixed>
69 |      */
70 |     public static function dot(array $array, string $prepend = ''): array
71 |     {
72 |         $results = [];
73 | 
74 |         foreach ($array as $key => $value) {
75 |             if (is_array($value) && $value !== []) {
76 |                 $results = array_merge($results, self::dot($value, $prepend.$key.'.'));
77 |             } else {
78 |                 $results[$prepend.$value] = $value;
79 |             }
80 |         }
81 | 
82 |         return $results;
83 |     }
84 | 
85 |     /**
86 |      * Returns the value of the last element or false for empty array
87 |      *
88 |      * @param  array<array-key, mixed>  $array
89 |      */
90 |     public static function last(array $array): mixed
91 |     {
92 |         return end($array);
93 |     }
94 | }
95 | 


--------------------------------------------------------------------------------
/src/Support/Backtrace.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | declare(strict_types=1);
  4 | 
  5 | namespace Pest\Support;
  6 | 
  7 | use Pest\Exceptions\ShouldNotHappen;
  8 | 
  9 | /**
 10 |  * @internal
 11 |  */
 12 | final class Backtrace
 13 | {
 14 |     /**
 15 |      * @var string
 16 |      */
 17 |     private const FILE = 'file';
 18 | 
 19 |     private const BACKTRACE_OPTIONS = DEBUG_BACKTRACE_IGNORE_ARGS;
 20 | 
 21 |     /**
 22 |      * Returns the current test file.
 23 |      */
 24 |     public static function testFile(): string
 25 |     {
 26 |         $current = null;
 27 | 
 28 |         foreach (debug_backtrace(self::BACKTRACE_OPTIONS) as $trace) {
 29 |             assert(array_key_exists(self::FILE, $trace));
 30 | 
 31 |             $traceFile = str_replace(DIRECTORY_SEPARATOR, '/', $trace[self::FILE]);
 32 | 
 33 |             if (
 34 |                 Str::endsWith($traceFile, 'overrides/Runner/TestSuiteLoader.php') ||
 35 |                 Str::endsWith($traceFile, 'src/Bootstrappers/BootFiles.php')
 36 |             ) {
 37 |                 break;
 38 |             }
 39 | 
 40 |             $current = $trace;
 41 |         }
 42 | 
 43 |         if ($current === null) {
 44 |             throw ShouldNotHappen::fromMessage('Test file not found.');
 45 |         }
 46 | 
 47 |         return $current[self::FILE];
 48 |     }
 49 | 
 50 |     /**
 51 |      * Returns the current datasets file.
 52 |      */
 53 |     public static function datasetsFile(): string
 54 |     {
 55 |         $current = null;
 56 | 
 57 |         foreach (debug_backtrace(self::BACKTRACE_OPTIONS) as $trace) {
 58 |             assert(array_key_exists(self::FILE, $trace));
 59 | 
 60 |             $traceFile = str_replace(DIRECTORY_SEPARATOR, '/', $trace[self::FILE]);
 61 | 
 62 |             if (Str::endsWith($traceFile, 'Bootstrappers/BootFiles.php') || Str::endsWith($traceFile, 'overrides/Runner/TestSuiteLoader.php')) {
 63 |                 break;
 64 |             }
 65 | 
 66 |             $current = $trace;
 67 |         }
 68 | 
 69 |         if ($current === null) {
 70 |             throw ShouldNotHappen::fromMessage('Dataset file not found.');
 71 |         }
 72 | 
 73 |         return $current[self::FILE];
 74 |     }
 75 | 
 76 |     /**
 77 |      * Returns the filename that called the current function/method.
 78 |      */
 79 |     public static function file(): string
 80 |     {
 81 |         $trace = self::backtrace();
 82 | 
 83 |         return $trace[self::FILE];
 84 |     }
 85 | 
 86 |     /**
 87 |      * Returns the dirname that called the current function/method.
 88 |      */
 89 |     public static function dirname(): string
 90 |     {
 91 |         $trace = self::backtrace();
 92 | 
 93 |         return dirname($trace[self::FILE]);
 94 |     }
 95 | 
 96 |     /**
 97 |      * Returns the line that called the current function/method.
 98 |      */
 99 |     public static function line(): int
100 |     {
101 |         $trace = self::backtrace();
102 | 
103 |         return $trace['line'] ?? 0;
104 |     }
105 | 
106 |     /**
107 |      * @return array{function: string, line?: int, file: string, class?: class-string, type?: string, args?: mixed[], object?: object}
108 |      */
109 |     private static function backtrace(): array
110 |     {
111 |         $backtrace = debug_backtrace(self::BACKTRACE_OPTIONS);
112 | 
113 |         foreach ($backtrace as $trace) {
114 |             if (! isset($trace['file'])) {
115 |                 continue;
116 |             }
117 | 
118 |             if (($GLOBALS['__PEST_INTERNAL_TEST_SUITE'] ?? false) && str_contains($trace['file'], 'pest'.DIRECTORY_SEPARATOR.'src')) {
119 |                 continue;
120 |             }
121 | 
122 |             if (str_contains($trace['file'], DIRECTORY_SEPARATOR.'pestphp'.DIRECTORY_SEPARATOR.'pest'.DIRECTORY_SEPARATOR.'src')) {
123 |                 continue;
124 |             }
125 | 
126 |             return $trace;
127 |         }
128 | 
129 |         throw ShouldNotHappen::fromMessage('Backtrace not found.');
130 |     }
131 | }
132 | 


--------------------------------------------------------------------------------
/src/Support/ChainableClosure.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Pest\Support;
 6 | 
 7 | use Closure;
 8 | use Pest\Exceptions\ShouldNotHappen;
 9 | 
10 | /**
11 |  * @internal
12 |  */
13 | final class ChainableClosure
14 | {
15 |     /**
16 |      * Calls the given `$closure` when the given condition is true, "bound" to the same object.
17 |      */
18 |     public static function boundWhen(Closure $condition, Closure $next): Closure
19 |     {
20 |         return function (...$arguments) use ($condition, $next): void {
21 |             if (! is_object($this)) { // @phpstan-ignore-line
22 |                 throw ShouldNotHappen::fromMessage('$this not bound to chainable closure.');
23 |             }
24 | 
25 |             if (\Pest\Support\Closure::bind($condition, $this, self::class)(...$arguments)) {
26 |                 \Pest\Support\Closure::bind($next, $this, self::class)(...$arguments);
27 |             }
28 |         };
29 |     }
30 | 
31 |     /**
32 |      * Calls the given `$closure` and chains the `$next` closure, "bound" to the same object.
33 |      */
34 |     public static function bound(Closure $closure, Closure $next): Closure
35 |     {
36 |         return function (...$arguments) use ($closure, $next): void {
37 |             if (! is_object($this)) { // @phpstan-ignore-line
38 |                 throw ShouldNotHappen::fromMessage('$this not bound to chainable closure.');
39 |             }
40 | 
41 |             \Pest\Support\Closure::bind($closure, $this, self::class)(...$arguments);
42 |             \Pest\Support\Closure::bind($next, $this, self::class)(...$arguments);
43 |         };
44 |     }
45 | 
46 |     /**
47 |      * Calls the given `$closure` and chains the `$next` closure, "unbound" of any object.
48 |      */
49 |     public static function unbound(Closure $closure, Closure $next): Closure
50 |     {
51 |         return function (...$arguments) use ($closure, $next): void {
52 |             $closure(...$arguments);
53 |             $next(...$arguments);
54 |         };
55 |     }
56 | 
57 |     /**
58 |      * Call the given static `$closure` and chains the `$next` closure, "bound" to the same object statically.
59 |      */
60 |     public static function boundStatically(Closure $closure, Closure $next): Closure
61 |     {
62 |         return static function (...$arguments) use ($closure, $next): void {
63 |             \Pest\Support\Closure::bind($closure, null, self::class)(...$arguments);
64 |             \Pest\Support\Closure::bind($next, null, self::class)(...$arguments);
65 |         };
66 |     }
67 | }
68 | 


--------------------------------------------------------------------------------
/src/Support/Closure.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Pest\Support;
 6 | 
 7 | use Closure as BaseClosure;
 8 | use Pest\Exceptions\ShouldNotHappen;
 9 | 
10 | /**
11 |  * @internal
12 |  */
13 | final class Closure
14 | {
15 |     /**
16 |      * Binds the given closure to the given "this".
17 |      *
18 |      * @throws ShouldNotHappen
19 |      */
20 |     public static function bind(?BaseClosure $closure, ?object $newThis, object|string|null $newScope = 'static'): BaseClosure
21 |     {
22 |         if (! $closure instanceof \Closure) {
23 |             throw ShouldNotHappen::fromMessage('Could not bind null closure.');
24 |         }
25 | 
26 |         // @phpstan-ignore-next-line
27 |         $closure = BaseClosure::bind($closure, $newThis, $newScope);
28 | 
29 |         if (! $closure instanceof \Closure) {
30 |             throw ShouldNotHappen::fromMessage('Could not bind closure.');
31 |         }
32 | 
33 |         return $closure;
34 |     }
35 | }
36 | 


--------------------------------------------------------------------------------
/src/Support/Container.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | declare(strict_types=1);
  4 | 
  5 | namespace Pest\Support;
  6 | 
  7 | use Pest\Exceptions\ShouldNotHappen;
  8 | use ReflectionClass;
  9 | use ReflectionParameter;
 10 | 
 11 | /**
 12 |  * @internal
 13 |  */
 14 | final class Container
 15 | {
 16 |     /**
 17 |      * The instance of the container.
 18 |      */
 19 |     private static ?Container $instance = null;
 20 | 
 21 |     /**
 22 |      * @var array<string, object|string>
 23 |      */
 24 |     private array $instances = [];
 25 | 
 26 |     /**
 27 |      * Gets a new or already existing container.
 28 |      */
 29 |     public static function getInstance(): self
 30 |     {
 31 |         if (! self::$instance instanceof \Pest\Support\Container) {
 32 |             self::$instance = new self;
 33 |         }
 34 | 
 35 |         return self::$instance;
 36 |     }
 37 | 
 38 |     /**
 39 |      * Gets a dependency from the container.
 40 |      */
 41 |     public function get(string $id): object|string
 42 |     {
 43 |         if (! array_key_exists($id, $this->instances)) {
 44 |             /** @var class-string $id */
 45 |             $this->instances[$id] = $this->build($id);
 46 |         }
 47 | 
 48 |         return $this->instances[$id];
 49 |     }
 50 | 
 51 |     /**
 52 |      * Adds the given instance to the container.
 53 |      *
 54 |      * @return $this
 55 |      */
 56 |     public function add(string $id, object|string $instance): self
 57 |     {
 58 |         $this->instances[$id] = $instance;
 59 | 
 60 |         return $this;
 61 |     }
 62 | 
 63 |     /**
 64 |      * Tries to build the given instance.
 65 |      *
 66 |      * @template TObject of object
 67 |      *
 68 |      * @param  class-string<TObject>  $id
 69 |      * @return TObject
 70 |      */
 71 |     private function build(string $id): object
 72 |     {
 73 |         $reflectionClass = new ReflectionClass($id);
 74 | 
 75 |         if ($reflectionClass->isInstantiable()) {
 76 |             $constructor = $reflectionClass->getConstructor();
 77 | 
 78 |             if ($constructor instanceof \ReflectionMethod) {
 79 |                 $params = array_map(
 80 |                     function (ReflectionParameter $param) use ($id): object|string {
 81 |                         $candidate = Reflection::getParameterClassName($param);
 82 | 
 83 |                         if ($candidate === null) {
 84 |                             $type = $param->getType();
 85 |                             /* @phpstan-ignore-next-line */
 86 |                             if ($type instanceof \ReflectionType && $type->isBuiltin()) {
 87 |                                 $candidate = $param->getName();
 88 |                             } else {
 89 |                                 throw ShouldNotHappen::fromMessage(sprintf('The type of `$%s` in `%s` cannot be determined.', $id, $param->getName()));
 90 |                             }
 91 |                         }
 92 | 
 93 |                         return $this->get($candidate);
 94 |                     },
 95 |                     $constructor->getParameters()
 96 |                 );
 97 | 
 98 |                 return $reflectionClass->newInstanceArgs($params);
 99 |             }
100 | 
101 |             return $reflectionClass->newInstance();
102 |         }
103 | 
104 |         throw ShouldNotHappen::fromMessage(sprintf('A dependency with the name `%s` cannot be resolved.', $id));
105 |     }
106 | }
107 | 


--------------------------------------------------------------------------------
/src/Support/DatasetInfo.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Pest\Support;
 6 | 
 7 | use function Pest\testDirectory;
 8 | 
 9 | /**
10 |  * @internal
11 |  */
12 | final class DatasetInfo
13 | {
14 |     public const DATASETS_DIR_NAME = 'Datasets';
15 | 
16 |     public const DATASETS_FILE_NAME = 'Datasets.php';
17 | 
18 |     public static function isInsideADatasetsDirectory(string $file): bool
19 |     {
20 |         return basename(dirname($file)) === self::DATASETS_DIR_NAME;
21 |     }
22 | 
23 |     public static function isADatasetsFile(string $file): bool
24 |     {
25 |         return basename($file) === self::DATASETS_FILE_NAME;
26 |     }
27 | 
28 |     public static function scope(string $file): string
29 |     {
30 |         if (Str::endsWith($file, testDirectory('Pest.php'))) {
31 |             return dirname($file);
32 |         }
33 | 
34 |         if (self::isInsideADatasetsDirectory($file)) {
35 |             return dirname($file, 2);
36 |         }
37 | 
38 |         if (self::isADatasetsFile($file)) {
39 |             return dirname($file);
40 |         }
41 | 
42 |         return $file;
43 |     }
44 | }
45 | 


--------------------------------------------------------------------------------
/src/Support/ExceptionTrace.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Pest\Support;
 6 | 
 7 | use Closure;
 8 | use PHPUnit\Framework\TestCase;
 9 | use Throwable;
10 | 
11 | /**
12 |  * @internal
13 |  */
14 | final class ExceptionTrace
15 | {
16 |     private const UNDEFINED_METHOD = 'Call to undefined method P\\';
17 | 
18 |     /**
19 |      * Ensures the given closure reports the good execution context.
20 |      *
21 |      * @throws Throwable
22 |      */
23 |     public static function ensure(Closure $closure): mixed
24 |     {
25 |         try {
26 |             return $closure();
27 |         } catch (Throwable $throwable) {
28 |             if (Str::startsWith($message = $throwable->getMessage(), self::UNDEFINED_METHOD)) {
29 |                 $class = preg_match('/^Call to undefined method ([^:]+)::/', $message, $matches) === false ? null : $matches[1];
30 | 
31 |                 $message = str_replace(self::UNDEFINED_METHOD, 'Call to undefined method ', $message);
32 | 
33 |                 if (class_exists((string) $class) && (is_countable(class_parents($class)) ? count(class_parents($class)) : 0) > 0 && array_values(class_parents($class))[0] === TestCase::class) { // @phpstan-ignore-line
34 |                     $message .= '. Did you forget to use the [pest()->extend()] function? Read more at: https://pestphp.com/docs/configuring-tests';
35 |                 }
36 | 
37 |                 Reflection::setPropertyValue($throwable, 'message', $message);
38 |             }
39 | 
40 |             throw $throwable;
41 |         }
42 |     }
43 | }
44 | 


--------------------------------------------------------------------------------
/src/Support/ExpectationPipeline.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Pest\Support;
 6 | 
 7 | use Closure;
 8 | 
 9 | /**
10 |  * @internal
11 |  */
12 | final class ExpectationPipeline
13 | {
14 |     /**
15 |      * The list of pipes.
16 |      *
17 |      * @var array<int, Closure>
18 |      */
19 |     private array $pipes = [];
20 | 
21 |     /**
22 |      * The list of passables.
23 |      *
24 |      * @var array<array-key, mixed>
25 |      */
26 |     private array $passables;
27 | 
28 |     /**
29 |      * Creates a new instance of Expectation Pipeline.
30 |      */
31 |     public function __construct(
32 |         private readonly Closure $closure
33 |     ) {}
34 | 
35 |     /**
36 |      * Creates a new instance of Expectation Pipeline with given closure.
37 |      */
38 |     public static function for(Closure $closure): self
39 |     {
40 |         return new self($closure);
41 |     }
42 | 
43 |     /**
44 |      * Sets the list of passables.
45 |      */
46 |     public function send(mixed ...$passables): self
47 |     {
48 |         $this->passables = $passables;
49 | 
50 |         return $this;
51 |     }
52 | 
53 |     /**
54 |      * Sets the list of pipes.
55 |      *
56 |      * @param  array<int, Closure>  $pipes
57 |      */
58 |     public function through(array $pipes): self
59 |     {
60 |         $this->pipes = $pipes;
61 | 
62 |         return $this;
63 |     }
64 | 
65 |     /**
66 |      * Runs the pipeline.
67 |      */
68 |     public function run(): void
69 |     {
70 |         $pipeline = array_reduce(
71 |             array_reverse($this->pipes),
72 |             $this->carry(),
73 |             function (): void {
74 |                 call_user_func_array($this->closure, $this->passables);
75 |             }
76 |         );
77 | 
78 |         $pipeline();
79 |     }
80 | 
81 |     /**
82 |      * Get a Closure that will carry of the expectation.
83 |      */
84 |     public function carry(): Closure
85 |     {
86 |         return fn (mixed $stack, callable $pipe): Closure => fn () => $pipe($stack, ...$this->passables);
87 |     }
88 | }
89 | 


--------------------------------------------------------------------------------
/src/Support/Exporter.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Pest\Support;
 6 | 
 7 | use SebastianBergmann\Exporter\Exporter as BaseExporter;
 8 | use SebastianBergmann\RecursionContext\Context;
 9 | 
10 | /**
11 |  * @internal
12 |  */
13 | final readonly class Exporter
14 | {
15 |     /**
16 |      * The maximum number of items in an array to export.
17 |      */
18 |     private const MAX_ARRAY_ITEMS = 3;
19 | 
20 |     /**
21 |      * Creates a new Exporter instance.
22 |      */
23 |     public function __construct(
24 |         private BaseExporter $exporter,
25 |     ) {
26 |         // ...
27 |     }
28 | 
29 |     /**
30 |      * Creates a new Exporter instance.
31 |      */
32 |     public static function default(): self
33 |     {
34 |         return new self(
35 |             new BaseExporter
36 |         );
37 |     }
38 | 
39 |     /**
40 |      * Exports a value into a single-line string recursively.
41 |      *
42 |      * @param  array<int|string, mixed>  $data
43 |      */
44 |     public function shortenedRecursiveExport(array &$data, ?Context $context = null): string
45 |     {
46 |         $result = [];
47 |         $array = $data;
48 |         $itemsCount = 0;
49 |         $exporter = self::default();
50 |         $context ??= new Context;
51 | 
52 |         $context->add($data);
53 | 
54 |         foreach ($array as $key => $value) {
55 |             if (++$itemsCount > self::MAX_ARRAY_ITEMS) {
56 |                 $result[] = '…';
57 | 
58 |                 break;
59 |             }
60 | 
61 |             if (! is_array($value)) {
62 |                 $result[] = $exporter->shortenedExport($value);
63 | 
64 |                 continue;
65 |             }
66 | 
67 |             $result[] = $context->contains($data[$key]) !== false
68 |                 ? '*RECURSION*'
69 |                 // @phpstan-ignore-next-line
70 |                 : sprintf('[%s]', $this->shortenedRecursiveExport($data[$key], $context));
71 |         }
72 | 
73 |         return implode(', ', $result);
74 |     }
75 | 
76 |     /**
77 |      * Exports a value into a single-line string.
78 |      */
79 |     public function shortenedExport(mixed $value): string
80 |     {
81 |         $map = [
82 |             '#\.{3}#' => '…',
83 |             '#\\\n\s*#' => '',
84 |             '# Object \(…\)#' => '',
85 |         ];
86 | 
87 |         return (string) preg_replace(array_keys($map), array_values($map), $this->exporter->shortenedExport($value));
88 |     }
89 | }
90 | 


--------------------------------------------------------------------------------
/src/Support/HigherOrderCallables.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Pest\Support;
 6 | 
 7 | use Closure;
 8 | use Pest\Expectation;
 9 | 
10 | /**
11 |  * @internal
12 |  */
13 | final readonly class HigherOrderCallables
14 | {
15 |     /**
16 |      * Creates a new Higher Order Callables instances.
17 |      */
18 |     public function __construct(private object $target)
19 |     {
20 |         // ..
21 |     }
22 | 
23 |     /**
24 |      * @template TValue
25 |      *
26 |      * Create a new expectation. Callable values will be executed prior to returning the new expectation.
27 |      *
28 |      * @param  (Closure():TValue)|TValue  $value
29 |      * @return Expectation<TValue>
30 |      */
31 |     public function expect(mixed $value): Expectation
32 |     {
33 |         /** @var TValue $value */
34 |         $value = $value instanceof Closure ? Reflection::bindCallableWithData($value) : $value;
35 | 
36 |         return new Expectation($value);
37 |     }
38 | 
39 |     /**
40 |      * @template TValue
41 |      *
42 |      * Create a new expectation. Callable values will be executed prior to returning the new expectation.
43 |      *
44 |      * @param  callable|TValue  $value
45 |      * @return Expectation<(callable(): mixed)|TValue>
46 |      */
47 |     public function and(mixed $value): Expectation
48 |     {
49 |         return $this->expect($value);
50 |     }
51 | 
52 |     /**
53 |      * Execute the given callable after the test has executed the setup method.
54 |      */
55 |     public function defer(callable $callable): object
56 |     {
57 |         Reflection::bindCallableWithData($callable);
58 | 
59 |         return $this->target;
60 |     }
61 | }
62 | 


--------------------------------------------------------------------------------
/src/Support/HigherOrderMessage.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | declare(strict_types=1);
  4 | 
  5 | namespace Pest\Support;
  6 | 
  7 | use Closure;
  8 | use ReflectionClass;
  9 | use Throwable;
 10 | 
 11 | /**
 12 |  * @internal
 13 |  */
 14 | final class HigherOrderMessage
 15 | {
 16 |     public const UNDEFINED_METHOD = 'Method %s does not exist';
 17 | 
 18 |     /**
 19 |      * An optional condition that will determine if the message will be executed.
 20 |      *
 21 |      * @var (Closure(): bool)|null
 22 |      */
 23 |     public ?Closure $condition = null;
 24 | 
 25 |     /**
 26 |      * Creates a new higher order message.
 27 |      *
 28 |      * @param  array<int, mixed>|null  $arguments
 29 |      */
 30 |     public function __construct(
 31 |         public string $filename,
 32 |         public int $line,
 33 |         public string $name,
 34 |         public ?array $arguments
 35 |     ) {
 36 |         // ..
 37 |     }
 38 | 
 39 |     /**
 40 |      * Re-throws the given `$throwable` with the good line and filename.
 41 |      *
 42 |      * @template TValue of object
 43 |      *
 44 |      * @param  TValue  $target
 45 |      */
 46 |     public function call(object $target): mixed
 47 |     {
 48 |         if (is_callable($this->condition) && call_user_func(Closure::bind($this->condition, $target)) === false) {
 49 |             return $target;
 50 |         }
 51 | 
 52 |         if ($this->hasHigherOrderCallable()) {
 53 |             return (new HigherOrderCallables($target))->{$this->name}(...$this->arguments);
 54 |         }
 55 | 
 56 |         try {
 57 |             return is_array($this->arguments)
 58 |                 ? Reflection::call($target, $this->name, $this->arguments)
 59 |                 : $target->{$this->name};
 60 |         } catch (Throwable $throwable) {
 61 |             Reflection::setPropertyValue($throwable, 'file', $this->filename);
 62 |             Reflection::setPropertyValue($throwable, 'line', $this->line);
 63 | 
 64 |             if ($throwable->getMessage() === $this->getUndefinedMethodMessage($target, $this->name)) {
 65 |                 /** @var ReflectionClass<TValue> $reflection */
 66 |                 $reflection = new ReflectionClass($target);
 67 |                 $reflection = $reflection->getParentClass() ?: $reflection;
 68 |                 Reflection::setPropertyValue($throwable, 'message', sprintf('Call to undefined method %s::%s()', $reflection->getName(), $this->name));
 69 |             }
 70 | 
 71 |             throw $throwable;
 72 |         }
 73 |     }
 74 | 
 75 |     /**
 76 |      * Indicates that this message should only be called when the given condition is true.
 77 |      *
 78 |      * @param  callable(): bool  $condition
 79 |      */
 80 |     public function when(callable $condition): self
 81 |     {
 82 |         $this->condition = Closure::fromCallable($condition);
 83 | 
 84 |         return $this;
 85 |     }
 86 | 
 87 |     /**
 88 |      * Determines whether or not there exists a higher order callable with the message name.
 89 |      */
 90 |     private function hasHigherOrderCallable(): bool
 91 |     {
 92 |         return in_array($this->name, get_class_methods(HigherOrderCallables::class), true);
 93 |     }
 94 | 
 95 |     private function getUndefinedMethodMessage(object $target, string $methodName): string
 96 |     {
 97 |         return sprintf(self::UNDEFINED_METHOD, sprintf('%s::%s()', $target::class, $methodName));
 98 |     }
 99 | }
100 | 


--------------------------------------------------------------------------------
/src/Support/HigherOrderMessageCollection.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Pest\Support;
 6 | 
 7 | /**
 8 |  * @internal
 9 |  */
10 | final class HigherOrderMessageCollection
11 | {
12 |     /**
13 |      * @var array<int, HigherOrderMessage>
14 |      */
15 |     private array $messages = [];
16 | 
17 |     /**
18 |      * Adds a new higher order message to the collection.
19 |      *
20 |      * @param  array<int, mixed>|null  $arguments
21 |      */
22 |     public function add(string $filename, int $line, string $name, ?array $arguments): void
23 |     {
24 |         $this->messages[] = new HigherOrderMessage($filename, $line, $name, $arguments);
25 |     }
26 | 
27 |     /**
28 |      * Adds a new higher order message to the collection if the callable condition is does not return false.
29 |      *
30 |      * @param  array<int, mixed>|null  $arguments
31 |      */
32 |     public function addWhen(callable $condition, string $filename, int $line, string $name, ?array $arguments): void
33 |     {
34 |         $this->messages[] = (new HigherOrderMessage($filename, $line, $name, $arguments))->when($condition);
35 |     }
36 | 
37 |     /**
38 |      * Proxy all the messages starting from the target.
39 |      */
40 |     public function chain(object $target): void
41 |     {
42 |         foreach ($this->messages as $message) {
43 |             $target = $message->call($target) ?? $target;
44 |         }
45 |     }
46 | 
47 |     /**
48 |      * Proxy all the messages to the target.
49 |      */
50 |     public function proxy(object $target): void
51 |     {
52 |         foreach ($this->messages as $message) {
53 |             $message->call($target);
54 |         }
55 |     }
56 | 
57 |     /**
58 |      * Count the number of messages with the given name.
59 |      *
60 |      * @param  string  $name  A higher order message name (usually a method name)
61 |      */
62 |     public function count(string $name): int
63 |     {
64 |         return array_reduce(
65 |             $this->messages,
66 |             static fn (int $total, HigherOrderMessage $message): int => $total + (int) ($name === $message->name),
67 |             0,
68 |         );
69 |     }
70 | }
71 | 


--------------------------------------------------------------------------------
/src/Support/HigherOrderTapProxy.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Pest\Support;
 6 | 
 7 | use PHPUnit\Framework\TestCase;
 8 | use ReflectionClass;
 9 | 
10 | /**
11 |  * @internal
12 |  */
13 | final class HigherOrderTapProxy
14 | {
15 |     /**
16 |      * Create a new tap proxy instance.
17 |      */
18 |     public function __construct(
19 |         public TestCase $target
20 |     ) {
21 |         // ..
22 |     }
23 | 
24 |     /**
25 |      * Dynamically sets properties on the target.
26 |      */
27 |     public function __set(string $property, mixed $value): void
28 |     {
29 |         $this->target->{$property} = $value;
30 |     }
31 | 
32 |     /**
33 |      * Dynamically pass properties gets to the target.
34 |      *
35 |      * @return mixed
36 |      */
37 |     public function __get(string $property)
38 |     {
39 |         if (property_exists($this->target, $property)) {
40 |             return $this->target->{$property};
41 |         }
42 | 
43 |         $className = (new ReflectionClass($this->target))->getName();
44 | 
45 |         if (str_starts_with($className, 'P\\')) {
46 |             $className = substr($className, 2);
47 |         }
48 | 
49 |         trigger_error(sprintf('Undefined property %s::$%s', $className, $property), E_USER_WARNING);
50 | 
51 |         return null;
52 |     }
53 | 
54 |     /**
55 |      * Dynamically pass method calls to the target.
56 |      *
57 |      * @param  array<int, mixed>  $arguments
58 |      * @return mixed
59 |      */
60 |     public function __call(string $methodName, array $arguments)
61 |     {
62 |         $filename = Backtrace::file();
63 |         $line = Backtrace::line();
64 | 
65 |         return (new HigherOrderMessage($filename, $line, $methodName, $arguments))
66 |             ->call($this->target);
67 |     }
68 | }
69 | 


--------------------------------------------------------------------------------
/src/Support/NullClosure.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Pest\Support;
 6 | 
 7 | use Closure;
 8 | 
 9 | /**
10 |  * @internal
11 |  */
12 | final class NullClosure
13 | {
14 |     /**
15 |      * Creates a nullable closure.
16 |      */
17 |     public static function create(): Closure
18 |     {
19 |         return Closure::fromCallable(function (): void {});
20 |     }
21 | }
22 | 


--------------------------------------------------------------------------------
/src/Support/Str.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | declare(strict_types=1);
  4 | 
  5 | namespace Pest\Support;
  6 | 
  7 | /**
  8 |  * @internal
  9 |  */
 10 | final class Str
 11 | {
 12 |     /**
 13 |      * Pool of alpha-numeric characters for generating (unsafe) random strings
 14 |      * from.
 15 |      */
 16 |     private const POOL = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ';
 17 | 
 18 |     /**
 19 |      * @var string
 20 |      */
 21 |     private const PREFIX = '__pest_evaluable_';
 22 | 
 23 |     /**
 24 |      * Create a (unsecure & non-cryptographically safe) random alpha-numeric
 25 |      * string value.
 26 |      *
 27 |      * @param  int  $length  the length of the resulting randomized string
 28 |      *
 29 |      * @see https://github.com/laravel/framework/blob/4.2/src/Illuminate/Support/Str.php#L240-L242
 30 |      */
 31 |     public static function random(int $length = 16): string
 32 |     {
 33 |         return substr(str_shuffle(str_repeat(self::POOL, 5)), 0, $length);
 34 |     }
 35 | 
 36 |     /**
 37 |      * Checks if the given `$target` starts with the given `$search`.
 38 |      */
 39 |     public static function startsWith(string $target, string $search): bool
 40 |     {
 41 |         return str_starts_with($target, $search);
 42 |     }
 43 | 
 44 |     /**
 45 |      * Checks if the given `$target` ends with the given `$search`.
 46 |      */
 47 |     public static function endsWith(string $target, string $search): bool
 48 |     {
 49 |         $length = strlen($search);
 50 |         if ($length === 0) {
 51 |             return true;
 52 |         }
 53 | 
 54 |         return $search === substr($target, -$length);
 55 |     }
 56 | 
 57 |     /**
 58 |      * Makes the given string evaluable by an `eval`.
 59 |      */
 60 |     public static function evaluable(string $code): string
 61 |     {
 62 |         $code = str_replace('_', '__', $code);
 63 | 
 64 |         $code = self::PREFIX.str_replace(' ', '_', $code);
 65 | 
 66 |         // sticks to PHP8.2 function naming rules https://www.php.net/manual/en/functions.user-defined.php
 67 |         return (string) preg_replace('/[^a-zA-Z0-9_\x80-\xff]/', '_', $code);
 68 |     }
 69 | 
 70 |     /**
 71 |      * Get the portion of a string before the last occurrence of a given value.
 72 |      */
 73 |     public static function beforeLast(string $subject, string $search): string
 74 |     {
 75 |         if ($search === '') {
 76 |             return $subject;
 77 |         }
 78 | 
 79 |         $pos = mb_strrpos($subject, $search);
 80 | 
 81 |         if ($pos === false) {
 82 |             return $subject;
 83 |         }
 84 | 
 85 |         return substr($subject, 0, $pos);
 86 |     }
 87 | 
 88 |     /**
 89 |      * Returns the content after the given "search".
 90 |      */
 91 |     public static function after(string $subject, string $search): string
 92 |     {
 93 |         return $search === '' ? $subject : array_reverse(explode($search, $subject, 2))[0];
 94 |     }
 95 | 
 96 |     /**
 97 |      * Determine if a given value is a valid UUID.
 98 |      */
 99 |     public static function isUuid(string $value): bool
100 |     {
101 |         return preg_match('/^[\da-f]{8}-[\da-f]{4}-[\da-f]{4}-[\da-f]{4}-[\da-f]{12}$/iD', $value) > 0;
102 |     }
103 | 
104 |     /**
105 |      * Creates a describe block as `$describeDescription` → `$testDescription` format.
106 |      *
107 |      * @param  array<int, string>  $describeDescriptions
108 |      */
109 |     public static function describe(array $describeDescriptions, string $testDescription): string
110 |     {
111 |         $descriptionComponents = [...$describeDescriptions, $testDescription];
112 | 
113 |         return sprintf(str_repeat('`%s` → ', count($describeDescriptions)).'%s', ...$descriptionComponents);
114 |     }
115 | 
116 |     /**
117 |      * Determine if a given value is a valid URL.
118 |      */
119 |     public static function isUrl(string $value): bool
120 |     {
121 |         return (bool) filter_var($value, FILTER_VALIDATE_URL);
122 |     }
123 | }
124 | 


--------------------------------------------------------------------------------
/src/Support/View.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Pest\Support;
 6 | 
 7 | use Symfony\Component\Console\Output\OutputInterface;
 8 | use Termwind\Termwind;
 9 | 
10 | use function Termwind\render;
11 | use function Termwind\renderUsing;
12 | 
13 | /**
14 |  * @internal
15 |  */
16 | final class View
17 | {
18 |     /**
19 |      * The implementation of the output.
20 |      */
21 |     private static OutputInterface $output;
22 | 
23 |     /**
24 |      * Renders views using the given Output instance.
25 |      */
26 |     public static function renderUsing(OutputInterface $output): void
27 |     {
28 |         self::$output = $output;
29 |     }
30 | 
31 |     /**
32 |      * Renders the given view.
33 |      *
34 |      * @param  array<string, mixed>  $data
35 |      */
36 |     public static function render(string $path, array $data = []): void
37 |     {
38 |         $contents = self::compile($path, $data);
39 | 
40 |         $existing = Termwind::getRenderer();
41 | 
42 |         renderUsing(self::$output);
43 | 
44 |         try {
45 |             render($contents);
46 |         } finally {
47 |             renderUsing($existing);
48 |         }
49 |     }
50 | 
51 |     /**
52 |      * Compiles the given view.
53 |      *
54 |      * @param  array<string, mixed>  $data
55 |      */
56 |     private static function compile(string $path, array $data): string
57 |     {
58 |         extract($data);
59 | 
60 |         ob_start();
61 | 
62 |         $path = str_replace('.', '/', $path);
63 | 
64 |         include sprintf('%s/../../resources/views/%s.php', __DIR__, $path);
65 | 
66 |         $contents = ob_get_contents();
67 | 
68 |         ob_clean();
69 | 
70 |         return (string) $contents;
71 |     }
72 | }
73 | 


--------------------------------------------------------------------------------
/src/TestCaseFilters/GitDirtyTestCaseFilter.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Pest\TestCaseFilters;
 6 | 
 7 | use Pest\Contracts\TestCaseFilter;
 8 | use Pest\Exceptions\MissingDependency;
 9 | use Pest\Exceptions\NoDirtyTestsFound;
10 | use Pest\Panic;
11 | use Pest\TestSuite;
12 | use Symfony\Component\Process\Process;
13 | 
14 | final class GitDirtyTestCaseFilter implements TestCaseFilter
15 | {
16 |     /**
17 |      * @var array<int, string>|null
18 |      */
19 |     private ?array $changedFiles = null;
20 | 
21 |     /**
22 |      * Creates a new instance of the filter.
23 |      */
24 |     public function __construct(private readonly string $projectRoot)
25 |     {
26 |         // ...
27 |     }
28 | 
29 |     /**
30 |      * {@inheritdoc}
31 |      */
32 |     public function accept(string $testCaseFilename): bool
33 |     {
34 |         if ($this->changedFiles === null) {
35 |             $this->loadChangedFiles();
36 |         }
37 | 
38 |         assert(is_array($this->changedFiles));
39 | 
40 |         $relativePath = str_replace($this->projectRoot, '', $testCaseFilename);
41 |         $relativePath = str_replace(DIRECTORY_SEPARATOR, '/', $relativePath);
42 | 
43 |         if (str_starts_with($relativePath, '/')) {
44 |             $relativePath = substr($relativePath, 1);
45 |         }
46 | 
47 |         return in_array($relativePath, $this->changedFiles, true);
48 |     }
49 | 
50 |     /**
51 |      * Loads the changed files.
52 |      */
53 |     private function loadChangedFiles(): void
54 |     {
55 |         $process = new Process(['git', 'status', '--short', '--', '*.php']);
56 |         $process->run();
57 | 
58 |         if (! $process->isSuccessful()) {
59 |             throw new MissingDependency('Filter by dirty files', 'git');
60 |         }
61 | 
62 |         $output = preg_split('/\R+/', $process->getOutput(), flags: PREG_SPLIT_NO_EMPTY);
63 |         assert(is_array($output));
64 | 
65 |         $dirtyFiles = [];
66 | 
67 |         foreach ($output as $dirtyFile) {
68 |             $dirtyFiles[substr($dirtyFile, 3)] = trim(substr($dirtyFile, 0, 3));
69 |         }
70 | 
71 |         $dirtyFiles = array_filter($dirtyFiles, fn (string $status): bool => $status !== 'D');
72 | 
73 |         $dirtyFiles = array_map(
74 |             fn (string $file, string $status): string => in_array($status, ['R', 'RM'], true)
75 |                 ? explode(' -> ', $file)[1]
76 |                 : $file, array_keys($dirtyFiles), $dirtyFiles,
77 |         );
78 | 
79 |         $dirtyFiles = array_filter(
80 |             $dirtyFiles,
81 |             fn (string $file): bool => str_starts_with('.'.DIRECTORY_SEPARATOR.$file, TestSuite::getInstance()->testPath)
82 |                 || str_starts_with($file, TestSuite::getInstance()->testPath)
83 |         );
84 | 
85 |         $dirtyFiles = array_values($dirtyFiles);
86 | 
87 |         if ($dirtyFiles === []) {
88 |             Panic::with(new NoDirtyTestsFound);
89 |         }
90 | 
91 |         $this->changedFiles = $dirtyFiles;
92 |     }
93 | }
94 | 


--------------------------------------------------------------------------------
/src/TestCaseMethodFilters/AssigneeTestCaseFilter.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Pest\TestCaseMethodFilters;
 6 | 
 7 | use Pest\Contracts\TestCaseMethodFilter;
 8 | use Pest\Factories\TestCaseMethodFactory;
 9 | 
10 | final readonly class AssigneeTestCaseFilter implements TestCaseMethodFilter
11 | {
12 |     /**
13 |      * Create a new filter instance.
14 |      */
15 |     public function __construct(private string $assignee)
16 |     {
17 |         //
18 |     }
19 | 
20 |     /**
21 |      * Filter the test case methods.
22 |      */
23 |     public function accept(TestCaseMethodFactory $factory): bool
24 |     {
25 |         return array_filter($factory->assignees, fn (string $assignee): bool => str_starts_with($assignee, $this->assignee)) !== [];
26 |     }
27 | }
28 | 


--------------------------------------------------------------------------------
/src/TestCaseMethodFilters/IssueTestCaseFilter.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Pest\TestCaseMethodFilters;
 6 | 
 7 | use Pest\Contracts\TestCaseMethodFilter;
 8 | use Pest\Factories\TestCaseMethodFactory;
 9 | 
10 | final readonly class IssueTestCaseFilter implements TestCaseMethodFilter
11 | {
12 |     /**
13 |      * Create a new filter instance.
14 |      */
15 |     public function __construct(private int $number)
16 |     {
17 |         //
18 |     }
19 | 
20 |     /**
21 |      * Filter the test case methods.
22 |      */
23 |     public function accept(TestCaseMethodFactory $factory): bool
24 |     {
25 |         return in_array($this->number, $factory->issues, true);
26 |     }
27 | }
28 | 


--------------------------------------------------------------------------------
/src/TestCaseMethodFilters/NotesTestCaseFilter.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Pest\TestCaseMethodFilters;
 6 | 
 7 | use Pest\Contracts\TestCaseMethodFilter;
 8 | use Pest\Factories\TestCaseMethodFactory;
 9 | 
10 | final readonly class NotesTestCaseFilter implements TestCaseMethodFilter
11 | {
12 |     /**
13 |      * Filter the test case methods.
14 |      */
15 |     public function accept(TestCaseMethodFactory $factory): bool
16 |     {
17 |         return $factory->notes !== [];
18 |     }
19 | }
20 | 


--------------------------------------------------------------------------------
/src/TestCaseMethodFilters/PrTestCaseFilter.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Pest\TestCaseMethodFilters;
 6 | 
 7 | use Pest\Contracts\TestCaseMethodFilter;
 8 | use Pest\Factories\TestCaseMethodFactory;
 9 | 
10 | final readonly class PrTestCaseFilter implements TestCaseMethodFilter
11 | {
12 |     /**
13 |      * Create a new filter instance.
14 |      */
15 |     public function __construct(private int $number)
16 |     {
17 |         //
18 |     }
19 | 
20 |     /**
21 |      * Filter the test case methods.
22 |      */
23 |     public function accept(TestCaseMethodFactory $factory): bool
24 |     {
25 |         return in_array($this->number, $factory->prs, true);
26 |     }
27 | }
28 | 


--------------------------------------------------------------------------------
/src/TestCaseMethodFilters/TodoTestCaseFilter.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Pest\TestCaseMethodFilters;
 6 | 
 7 | use Pest\Contracts\TestCaseMethodFilter;
 8 | use Pest\Factories\TestCaseMethodFactory;
 9 | 
10 | final readonly class TodoTestCaseFilter implements TestCaseMethodFilter
11 | {
12 |     /**
13 |      * Filter the test case methods.
14 |      */
15 |     public function accept(TestCaseMethodFactory $factory): bool
16 |     {
17 |         return $factory->todo;
18 |     }
19 | }
20 | 


--------------------------------------------------------------------------------
/src/TestCases/IgnorableTestCase.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Pest\TestCases;
 6 | 
 7 | use PHPUnit\Framework\TestCase;
 8 | 
 9 | /**
10 |  * @internal
11 |  */
12 | final class IgnorableTestCase extends TestCase
13 | {
14 |     // ...
15 | }
16 | 


--------------------------------------------------------------------------------
/src/TestSuite.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | declare(strict_types=1);
  4 | 
  5 | namespace Pest;
  6 | 
  7 | use Pest\Exceptions\InvalidPestCommand;
  8 | use Pest\Repositories\AfterAllRepository;
  9 | use Pest\Repositories\AfterEachRepository;
 10 | use Pest\Repositories\BeforeAllRepository;
 11 | use Pest\Repositories\BeforeEachRepository;
 12 | use Pest\Repositories\SnapshotRepository;
 13 | use Pest\Repositories\TestRepository;
 14 | use Pest\Support\Str;
 15 | use PHPUnit\Framework\TestCase;
 16 | 
 17 | /**
 18 |  * @internal
 19 |  */
 20 | final class TestSuite
 21 | {
 22 |     /**
 23 |      * Holds the current test case.
 24 |      */
 25 |     public ?TestCase $test = null;
 26 | 
 27 |     /**
 28 |      * Holds the tests repository.
 29 |      */
 30 |     public TestRepository $tests;
 31 | 
 32 |     /**
 33 |      * Holds the before each repository.
 34 |      */
 35 |     public BeforeEachRepository $beforeEach;
 36 | 
 37 |     /**
 38 |      * Holds the before all repository.
 39 |      */
 40 |     public BeforeAllRepository $beforeAll;
 41 | 
 42 |     /**
 43 |      * Holds the after each repository.
 44 |      */
 45 |     public AfterEachRepository $afterEach;
 46 | 
 47 |     /**
 48 |      * Holds the after all repository.
 49 |      */
 50 |     public AfterAllRepository $afterAll;
 51 | 
 52 |     /**
 53 |      * Holds the snapshots repository.
 54 |      */
 55 |     public SnapshotRepository $snapshots;
 56 | 
 57 |     /**
 58 |      * Holds the root path.
 59 |      */
 60 |     public string $rootPath;
 61 | 
 62 |     /**
 63 |      * Holds an instance of the test suite.
 64 |      */
 65 |     private static ?TestSuite $instance = null;
 66 | 
 67 |     /**
 68 |      * Creates a new instance of the test suite.
 69 |      */
 70 |     public function __construct(
 71 |         string $rootPath,
 72 |         public string $testPath,
 73 |     ) {
 74 |         $this->beforeAll = new BeforeAllRepository;
 75 |         $this->beforeEach = new BeforeEachRepository;
 76 |         $this->tests = new TestRepository;
 77 |         $this->afterEach = new AfterEachRepository;
 78 |         $this->afterAll = new AfterAllRepository;
 79 |         $this->rootPath = (string) realpath($rootPath);
 80 |         $this->snapshots = new SnapshotRepository(
 81 |             implode(DIRECTORY_SEPARATOR, [$this->rootPath, $this->testPath]),
 82 |             implode(DIRECTORY_SEPARATOR, ['.pest', 'snapshots']),
 83 |         );
 84 |     }
 85 | 
 86 |     /**
 87 |      * Returns the current instance of the test suite.
 88 |      */
 89 |     public static function getInstance(
 90 |         ?string $rootPath = null,
 91 |         ?string $testPath = null,
 92 |     ): TestSuite {
 93 |         if (is_string($rootPath) && is_string($testPath)) {
 94 |             self::$instance = new TestSuite($rootPath, $testPath);
 95 | 
 96 |             foreach (Plugin::$callables as $callable) {
 97 |                 $callable();
 98 |             }
 99 | 
100 |             return self::$instance;
101 |         }
102 | 
103 |         if (! self::$instance instanceof self) {
104 |             Panic::with(new InvalidPestCommand);
105 |         }
106 | 
107 |         return self::$instance;
108 |     }
109 | 
110 |     public function getFilename(): string
111 |     {
112 |         assert($this->test instanceof TestCase);
113 | 
114 |         return (fn () => self::$__filename)->call($this->test, $this->test::class); // @phpstan-ignore-line
115 |     }
116 | 
117 |     public function getDescription(): string
118 |     {
119 |         assert($this->test instanceof TestCase);
120 | 
121 |         $description = str_replace('__pest_evaluable_', '', $this->test->name());
122 |         $datasetAsString = str_replace('__pest_evaluable_', '', Str::evaluable($this->test->dataSetAsStringWithData()));
123 | 
124 |         return str_replace(' ', '_', $description.$datasetAsString);
125 |     }
126 | 
127 |     public function registerSnapshotChange(string $message): void
128 |     {
129 |         assert($this->test instanceof TestCase);
130 | 
131 |         (fn (): string => $this->__snapshotChanges[] = $message)->call($this->test, $this->test::class); // @phpstan-ignore-line
132 |     }
133 | }
134 | 


--------------------------------------------------------------------------------
/stubs/Browser.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | use Laravel\Dusk\Browser;
 4 | 
 5 | it('has {name} page', function () {
 6 |     $this->browse(function (Browser $browser) {
 7 |         $browser->visit('/{name}')
 8 |             ->assertSee('{name}');
 9 |     });
10 | });
11 | 


--------------------------------------------------------------------------------
/stubs/Dataset.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | dataset('{dataset_name}', function () {
4 |     return ['{dataset_element} A', '{dataset_element} B'];
5 | });
6 | 


--------------------------------------------------------------------------------
/stubs/Feature.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | it('has {name} page', function () {
4 |     $response = $this->get('/{name}');
5 | 
6 |     $response->assertStatus(200);
7 | });
8 | 


--------------------------------------------------------------------------------
/stubs/Unit.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | test('{name}', function () {
4 |     expect(true)->toBeTrue();
5 | });
6 | 


--------------------------------------------------------------------------------
/stubs/init-laravel/Feature/ExampleTest.php.stub:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | it('returns a successful response', function () {
4 |     $response = $this->get('/');
5 | 
6 |     $response->assertStatus(200);
7 | });
8 | 


--------------------------------------------------------------------------------
/stubs/init-laravel/Pest.php.stub:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /*
 4 | |--------------------------------------------------------------------------
 5 | | Test Case
 6 | |--------------------------------------------------------------------------
 7 | |
 8 | | The closure you provide to your test functions is always bound to a specific PHPUnit test
 9 | | case class. By default, that class is "PHPUnit\Framework\TestCase". Of course, you may
10 | | need to change it using the "pest()" function to bind a different classes or traits.
11 | |
12 | */
13 | 
14 | pest()->extend(Tests\TestCase::class)
15 |  // ->use(Illuminate\Foundation\Testing\RefreshDatabase::class)
16 |     ->in('Feature');
17 | 
18 | /*
19 | |--------------------------------------------------------------------------
20 | | Expectations
21 | |--------------------------------------------------------------------------
22 | |
23 | | When you're writing tests, you often need to check that values meet certain conditions. The
24 | | "expect()" function gives you access to a set of "expectations" methods that you can use
25 | | to assert different things. Of course, you may extend the Expectation API at any time.
26 | |
27 | */
28 | 
29 | expect()->extend('toBeOne', function () {
30 |     return $this->toBe(1);
31 | });
32 | 
33 | /*
34 | |--------------------------------------------------------------------------
35 | | Functions
36 | |--------------------------------------------------------------------------
37 | |
38 | | While Pest is very powerful out-of-the-box, you may have some testing code specific to your
39 | | project that you don't want to repeat in every file. Here you can also expose helpers as
40 | | global functions to help you to reduce the number of lines of code in your test files.
41 | |
42 | */
43 | 
44 | function something()
45 | {
46 |     // ..
47 | }
48 | 


--------------------------------------------------------------------------------
/stubs/init-laravel/TestCase.php.stub:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Tests;
 4 | 
 5 | use Illuminate\Foundation\Testing\TestCase as BaseTestCase;
 6 | 
 7 | abstract class TestCase extends BaseTestCase
 8 | {
 9 |     //
10 | }
11 | 


--------------------------------------------------------------------------------
/stubs/init-laravel/Unit/ExampleTest.php.stub:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | test('that true is true', function () {
4 |     expect(true)->toBeTrue();
5 | });
6 | 


--------------------------------------------------------------------------------
/stubs/init-laravel/phpunit.xml.stub:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="UTF-8"?>
 2 | <phpunit xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 3 |          xsi:noNamespaceSchemaLocation="vendor/phpunit/phpunit/phpunit.xsd"
 4 |          bootstrap="vendor/autoload.php"
 5 |          colors="true"
 6 | >
 7 |     <testsuites>
 8 |         <testsuite name="Unit">
 9 |             <directory>tests/Unit</directory>
10 |         </testsuite>
11 |         <testsuite name="Feature">
12 |             <directory>tests/Feature</directory>
13 |         </testsuite>
14 |     </testsuites>
15 |     <source>
16 |         <include>
17 |             <directory>app</directory>
18 |         </include>
19 |     </source>
20 |     <php>
21 |         <env name="APP_ENV" value="testing"/>
22 |         <env name="APP_MAINTENANCE_DRIVER" value="file"/>
23 |         <env name="BCRYPT_ROUNDS" value="4"/>
24 |         <env name="CACHE_STORE" value="array"/>
25 |         <!-- <env name="DB_CONNECTION" value="sqlite"/> -->
26 |         <!-- <env name="DB_DATABASE" value=":memory:"/> -->
27 |         <env name="MAIL_MAILER" value="array"/>
28 |         <env name="PULSE_ENABLED" value="false"/>
29 |         <env name="QUEUE_CONNECTION" value="sync"/>
30 |         <env name="SESSION_DRIVER" value="array"/>
31 |         <env name="TELESCOPE_ENABLED" value="false"/>
32 |     </php>
33 | </phpunit>
34 | 


--------------------------------------------------------------------------------
/stubs/init/Feature/ExampleTest.php.stub:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | test('example', function () {
4 |     expect(true)->toBeTrue();
5 | });
6 | 


--------------------------------------------------------------------------------
/stubs/init/Pest.php.stub:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /*
 4 | |--------------------------------------------------------------------------
 5 | | Test Case
 6 | |--------------------------------------------------------------------------
 7 | |
 8 | | The closure you provide to your test functions is always bound to a specific PHPUnit test
 9 | | case class. By default, that class is "PHPUnit\Framework\TestCase". Of course, you may
10 | | need to change it using the "pest()" function to bind a different classes or traits.
11 | |
12 | */
13 | 
14 | pest()->extend(Tests\TestCase::class)->in('Feature');
15 | 
16 | /*
17 | |--------------------------------------------------------------------------
18 | | Expectations
19 | |--------------------------------------------------------------------------
20 | |
21 | | When you're writing tests, you often need to check that values meet certain conditions. The
22 | | "expect()" function gives you access to a set of "expectations" methods that you can use
23 | | to assert different things. Of course, you may extend the Expectation API at any time.
24 | |
25 | */
26 | 
27 | expect()->extend('toBeOne', function () {
28 |     return $this->toBe(1);
29 | });
30 | 
31 | /*
32 | |--------------------------------------------------------------------------
33 | | Functions
34 | |--------------------------------------------------------------------------
35 | |
36 | | While Pest is very powerful out-of-the-box, you may have some testing code specific to your
37 | | project that you don't want to repeat in every file. Here you can also expose helpers as
38 | | global functions to help you to reduce the number of lines of code in your test files.
39 | |
40 | */
41 | 
42 | function something()
43 | {
44 |     // ..
45 | }
46 | 


--------------------------------------------------------------------------------
/stubs/init/TestCase.php.stub:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Tests;
 4 | 
 5 | use PHPUnit\Framework\TestCase as BaseTestCase;
 6 | 
 7 | abstract class TestCase extends BaseTestCase
 8 | {
 9 |     //
10 | }
11 | 


--------------------------------------------------------------------------------
/stubs/init/Unit/ExampleTest.php.stub:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | test('example', function () {
4 |     expect(true)->toBeTrue();
5 | });
6 | 


--------------------------------------------------------------------------------
/stubs/init/phpunit.xml.stub:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="UTF-8"?>
 2 | <phpunit xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 3 |          xsi:noNamespaceSchemaLocation="vendor/phpunit/phpunit/phpunit.xsd"
 4 |          bootstrap="vendor/autoload.php"
 5 |          colors="true"
 6 | >
 7 |     <testsuites>
 8 |         <testsuite name="Test Suite">
 9 |             <directory suffix="Test.php">./tests</directory>
10 |         </testsuite>
11 |     </testsuites>
12 |     <source>
13 |         <include>
14 |             <directory>app</directory>
15 |             <directory>src</directory>
16 |         </include>
17 |     </source>
18 | </phpunit>
19 | 


--------------------------------------------------------------------------------