release: v4.6.2

.github/workflows/static.yml

@@ -11,6 +11,9 @@ concurrency:
   group: static-${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}
   cancel-in-progress: true
 
+permissions:
+  contents: read
+
 jobs:
   static:
     if: github.event_name != 'schedule' || github.repository == 'pestphp/pest'
@@ -44,7 +47,7 @@ jobs:
       uses: actions/cache@v5
       with:
         path: ${{ steps.composer-cache.outputs.dir }}
-        key: static-php-8.3-${{ matrix.dependency-version }}-composer-${{ hashFiles('**/composer.json') }}
+        key: static-php-8.3-${{ matrix.dependency-version }}-composer-${{ hashFiles('**/composer.json', '**/composer.lock') }}
         restore-keys: |
           static-php-8.3-${{ matrix.dependency-version }}-composer-
           static-php-8.3-composer-

.github/workflows/tests.yml

@@ -11,6 +11,9 @@ concurrency:
   group: tests-${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}
   cancel-in-progress: true
 
+permissions:
+  contents: read
+
 jobs:
   tests:
     if: github.event_name != 'schedule' || github.repository == 'pestphp/pest'
@@ -51,7 +54,7 @@ jobs:
       uses: actions/cache@v5
       with:
         path: ${{ steps.composer-cache.outputs.dir }}
-        key: ${{ matrix.os }}-php-${{ matrix.php }}-symfony-${{ matrix.symfony }}-composer-${{ hashFiles('**/composer.json') }}
+        key: ${{ matrix.os }}-php-${{ matrix.php }}-symfony-${{ matrix.symfony }}-composer-${{ hashFiles('**/composer.json', '**/composer.lock') }}
         restore-keys: |
           ${{ matrix.os }}-php-${{ matrix.php }}-symfony-${{ matrix.symfony }}-composer-
           ${{ matrix.os }}-php-${{ matrix.php }}-composer-

composer.json

@@ -25,12 +25,12 @@
         "pestphp/pest-plugin-arch": "^4.0.2",
         "pestphp/pest-plugin-mutate": "^4.0.1",
         "pestphp/pest-plugin-profanity": "^4.2.1",
-        "phpunit/phpunit": "^12.5.16",
+        "phpunit/phpunit": "^12.5.22",
         "symfony/process": "^7.4.8|^8.0.8"
     },
     "conflict": {
         "filp/whoops": "<2.18.3",
-        "phpunit/phpunit": ">12.5.16",
+        "phpunit/phpunit": ">12.5.22",
         "sebastian/exporter": "<7.0.0",
         "webmozart/assert": "<1.11.0"
     },

overrides/Logging/JUnit/JunitXmlLogger.php

@@ -1,6 +1,39 @@
 <?php
 
+/*
+ * BSD 3-Clause License
+ *
+ * Copyright (c) 2001-2023, Sebastian Bergmann
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its
+ *    contributors may be used to endorse or promote products derived from
+ *    this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
 declare(strict_types=1);
+
 /*
  * This file is part of PHPUnit.
  *

overrides/Runner/TestSuiteSorter.php

@@ -0,0 +1,388 @@
+<?php
+
+/*
+ * BSD 3-Clause License
+ *
+ * Copyright (c) 2001-2023, Sebastian Bergmann
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its
+ *    contributors may be used to endorse or promote products derived from
+ *    this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+declare(strict_types=1);
+
+/*
+ * This file is part of PHPUnit.
+ *
+ * (c) Sebastian Bergmann <sebastian@phpunit.de>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace PHPUnit\Runner;
+
+use PHPUnit\Framework\DataProviderTestSuite;
+use PHPUnit\Framework\Reorderable;
+use PHPUnit\Framework\Test;
+use PHPUnit\Framework\TestCase;
+use PHPUnit\Framework\TestSuite;
+use PHPUnit\Runner\ResultCache\NullResultCache;
+use PHPUnit\Runner\ResultCache\ResultCache;
+use PHPUnit\Runner\ResultCache\ResultCacheId;
+
+use function array_diff;
+use function array_merge;
+use function array_reverse;
+use function array_splice;
+use function assert;
+use function count;
+use function in_array;
+use function max;
+use function shuffle;
+use function usort;
+
+/**
+ * @internal This class is not covered by the backward compatibility promise for PHPUnit
+ */
+final class TestSuiteSorter
+{
+    public const int ORDER_DEFAULT = 0;
+
+    public const int ORDER_RANDOMIZED = 1;
+
+    public const int ORDER_REVERSED = 2;
+
+    public const int ORDER_DEFECTS_FIRST = 3;
+
+    public const int ORDER_DURATION = 4;
+
+    public const int ORDER_SIZE = 5;
+
+    /**
+     * @var non-empty-array<non-empty-string, positive-int>
+     */
+    private const array SIZE_SORT_WEIGHT = [
+        'small' => 1,
+        'medium' => 2,
+        'large' => 3,
+        'unknown' => 4,
+    ];
+
+    /**
+     * @var array<string, int> Associative array of (string => DEFECT_SORT_WEIGHT) elements
+     */
+    private array $defectSortOrder = [];
+
+    private readonly ResultCache $cache;
+
+    public function __construct(?ResultCache $cache = null)
+    {
+        $this->cache = $cache ?? new NullResultCache;
+    }
+
+    /**
+     * @throws Exception
+     */
+    public function reorderTestsInSuite(Test $suite, int $order, bool $resolveDependencies, int $orderDefects): void
+    {
+        $allowedOrders = [
+            self::ORDER_DEFAULT,
+            self::ORDER_REVERSED,
+            self::ORDER_RANDOMIZED,
+            self::ORDER_DURATION,
+            self::ORDER_SIZE,
+        ];
+
+        if (! in_array($order, $allowedOrders, true)) {
+            // @codeCoverageIgnoreStart
+            throw new InvalidOrderException;
+            // @codeCoverageIgnoreEnd
+        }
+
+        $allowedOrderDefects = [
+            self::ORDER_DEFAULT,
+            self::ORDER_DEFECTS_FIRST,
+        ];
+
+        if (! in_array($orderDefects, $allowedOrderDefects, true)) {
+            // @codeCoverageIgnoreStart
+            throw new InvalidOrderException;
+            // @codeCoverageIgnoreEnd
+        }
+
+        if ($suite instanceof TestSuite) {
+            foreach ($suite as $_suite) {
+                $this->reorderTestsInSuite($_suite, $order, $resolveDependencies, $orderDefects);
+            }
+
+            if ($orderDefects === self::ORDER_DEFECTS_FIRST) {
+                $this->addSuiteToDefectSortOrder($suite);
+            }
+
+            $this->sort($suite, $order, $resolveDependencies, $orderDefects);
+        }
+    }
+
+    private function sort(TestSuite $suite, int $order, bool $resolveDependencies, int $orderDefects): void
+    {
+        if ($suite->tests() === []) {
+            return;
+        }
+
+        if ($order === self::ORDER_REVERSED) {
+            $suite->setTests($this->reverse($suite->tests()));
+        } elseif ($order === self::ORDER_RANDOMIZED) {
+            $suite->setTests($this->randomize($suite->tests()));
+        } elseif ($order === self::ORDER_DURATION) {
+            $suite->setTests($this->sortByDuration($suite->tests()));
+        } elseif ($order === self::ORDER_SIZE) {
+            $suite->setTests($this->sortBySize($suite->tests()));
+        }
+
+        if ($orderDefects === self::ORDER_DEFECTS_FIRST) {
+            $suite->setTests($this->sortDefectsFirst($suite->tests()));
+        }
+
+        if ($resolveDependencies && ! ($suite instanceof DataProviderTestSuite)) {
+            $tests = $suite->tests();
+
+            /** @noinspection PhpParamsInspection */
+            /** @phpstan-ignore argument.type */
+            $suite->setTests($this->resolveDependencies($tests));
+        }
+    }
+
+    private function addSuiteToDefectSortOrder(TestSuite $suite): void
+    {
+        $max = 0;
+
+        foreach ($suite->tests() as $test) {
+            assert($test instanceof Reorderable);
+
+            $sortId = $test->sortId();
+
+            if (! isset($this->defectSortOrder[$sortId])) {
+                $this->defectSortOrder[$sortId] = $this->cache->status(ResultCacheId::fromReorderable($test))->asInt();
+                $max = max($max, $this->defectSortOrder[$sortId]);
+            }
+        }
+
+        $this->defectSortOrder[$suite->sortId()] = $max;
+    }
+
+    /**
+     * @param  list<Test>  $tests
+     * @return list<Test>
+     */
+    private function reverse(array $tests): array
+    {
+        return array_reverse($tests);
+    }
+
+    /**
+     * @param  list<Test>  $tests
+     * @return list<Test>
+     */
+    private function randomize(array $tests): array
+    {
+        shuffle($tests);
+
+        return $tests;
+    }
+
+    /**
+     * @param  list<Test>  $tests
+     * @return list<Test>
+     */
+    private function sortDefectsFirst(array $tests): array
+    {
+        usort(
+            $tests,
+            fn (Test $left, Test $right) => $this->cmpDefectPriorityAndTime($left, $right),
+        );
+
+        return $tests;
+    }
+
+    /**
+     * @param  list<Test>  $tests
+     * @return list<Test>
+     */
+    private function sortByDuration(array $tests): array
+    {
+        usort(
+            $tests,
+            fn (Test $left, Test $right) => $this->cmpDuration($left, $right),
+        );
+
+        return $tests;
+    }
+
+    /**
+     * @param  list<Test>  $tests
+     * @return list<Test>
+     */
+    private function sortBySize(array $tests): array
+    {
+        usort(
+            $tests,
+            fn (Test $left, Test $right) => $this->cmpSize($left, $right),
+        );
+
+        return $tests;
+    }
+
+    /**
+     * Comparator callback function to sort tests for "reach failure as fast as possible".
+     *
+     * 1. sort tests by defect weight defined in self::DEFECT_SORT_WEIGHT
+     * 2. when tests are equally defective, sort the fastest to the front
+     * 3. do not reorder successful tests
+     */
+    private function cmpDefectPriorityAndTime(Test $a, Test $b): int
+    {
+        assert($a instanceof Reorderable);
+        assert($b instanceof Reorderable);
+
+        $priorityA = $this->defectSortOrder[$a->sortId()] ?? 0;
+        $priorityB = $this->defectSortOrder[$b->sortId()] ?? 0;
+
+        if ($priorityA !== $priorityB) {
+            // Sort defect weight descending
+            return $priorityB <=> $priorityA;
+        }
+
+        if ($priorityA > 0 || $priorityB > 0) {
+            return $this->cmpDuration($a, $b);
+        }
+
+        // do not change execution order
+        return 0;
+    }
+
+    /**
+     * Compares test duration for sorting tests by duration ascending.
+     */
+    private function cmpDuration(Test $a, Test $b): int
+    {
+        if (! ($a instanceof Reorderable && $b instanceof Reorderable)) {
+            return 0;
+        }
+
+        return $this->cache->time(ResultCacheId::fromReorderable($a)) <=> $this->cache->time(ResultCacheId::fromReorderable($b));
+    }
+
+    /**
+     * Compares test size for sorting tests small->medium->large->unknown.
+     */
+    private function cmpSize(Test $a, Test $b): int
+    {
+        $sizeA = ($a instanceof TestCase || $a instanceof DataProviderTestSuite)
+            ? $a->size()->asString()
+            : 'unknown';
+        $sizeB = ($b instanceof TestCase || $b instanceof DataProviderTestSuite)
+            ? $b->size()->asString()
+            : 'unknown';
+
+        return self::SIZE_SORT_WEIGHT[$sizeA] <=> self::SIZE_SORT_WEIGHT[$sizeB];
+    }
+
+    /**
+     * Reorder Tests within a TestCase in such a way as to resolve as many dependencies as possible.
+     * The algorithm will leave the tests in original running order when it can.
+     * For more details see the documentation for test dependencies.
+     *
+     * Short description of algorithm:
+     * 1. Pick the next Test from remaining tests to be checked for dependencies.
+     * 2. If the test has no dependencies: mark done, start again from the top
+     * 3. If the test has dependencies but none left to do: mark done, start again from the top
+     * 4. When we reach the end add any leftover tests to the end. These will be marked 'skipped' during execution.
+     *
+     * @param  array<TestCase>  $tests
+     * @return array<TestCase>
+     */
+    private function resolveDependencies(array $tests): array
+    {
+        // Pest: Fast-path. If no test in this suite declares dependencies, the
+        // original O(N^2) algorithm is wasted work — it would splice each test
+        // one-by-one back into the same order. The check deliberately walks
+        // TestCase instances directly instead of calling TestSuite::requires(),
+        // because the latter lazily builds TestSuite::provides() via
+        // ExecutionOrderDependency::mergeUnique, which is O(N^2) in the total
+        // number of tests. With thousands of tests that single call alone can
+        // burn several seconds before the sort even begins. Reading the
+        // cached TestCase::$dependencies property stays O(N) and costs nothing
+        // when no test uses `->depends()` / PHPUnit `@depends`.
+        if (! $this->anyTestHasDependencies($tests)) {
+            return $tests;
+        }
+
+        $newTestOrder = [];
+        $i = 0;
+        $provided = [];
+
+        do {
+            if (array_diff($tests[$i]->requires(), $provided) === []) {
+                $provided = array_merge($provided, $tests[$i]->provides());
+                $newTestOrder = array_merge($newTestOrder, array_splice($tests, $i, 1));
+                $i = 0;
+            } else {
+                $i++;
+            }
+        } while ($tests !== [] && ($i < count($tests)));
+
+        return array_merge($newTestOrder, $tests);
+    }
+
+    /**
+     * Cheaply determines whether any test in the tree declares @depends.
+     *
+     * Walks `TestSuite` containers recursively and inspects each `TestCase`
+     * directly so it never triggers `TestSuite::provides()`, which is O(N^2)
+     * in the total number of aggregated tests.
+     *
+     * @param  iterable<Test>  $tests
+     */
+    private function anyTestHasDependencies(iterable $tests): bool
+    {
+        foreach ($tests as $test) {
+            if ($test instanceof TestSuite) {
+                if ($this->anyTestHasDependencies($test->tests())) {
+                    return true;
+                }
+
+                continue;
+            }
+
+            if ($test instanceof TestCase && $test->requires() !== []) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+}

src/Bootstrappers/BootOverrides.php

@@ -21,6 +21,7 @@ final class BootOverrides implements Bootstrapper
         'Runner/Filter/NameFilterIterator.php',
         'Runner/ResultCache/DefaultResultCache.php',
         'Runner/TestSuiteLoader.php',
+        'Runner/TestSuiteSorter.php',
         'TextUI/Command/Commands/WarmCodeCoverageCacheCommand.php',
         'TextUI/Output/Default/ProgressPrinter/Subscriber/TestSkippedSubscriber.php',
         'TextUI/TestSuiteFilterProcessor.php',

src/Mixins/Expectation.php

@@ -14,6 +14,7 @@ use InvalidArgumentException;
 use JsonSerializable;
 use Pest\Exceptions\InvalidExpectationValue;
 use Pest\Matchers\Any;
+use Pest\Plugins\Snapshot;
 use Pest\Support\Arr;
 use Pest\Support\Exporter;
 use Pest\Support\NullClosure;
@@ -851,18 +852,31 @@ final class Expectation
             default => InvalidExpectationValue::expected('array|object|string'),
         };
 
-        if ($snapshots->has()) {
-            [$filename, $content] = $snapshots->get();
-
-            Assert::assertSame(
-                strtr($content, ["\r\n" => "\n", "\r" => "\n"]),
-                strtr($string, ["\r\n" => "\n", "\r" => "\n"]),
-                $message === '' ? "Failed asserting that the string value matches its snapshot ($filename)." : $message
-            );
-        } else {
+        if (! $snapshots->has()) {
             $filename = $snapshots->save($string);
 
             TestSuite::getInstance()->registerSnapshotChange("Snapshot created at [$filename]");
+        } else {
+            [$filename, $content] = $snapshots->get();
+
+            $normalizedContent = strtr($content, ["\r\n" => "\n", "\r" => "\n"]);
+            $normalizedString = strtr($string, ["\r\n" => "\n", "\r" => "\n"]);
+
+            if (Snapshot::$updateSnapshots && $normalizedContent !== $normalizedString) {
+                $snapshots->save($string);
+
+                TestSuite::getInstance()->registerSnapshotChange("Snapshot updated at [$filename]");
+            } else {
+                if (Snapshot::$updateSnapshots) {
+                    TestSuite::getInstance()->registerSnapshotChange("Snapshot unchanged at [$filename]");
+                }
+
+                Assert::assertSame(
+                    $normalizedContent,
+                    $normalizedString,
+                    $message === '' ? "Failed asserting that the string value matches its snapshot ($filename)." : $message
+                );
+            }
         }
 
         return $this;

src/Pest.php

@@ -6,7 +6,7 @@ namespace Pest;
 
 function version(): string
 {
-    return '4.6.0';
+    return '4.6.2';
 }
 
 function testDirectory(string $file = ''): string

src/Plugins/Snapshot.php

@@ -5,7 +5,6 @@ declare(strict_types=1);
 namespace Pest\Plugins;
 
 use Pest\Contracts\Plugins\HandlesArguments;
-use Pest\Exceptions\InvalidOption;
 use Pest\TestSuite;
 
 /**
@@ -15,21 +14,116 @@ final class Snapshot implements HandlesArguments
 {
     use Concerns\HandleArguments;
 
+    /**
+     * Whether snapshots should be updated on this run.
+     */
+    public static bool $updateSnapshots = false;
+
     /**
      * {@inheritDoc}
      */
     public function handleArguments(array $arguments): array
     {
+        if (Parallel::isWorker() && Parallel::getGlobal('UPDATE_SNAPSHOTS') === true) {
+            self::$updateSnapshots = true;
+
+            return $arguments;
+        }
+
         if (! $this->hasArgument('--update-snapshots', $arguments)) {
             return $arguments;
         }
 
-        if ($this->hasArgument('--parallel', $arguments)) {
-            throw new InvalidOption('The [--update-snapshots] option is not supported when running in parallel.');
+        self::$updateSnapshots = true;
+
+        if ($this->isFullRun($arguments)) {
+            TestSuite::getInstance()->snapshots->flush();
         }
 
-        TestSuite::getInstance()->snapshots->flush();
+        if ($this->hasArgument('--parallel', $arguments) || $this->hasArgument('-p', $arguments)) {
+            Parallel::setGlobal('UPDATE_SNAPSHOTS', true);
+        }
 
         return $this->popArgument('--update-snapshots', $arguments);
     }
+
+    /**
+     * Options that take a value as the next argument (rather than via "=value").
+     *
+     * @var list<string>
+     */
+    private const array FLAGS_WITH_VALUES = [
+        '--filter',
+        '--group',
+        '--exclude-group',
+        '--test-suffix',
+        '--covers',
+        '--uses',
+        '--cache-directory',
+        '--cache-result-file',
+        '--configuration',
+        '--colors',
+        '--test-directory',
+        '--bootstrap',
+        '--order-by',
+        '--random-order-seed',
+        '--log-junit',
+        '--log-teamcity',
+        '--log-events-text',
+        '--log-events-verbose-text',
+        '--coverage-clover',
+        '--coverage-cobertura',
+        '--coverage-crap4j',
+        '--coverage-html',
+        '--coverage-php',
+        '--coverage-text',
+        '--coverage-xml',
+        '--assignee',
+        '--issue',
+        '--ticket',
+        '--pr',
+        '--pull-request',
+        '--retry',
+        '--shard',
+        '--repeat',
+    ];
+
+    /**
+     * Determines whether the command targets the entire suite (no filter, no path).
+     *
+     * @param  array<int, string>  $arguments
+     */
+    private function isFullRun(array $arguments): bool
+    {
+        if ($this->hasArgument('--filter', $arguments)) {
+            return false;
+        }
+
+        $tokens = array_slice($arguments, 1);
+        $skipNext = false;
+
+        foreach ($tokens as $arg) {
+            if ($skipNext) {
+                $skipNext = false;
+
+                continue;
+            }
+
+            if ($arg === '') {
+                continue;
+            }
+
+            if ($arg[0] === '-') {
+                if (in_array($arg, self::FLAGS_WITH_VALUES, true)) {
+                    $skipNext = true;
+                }
+
+                continue;
+            }
+
+            return false;
+        }
+
+        return true;
+    }
 }

src/Repositories/SnapshotRepository.php

@@ -59,8 +59,10 @@ final class SnapshotRepository
     {
         $snapshotFilename = $this->getSnapshotFilename();
 
-        if (! file_exists(dirname($snapshotFilename))) {
-            mkdir(dirname($snapshotFilename), 0755, true);
+        $directory = dirname($snapshotFilename);
+
+        if (! is_dir($directory)) {
+            @mkdir($directory, 0755, true);
         }
 
         file_put_contents($snapshotFilename, $snapshot);

tests/.pest/snapshots/Features/Expect/toMatchSnapshot/failures.snap

@@ -1,7 +0,0 @@
-    <div class="container">
-        <div class="row">
-            <div class="col-md-12">
-                <h1>Snapshot</h1>
-            </div>
-        </div>
-    </div>

tests/.pest/snapshots/Features/Expect/toMatchSnapshot/failures_with_custom_message.snap

@@ -1,7 +0,0 @@
-    <div class="container">
-        <div class="row">
-            <div class="col-md-12">
-                <h1>Snapshot</h1>
-            </div>
-        </div>
-    </div>

tests/.pest/snapshots/Visual/Help/visual_snapshot_of_help_command_output.snap

@@ -1,5 +1,5 @@
 
-  Pest Testing Framework 4.6.0.  
+  Pest Testing Framework 4.6.2.  
 
   USAGE: pest <file> [options]  
 
@@ -91,7 +91,11 @@
   --cache-result ............................ Write test results to cache file  
   --do-not-cache-result .............. Do not write test results to cache file  
   --order-by [order]  Run tests in order: default|defects|depends|duration|no-depends|random|reverse|size  
+  --resolve-dependencies ...................... Alias for "--order-by depends"  
+  --ignore-dependencies .................... Alias for "--order-by no-depends"  
+  --random-order ............................... Alias for "--order-by random"  
   --random-order-seed [N]  Use the specified random seed when running tests in random order  
+  --reverse-order ............................. Alias for "--order-by reverse"  
 
   REPORTING OPTIONS:
   --colors=[flag] ......... Use colors in output ("never", "auto" or "always")  

tests/.pest/snapshots/Visual/Version/visual_snapshot_of_help_command_output.snap

@@ -1,3 +1,3 @@
 
-  Pest Testing Framework 4.6.0.  
+  Pest Testing Framework 4.6.2.  
 

tests/.snapshots/success.txt

@@ -1037,8 +1037,6 @@
   ✓ pass with toArray
   ✓ pass with array
   ✓ pass with toSnapshot
-  ✓ failures
-  ✓ failures with custom message
   ✓ not failures
   ✓ multiple snapshot expectations
   ✓ multiple snapshot expectations with datasets with (1)
@@ -1903,4 +1901,4 @@
   ✓ pass with dataset with ('my-datas-set-value')
   ✓ within describe → pass with dataset with ('my-datas-set-value')
 
-  Tests:    2 deprecated, 4 warnings, 5 incomplete, 2 notices, 40 todos, 35 skipped, 1296 passed (2977 assertions)
+  Tests:    2 deprecated, 4 warnings, 5 incomplete, 2 notices, 40 todos, 35 skipped, 1294 passed (2971 assertions)

tests/Features/Expect/toMatchSnapshot.php

@@ -134,18 +134,6 @@ test('pass with `toSnapshot`', function () {
     expect($object)->toMatchSnapshot();
 });
 
-test('failures', function () {
-    TestSuite::getInstance()->snapshots->save($this->snapshotable);
-
-    expect('contain that does not match snapshot')->toMatchSnapshot();
-})->throws(ExpectationFailedException::class, 'Failed asserting that two strings are identical.');
-
-test('failures with custom message', function () {
-    TestSuite::getInstance()->snapshots->save($this->snapshotable);
-
-    expect('contain that does not match snapshot')->toMatchSnapshot('oh no');
-})->throws(ExpectationFailedException::class, 'oh no');
-
 test('not failures', function () {
     TestSuite::getInstance()->snapshots->save($this->snapshotable);
 

tests/Pest.php

@@ -86,5 +86,12 @@ dataset('dataset_in_pest_file', ['A', 'B']);
 
 function removeAnsiEscapeSequences(string $input): ?string
 {
-    return preg_replace('#\\x1b[[][^A-Za-z]*[A-Za-z]#', '', $input);
+    return preg_replace(
+        [
+            '#\\x1b[[][^A-Za-z]*[A-Za-z]#',       // CSI (colors, cursor, etc.)
+            '#\\x1b\\]8;[^\\x1b\\x07]*(?:\\x1b\\\\|\\x07)#', // OSC 8 hyperlinks
+        ],
+        '',
+        $input,
+    );
 }

tests/Visual/Parallel.php

@@ -23,13 +23,13 @@ test('parallel', function () use ($run) {
         $file = file_get_contents(__FILE__);
         $file = preg_replace(
             '/\$expected = \'.*?\';/',
-            "\$expected = '2 deprecated, 4 warnings, 5 incomplete, 3 notices, 40 todos, 27 skipped, 1280 passed (2926 assertions)';",
+            "\$expected = '2 deprecated, 4 warnings, 5 incomplete, 3 notices, 40 todos, 27 skipped, 1278 passed (2920 assertions)';",
             $file,
         );
         file_put_contents(__FILE__, $file);
     }
 
-    $expected = '2 deprecated, 4 warnings, 5 incomplete, 3 notices, 40 todos, 27 skipped, 1280 passed (2926 assertions)';
+    $expected = '2 deprecated, 4 warnings, 5 incomplete, 3 notices, 40 todos, 27 skipped, 1278 passed (2920 assertions)';
 
     expect($output)
         ->toContain("Tests:    {$expected}")

tests/Visual/Success.php

@@ -21,8 +21,10 @@ test('visual snapshot of test suite on success', function () {
 
         return preg_replace([
             '#\\x1b[[][^A-Za-z]*[A-Za-z]#',
+            '#\\x1b\\]8;[^\\x1b\\x07]*(?:\\x1b\\\\|\\x07)#',
             '/(Tests\\\PHPUnit\\\CustomAffixes\\\InvalidTestName)([A-Za-z0-9]*)/',
         ], [
+            '',
             '',
             '$1',
         ], $process->getOutput());