chore: release 1.1.0

Reusable hooks

.github/FUNDING.yml

@@ -1,5 +1,5 @@
 # These are supported funding model platforms
 
-github: nunomaduro
+github: [nunomaduro,owenvoke,olivernybroe,octoper]
 patreon: nunomaduro
 custom: https://www.paypal.com/cgi-bin/webscr?cmd=_s-xclick&hosted_button_id=66BYDWAT92N6L

.github/workflows/static.yml

@@ -15,16 +15,13 @@ jobs:
     - name: Setup PHP
       uses: shivammathur/setup-php@v2
       with:
-        php-version: 7.4
+        php-version: 8.0
         tools: composer:v2
         coverage: none
 
     - name: Install Dependencies
       run: composer update --no-interaction --no-progress
 
-    - name: Run Rector
-      run: vendor/bin/rector process src --dry-run
-
     - name: Run PHP-CS-Fixer
       run: vendor/bin/php-cs-fixer fix -v --allow-risky=yes --dry-run
 
@@ -43,7 +40,7 @@ jobs:
     - name: Setup PHP
       uses: shivammathur/setup-php@v2
       with:
-        php-version: 7.4
+        php-version: 8.0
         tools: composer:v2
         coverage: none
 

CHANGELOG.md

@@ -4,6 +4,83 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](http://keepachangelog.com/)
 and this project adheres to [Semantic Versioning](http://semver.org/).
 
+## [v1.1.0 (2021-05-02)](https://github.com/pestphp/pest/compare/v1.0.5...v1.1.0)
+### Added
+- Possibility of "hooks" being added using the "uses" function ([#282](https://github.com/pestphp/pest/pull/282))
+
+## [v1.0.5 (2021-03-31)](https://github.com/pestphp/pest/compare/v1.0.4...v1.0.5)
+### Added
+- Add `--browse` option to `pest:dusk` command ([#280](https://github.com/pestphp/pest/pull/280))
+- Support for PHPUnit 9.5.4 ([#284](https://github.com/pestphp/pest/pull/284))
+
+## [v1.0.4 (2021-03-17)](https://github.com/pestphp/pest/compare/v1.0.3...v1.0.4)
+### Added
+- Support for PHPUnit 9.5.3 ([#278](https://github.com/pestphp/pest/pull/278))
+
+## [v1.0.3 (2021-03-13)](https://github.com/pestphp/pest/compare/v1.0.2...v1.0.3)
+### Added
+- Support for test extensions ([#269](https://github.com/pestphp/pest/pull/269))
+
+## [v1.0.2 (2021-02-04)](https://github.com/pestphp/pest/compare/v1.0.1...v1.0.2)
+### Added
+- Support for PHPUnit 9.5.2 ([#267](https://github.com/pestphp/pest/pull/267))
+
+## [v1.0.1 (2021-01-18)](https://github.com/pestphp/pest/compare/v1.0.0...v1.0.1)
+### Added
+- Support for PHPUnit 9.5.1 ([#261](https://github.com/pestphp/pest/pull/261))
+
+### Fixed
+- Fix `TestCase@expect` PHPDoc tag ([#251](https://github.com/pestphp/pest/pull/251))
+
+## [v1.0.0 (2021-01-03)](https://github.com/pestphp/pest/compare/v0.3.19...v1.0.0)
+### Added
+- `pest:test --dusk` option ([#245](https://github.com/pestphp/pest/pull/245))
+
+### Changed
+- Stable version
+- Updates init structure ([#240](https://github.com/pestphp/pest/pull/240))
+
+## [v0.3.19 (2020-12-27)](https://github.com/pestphp/pest/compare/v0.3.18...v0.3.19)
+### Fixed
+- Fix binary path in `pest:dusk` command ([#239](https://github.com/pestphp/pest/pull/239))
+
+## [v0.3.18 (2020-12-26)](https://github.com/pestphp/pest/compare/v0.3.17...v0.3.18)
+### Added
+- `toBeJson()` expectation ([plugin-expectations#2](https://github.com/pestphp/pest-plugin-expectations/pull/2))
+
+## [v0.3.17 (2020-12-20)](https://github.com/pestphp/pest/compare/v0.3.16...v0.3.17)
+### Fixed
+- Class inheritance with `depends()` ([#236](https://github.com/pestphp/pest/pull/236))
+
+## [v0.3.16 (2020-12-13)](https://github.com/pestphp/pest/compare/v0.3.15...v0.3.16)
+### Changed
+- Moves expectation API for external plugin ([5d7f262](https://github.com/pestphp/pest/commit/5d7f262f4ab280a660a85900f402eebb23abfda8))
+
+## [v0.3.15 (2020-12-04)](https://github.com/pestphp/pest/compare/v0.3.14...v0.3.15)
+### Added
+- Support for PHPUnit 9.5.0 ([#234](https://github.com/pestphp/pest/pull/234))
+- Support for extending expectation API ([#232](https://github.com/pestphp/pest/pull/232))
+
+### Fixed
+- Static analysis while using string as key for datasets ([#233](https://github.com/pestphp/pest/pull/233))
+
+## [v0.3.14 (2020-11-28)](https://github.com/pestphp/pest/compare/v0.3.13...v0.3.14)
+### Added
+- `pest:dusk` command ([#223](https://github.com/pestphp/pest/pull/223))
+- Better feedback on errors in `toMatchArray` and `toMatchObject` ([#231](https://github.com/pestphp/pest/pull/231))
+
+## [v0.3.13 (2020-11-23)](https://github.com/pestphp/pest/compare/v0.3.12...v0.3.13)
+### Added
+- `toMatchArray` expectation ([7bea51f](https://github.com/pestphp/pest/commit/7bea51fe09dd2eca7093e4c34cf2dab2e8d39fa5), [3fd24d9](https://github.com/pestphp/pest/commit/3fd24d96d3145dcebdb0aab40aa8b76faa8b6979))
+- Add Pest options to `--help` output ([#217](https://github.com/pestphp/pest/pull/217))
+
+### Fixed
+- Resolve issue with name resolution in `depends()` ([#216](https://github.com/pestphp/pest/pull/216))
+
+## [v0.3.12 (2020-11-11)](https://github.com/pestphp/pest/compare/v0.3.11...v0.3.12)
+### Added
+- Add support for PHPUnit 9.4.3 ([#219](https://github.com/pestphp/pest/pull/219))
+
 ## [v0.3.11 (2020-11-09)](https://github.com/pestphp/pest/compare/v0.3.10...v0.3.11)
 ### Changed
 - Improved the exception output for the TeamCity printer (usage with phpstorm plugin) ([#215](https://github.com/pestphp/pest/pull/215))

README.md

@@ -21,6 +21,8 @@ We would like to extend our thanks to the following sponsors for funding Pest de
 
 ### Premium Sponsors
 
-- **[Scout APM](https://github.com/scoutapp)**
+- **[Scout APM](https://scoutapm.com)**
+- **[Akaunting](https://akaunting.com)**
+- **[Meema](https://meema.io/)**
 
 Pest was created by **[Nuno Maduro](https://twitter.com/enunomaduro)** under the **[Sponsorware license](https://github.com/sponsorware/docs)**. It got open-sourced and is now licensed under the **[MIT license](https://opensource.org/licenses/MIT)**.

RELEASE.md

@@ -0,0 +1,16 @@
+# Release process
+
+When releasing a new version of Pest there are some checks and updates that need to be done:
+
+- Clear your local repository with: `git add . && git reset --hard && git checkout master` 
+- On the GitHub repository, check the contents of [github.com/pestphp/pest/compare/{latest_version}...master](https://github.com/pestphp/pest/compare/{latest_version}...master) and update the [changelog](CHANGELOG.md) file with the main changes for this release
+- Update the version number in [src/Pest.php](src/Pest.php)
+- Run the tests locally using: `composer test`
+- Commit the CHANGELOG and Pest file with the message: `git commit -m "docs: update changelog"`
+- Push the changes to GitHub
+- Check that the CI is passing as expected: [github.com/pestphp/pest/actions](https://github.com/pestphp/pest/actions)
+- Tag and push the tag with `git tag vX.X.X && git push --tags`
+
+### Plugins
+
+Plugins should be versioned using the same major (or minor for `0.x` releases) version as Pest core.

bin/pest

@@ -19,13 +19,16 @@ use Symfony\Component\Console\Output\OutputInterface;
 
     if (file_exists($vendorPath)) {
         include_once $vendorPath;
+        $autoloadPath = $vendorPath;
     } else {
         include_once $localPath;
+        $autoloadPath = $localPath;
     }
 
     (new Provider())->register();
 
-    $rootPath = getcwd();
+    // get $rootPath based on $autoloadPath
+    $rootPath =  dirname($autoloadPath, 2);
 
     $testSuite = TestSuite::getInstance($rootPath);
 

composer.json

@@ -19,17 +19,18 @@
     "require": {
         "php": "^7.3 || ^8.0",
         "nunomaduro/collision": "^5.0",
-        "pestphp/pest-plugin": "^0.3",
-        "pestphp/pest-plugin-coverage": "^0.3",
-        "pestphp/pest-plugin-init": "^0.3",
-        "phpunit/phpunit": ">= 9.3.7 <= 9.4.2"
+        "pestphp/pest-plugin": "^1.0",
+        "pestphp/pest-plugin-coverage": "^1.0",
+        "pestphp/pest-plugin-expectations": "^1.0",
+        "pestphp/pest-plugin-init": "^1.0",
+        "phpunit/phpunit": ">= 9.3.7 <= 9.5.4"
     },
     "autoload": {
         "psr-4": {
             "Pest\\": "src/"
         },
         "files": [
-            "src/globals.php",
+            "src/Functions.php",
             "src/Pest.php"
         ]
     },
@@ -42,9 +43,10 @@
         ]
     },
     "require-dev": {
-        "illuminate/console": "^7.16.1",
-        "illuminate/support": "^7.16.1",
-        "mockery/mockery": "^1.4.1",
+        "illuminate/console": "^8.32.1",
+        "illuminate/support": "^8.32.1",
+        "laravel/dusk": "^6.13.0",
+        "mockery/mockery": "^1.4.3",
         "pestphp/pest-dev-tools": "dev-master"
     },
     "minimum-stability": "dev",
@@ -57,8 +59,8 @@
         "bin/pest"
     ],
     "scripts": {
-        "lint": "rector process src && php-cs-fixer fix -v",
-        "test:lint": "php-cs-fixer fix -v --dry-run && rector process src --dry-run",
+        "lint": "php-cs-fixer fix -v",
+        "test:lint": "php-cs-fixer fix -v --dry-run",
         "test:types": "phpstan analyse --ansi --memory-limit=0",
         "test:unit": "php bin/pest --colors=always --exclude-group=integration",
         "test:integration": "php bin/pest --colors=always --group=integration",
@@ -72,7 +74,7 @@
     },
     "extra": {
         "branch-alias": {
-            "dev-master": "0.4.x-dev"
+            "dev-master": "1.x-dev"
         },
         "pest": {
             "plugins": [

phpstan.neon

@@ -7,15 +7,13 @@ parameters:
     level: max
     paths:
         - src
-    excludes_analyse:
-        - src/globals.php
 
     checkMissingIterableValueType: true
     checkGenericClassInNonGenericObjectType: false
     reportUnmatchedIgnoredErrors: true
 
     ignoreErrors:
-        - "#Undefined variable: \\$this#"
+        - "#type mixed is not subtype of native#"
         - "#is not allowed to extend#"
         - "#Language construct eval#"
         - "# with null as default value#"

rector.php

@@ -1,35 +0,0 @@
-<?php
-
-declare(strict_types=1);
-
-use Rector\Core\Configuration\Option;
-use Rector\Php70\Rector\StaticCall\StaticCallOnNonStaticToInstanceCallRector;
-use Rector\Set\ValueObject\SetList;
-use Symfony\Component\DependencyInjection\Loader\Configurator\ContainerConfigurator;
-
-return static function (ContainerConfigurator $containerConfigurator): void {
-    $parameters = $containerConfigurator->parameters();
-
-    $parameters->set(Option::AUTO_IMPORT_NAMES, true);
-
-    $parameters->set(Option::SETS, [
-        SetList::ACTION_INJECTION_TO_CONSTRUCTOR_INJECTION,
-        SetList::ARRAY_STR_FUNCTIONS_TO_STATIC_CALL,
-        SetList::CODE_QUALITY,
-        SetList::PHP_53,
-        SetList::PHP_54,
-        SetList::PHP_56,
-        SetList::PHP_70,
-        SetList::PHP_71,
-        SetList::PHP_72,
-        SetList::PHP_73,
-        SetList::PHPSTAN,
-        SetList::PHPUNIT_CODE_QUALITY,
-        SetList::SOLID,
-    ]);
-
-    $parameters->set(Option::PATHS, [__DIR__ . '/src', __DIR__ . '/tests']);
-    $parameters->set(Option::EXCLUDE_RECTORS, [
-       StaticCallOnNonStaticToInstanceCallRector::class,
-    ]);
-};

src/Actions/LoadStructure.php

@@ -21,6 +21,7 @@ final class LoadStructure
      * @var array<int, string>
      */
     private const STRUCTURE = [
+        'Expectations.php',
         'Datasets.php',
         'Helpers.php',
         'Pest.php',

src/Concerns/TestCase.php

@@ -5,9 +5,10 @@ declare(strict_types=1);
 namespace Pest\Concerns;
 
 use Closure;
-use Pest\Expectation;
+use Pest\Support\ChainableClosure;
 use Pest\Support\ExceptionTrace;
 use Pest\TestSuite;
+use PHPUnit\Framework\ExecutionOrderDependency;
 use PHPUnit\Util\Test;
 use Throwable;
 
@@ -34,6 +35,38 @@ trait TestCase
      */
     private $__test;
 
+    /**
+     * Holds a global/shared beforeEach ("set up") closure if one has been
+     * defined.
+     *
+     * @var Closure|null
+     */
+    private $beforeEach = null;
+
+    /**
+     * Holds a global/shared afterEach ("tear down") closure if one has been
+     * defined.
+     *
+     * @var Closure|null
+     */
+    private $afterEach = null;
+
+    /**
+     * Holds a global/shared beforeAll ("set up before") closure if one has been
+     * defined.
+     *
+     * @var Closure|null
+     */
+    private static $beforeAll = null;
+
+    /**
+     * Holds a global/shared afterAll ("tear down after") closure if one has
+     * been defined.
+     *
+     * @var Closure|null
+     */
+    private static $afterAll = null;
+
     /**
      * Creates a new instance of the test case.
      */
@@ -55,6 +88,86 @@ trait TestCase
         $this->setGroups($groups);
     }
 
+    /**
+     * Add dependencies to the test case and map them to instances of ExecutionOrderDependency.
+     */
+    public function addDependencies(array $tests): void
+    {
+        $className = get_class($this);
+
+        $tests = array_map(function (string $test) use ($className): ExecutionOrderDependency {
+            if (strpos($test, '::') === false) {
+                $test = "{$className}::{$test}";
+            }
+
+            return new ExecutionOrderDependency($test, null, '');
+        }, $tests);
+
+        $this->setDependencies($tests);
+    }
+
+    /**
+     * Add a shared/"global" before all test hook that will execute **before**
+     * the test defined `beforeAll` hook(s).
+     */
+    public function addBeforeAll(?Closure $hook): void
+    {
+        if (!$hook) {
+            return;
+        }
+
+        self::$beforeAll = (self::$beforeAll instanceof Closure)
+            ? ChainableClosure::fromStatic(self::$beforeAll, $hook)
+            : $hook;
+    }
+
+    /**
+     * Add a shared/"global" after all test hook that will execute **before**
+     * the test defined `afterAll` hook(s).
+     */
+    public function addAfterAll(?Closure $hook): void
+    {
+        if (!$hook) {
+            return;
+        }
+
+        self::$afterAll = (self::$afterAll instanceof Closure)
+            ? ChainableClosure::fromStatic(self::$afterAll, $hook)
+            : $hook;
+    }
+
+    /**
+     * Add a shared/"global" before each test hook that will execute **before**
+     * the test defined `beforeEach` hook.
+     */
+    public function addBeforeEach(?Closure $hook): void
+    {
+        $this->addHook('beforeEach', $hook);
+    }
+
+    /**
+     * Add a shared/"global" after each test hook that will execute **before**
+     * the test defined `afterEach` hook.
+     */
+    public function addAfterEach(?Closure $hook): void
+    {
+        $this->addHook('afterEach', $hook);
+    }
+
+    /**
+     * Add a shared/global hook and compose them if more than one is passed.
+     */
+    private function addHook(string $property, ?Closure $hook): void
+    {
+        if (!$hook) {
+            return;
+        }
+
+        $this->{$property} = ($this->{$property} instanceof Closure)
+            ? ChainableClosure::from($this->{$property}, $hook)
+            : $hook;
+    }
+
     /**
      * Returns the test case name. Note that, in Pest
      * we ignore withDataset argument as the description
@@ -79,6 +192,10 @@ trait TestCase
 
         $beforeAll = TestSuite::getInstance()->beforeAll->get(self::$__filename);
 
+        if (self::$beforeAll instanceof Closure) {
+            $beforeAll = ChainableClosure::fromStatic(self::$beforeAll, $beforeAll);
+        }
+
         call_user_func(Closure::bind($beforeAll, null, self::class));
     }
 
@@ -89,21 +206,15 @@ trait TestCase
     {
         $afterAll = TestSuite::getInstance()->afterAll->get(self::$__filename);
 
+        if (self::$afterAll instanceof Closure) {
+            $afterAll = ChainableClosure::fromStatic(self::$afterAll, $afterAll);
+        }
+
         call_user_func(Closure::bind($afterAll, null, self::class));
 
         parent::tearDownAfterClass();
     }
 
-    /**
-     * Creates a new expectation.
-     *
-     * @param mixed $value
-     */
-    public function expect($value): Expectation
-    {
-        return new Expectation($value);
-    }
-
     /**
      * Gets executed before the test.
      */
@@ -115,6 +226,10 @@ trait TestCase
 
         $beforeEach = TestSuite::getInstance()->beforeEach->get(self::$__filename);
 
+        if ($this->beforeEach instanceof Closure) {
+            $beforeEach = ChainableClosure::from($this->beforeEach, $beforeEach);
+        }
+
         $this->__callClosure($beforeEach, func_get_args());
     }
 
@@ -125,6 +240,10 @@ trait TestCase
     {
         $afterEach = TestSuite::getInstance()->afterEach->get(self::$__filename);
 
+        if ($this->afterEach instanceof Closure) {
+            $afterEach = ChainableClosure::from($this->afterEach, $afterEach);
+        }
+
         $this->__callClosure($afterEach, func_get_args());
 
         parent::tearDown();

src/Console/Command.php

@@ -90,8 +90,6 @@ final class Command extends BaseCommand
          */
         $this->arguments = AddsDefaults::to($this->arguments);
 
-        LoadStructure::in($this->testSuite->rootPath);
-
         $testRunner = new TestRunner($this->arguments['loader']);
         $testSuite  = $this->arguments['test'];
 
@@ -127,6 +125,8 @@ final class Command extends BaseCommand
      */
     public function run(array $argv, bool $exit = true): int
     {
+        LoadStructure::in($this->testSuite->rootPath);
+
         $result = parent::run($argv, false);
 
         /*
@@ -148,5 +148,7 @@ final class Command extends BaseCommand
         $version = Container::getInstance()->get(Version::class);
         $version->handleArguments(['--version']);
         parent::showHelp();
+
+        (new Help($this->output))();
     }
 }

src/Console/Help.php

@@ -0,0 +1,37 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Pest\Console;
+
+use Symfony\Component\Console\Output\OutputInterface;
+
+/**
+ * @internal
+ */
+final class Help
+{
+    /** @var array<int, string> */
+    private const HELP_MESSAGES = [
+        '<comment>Pest Options:</comment>',
+        '  <info>--init</info>                      Initialise a standard Pest configuration',
+        '  <info>--coverage</info>                  Enable coverage and output to standard output',
+        '  <info>--min=<fg=cyan><N></></info>                   Set the minimum required coverage percentage (<N>), and fail if not met',
+        '  <info>--group=<fg=cyan><name></></info>              Only runs tests from the specified group(s)',
+    ];
+
+    /** @var OutputInterface */
+    private $output;
+
+    public function __construct(OutputInterface $output)
+    {
+        $this->output = $output;
+    }
+
+    public function __invoke(): void
+    {
+        foreach (self::HELP_MESSAGES as $message) {
+            $this->output->writeln($message);
+        }
+    }
+}

src/Datasets.php

@@ -18,14 +18,14 @@ final class Datasets
     /**
      * Holds the datasets.
      *
-     * @var array<string, \Closure|iterable<int, mixed>>
+     * @var array<int|string, Closure|iterable<int|string, mixed>>
      */
     private static $datasets = [];
 
     /**
      * Sets the given.
      *
-     * @param Closure|iterable<int, mixed> $data
+     * @param Closure|iterable<int|string, mixed> $data
      */
     public static function set(string $name, $data): void
     {
@@ -37,7 +37,7 @@ final class Datasets
     }
 
     /**
-     * @return Closure|iterable<int, mixed>
+     * @return Closure|iterable<int|string, mixed>
      */
     public static function get(string $name)
     {
@@ -51,7 +51,7 @@ final class Datasets
     /**
      * Resolves the current dataset to an array value.
      *
-     * @param Traversable<int, mixed>|Closure|iterable<int, mixed>|string|null $data
+     * @param Traversable<int|string, mixed>|Closure|iterable<int|string, mixed>|string|null $data
      *
      * @return array<string, mixed>
      */

src/Expectation.php

@@ -1,538 +0,0 @@
-<?php
-
-declare(strict_types=1);
-
-namespace Pest;
-
-use PHPUnit\Framework\Assert;
-use PHPUnit\Framework\Constraint\Constraint;
-
-/**
- * @internal
- *
- * @property Expectation $not Creates the opposite expectation.
- */
-final class Expectation
-{
-    /**
-     * The expectation value.
-     *
-     * @readonly
-     *
-     * @var mixed
-     */
-    public $value;
-
-    /**
-     * Creates a new expectation.
-     *
-     * @param mixed $value
-     */
-    public function __construct($value)
-    {
-        $this->value = $value;
-    }
-
-    /**
-     * Creates a new expectation.
-     *
-     * @param mixed $value
-     */
-    public function and($value): Expectation
-    {
-        return new self($value);
-    }
-
-    /**
-     * Creates the opposite expectation for the value.
-     */
-    public function not(): OppositeExpectation
-    {
-        return new OppositeExpectation($this);
-    }
-
-    /**
-     * Asserts that two variables have the same type and
-     * value. Used on objects, it asserts that two
-     * variables reference the same object.
-     *
-     * @param mixed $expected
-     */
-    public function toBe($expected): Expectation
-    {
-        Assert::assertSame($expected, $this->value);
-
-        return $this;
-    }
-
-    /**
-     * Asserts that the value is empty.
-     */
-    public function toBeEmpty(): Expectation
-    {
-        Assert::assertEmpty($this->value);
-
-        return $this;
-    }
-
-    /**
-     * Asserts that the value is true.
-     */
-    public function toBeTrue(): Expectation
-    {
-        Assert::assertTrue($this->value);
-
-        return $this;
-    }
-
-    /**
-     * Asserts that the value is false.
-     */
-    public function toBeFalse(): Expectation
-    {
-        Assert::assertFalse($this->value);
-
-        return $this;
-    }
-
-    /**
-     * Asserts that the value is greater than $expected.
-     *
-     * @param int|float $expected
-     */
-    public function toBeGreaterThan($expected): Expectation
-    {
-        Assert::assertGreaterThan($expected, $this->value);
-
-        return $this;
-    }
-
-    /**
-     * Asserts that the value is greater than or equal to $expected.
-     *
-     * @param int|float $expected
-     */
-    public function toBeGreaterThanOrEqual($expected): Expectation
-    {
-        Assert::assertGreaterThanOrEqual($expected, $this->value);
-
-        return $this;
-    }
-
-    /**
-     * Asserts that the value is less than or equal to $expected.
-     *
-     * @param int|float $expected
-     */
-    public function toBeLessThan($expected): Expectation
-    {
-        Assert::assertLessThan($expected, $this->value);
-
-        return $this;
-    }
-
-    /**
-     * Asserts that the value is less than $expected.
-     *
-     * @param int|float $expected
-     */
-    public function toBeLessThanOrEqual($expected): Expectation
-    {
-        Assert::assertLessThanOrEqual($expected, $this->value);
-
-        return $this;
-    }
-
-    /**
-     * Asserts that $needle is an element of the value.
-     *
-     * @param mixed $needle
-     */
-    public function toContain($needle): Expectation
-    {
-        if (is_string($this->value)) {
-            Assert::assertStringContainsString($needle, $this->value);
-        } else {
-            Assert::assertContains($needle, $this->value);
-        }
-
-        return $this;
-    }
-
-    /**
-     * Asserts that the value starts with $expected.
-     */
-    public function toStartWith(string $expected): Expectation
-    {
-        Assert::assertStringStartsWith($expected, $this->value);
-
-        return $this;
-    }
-
-    /**
-     * Asserts that the value ends with $expected.
-     */
-    public function toEndWith(string $expected): Expectation
-    {
-        Assert::assertStringEndsWith($expected, $this->value);
-
-        return $this;
-    }
-
-    /**
-     * Asserts that $count matches the number of elements of the value.
-     */
-    public function toHaveCount(int $count): Expectation
-    {
-        Assert::assertCount($count, $this->value);
-
-        return $this;
-    }
-
-    /**
-     * Asserts that the value contains the property $name.
-     *
-     * @param mixed $value
-     */
-    public function toHaveProperty(string $name, $value = null): Expectation
-    {
-        $this->toBeObject();
-
-        Assert::assertTrue(property_exists($this->value, $name));
-
-        if (func_num_args() > 1) {
-            /* @phpstan-ignore-next-line */
-            Assert::assertEquals($value, $this->value->{$name});
-        }
-
-        return $this;
-    }
-
-    /**
-     * Asserts that two variables have the same value.
-     *
-     * @param mixed $expected
-     */
-    public function toEqual($expected): Expectation
-    {
-        Assert::assertEquals($expected, $this->value);
-
-        return $this;
-    }
-
-    /**
-     * Asserts that two variables have the same value.
-     * The contents of $expected and the $this->value are
-     * canonicalized before they are compared. For instance, when the two
-     * variables $expected and $this->value are arrays, then these arrays
-     * are sorted before they are compared. When $expected and $this->value
-     * are objects, each object is converted to an array containing all
-     * private, protected and public attributes.
-     *
-     * @param mixed $expected
-     */
-    public function toEqualCanonicalizing($expected): Expectation
-    {
-        Assert::assertEqualsCanonicalizing($expected, $this->value);
-
-        return $this;
-    }
-
-    /**
-     * Asserts that the absolute difference between the value and $expected
-     * is lower than $delta.
-     *
-     * @param mixed $expected
-     */
-    public function toEqualWithDelta($expected, float $delta): Expectation
-    {
-        Assert::assertEqualsWithDelta($expected, $this->value, $delta);
-
-        return $this;
-    }
-
-    /**
-     * Asserts that the value is infinite.
-     */
-    public function toBeInfinite(): Expectation
-    {
-        Assert::assertInfinite($this->value);
-
-        return $this;
-    }
-
-    /**
-     * Asserts that the value is an instance of $class.
-     *
-     * @param string $class
-     */
-    public function toBeInstanceOf($class): Expectation
-    {
-        /* @phpstan-ignore-next-line */
-        Assert::assertInstanceOf($class, $this->value);
-
-        return $this;
-    }
-
-    /**
-     * Asserts that the value is an array.
-     */
-    public function toBeArray(): Expectation
-    {
-        Assert::assertIsArray($this->value);
-
-        return $this;
-    }
-
-    /**
-     * Asserts that the value is of type bool.
-     */
-    public function toBeBool(): Expectation
-    {
-        Assert::assertIsBool($this->value);
-
-        return $this;
-    }
-
-    /**
-     * Asserts that the value is of type callable.
-     */
-    public function toBeCallable(): Expectation
-    {
-        Assert::assertIsCallable($this->value);
-
-        return $this;
-    }
-
-    /**
-     * Asserts that the value is of type float.
-     */
-    public function toBeFloat(): Expectation
-    {
-        Assert::assertIsFloat($this->value);
-
-        return $this;
-    }
-
-    /**
-     * Asserts that the value is of type int.
-     */
-    public function toBeInt(): Expectation
-    {
-        Assert::assertIsInt($this->value);
-
-        return $this;
-    }
-
-    /**
-     * Asserts that the value is of type iterable.
-     */
-    public function toBeIterable(): Expectation
-    {
-        Assert::assertIsIterable($this->value);
-
-        return $this;
-    }
-
-    /**
-     * Asserts that the value is of type numeric.
-     */
-    public function toBeNumeric(): Expectation
-    {
-        Assert::assertIsNumeric($this->value);
-
-        return $this;
-    }
-
-    /**
-     * Asserts that the value is of type object.
-     */
-    public function toBeObject(): Expectation
-    {
-        Assert::assertIsObject($this->value);
-
-        return $this;
-    }
-
-    /**
-     * Asserts that the value is of type resource.
-     */
-    public function toBeResource(): Expectation
-    {
-        Assert::assertIsResource($this->value);
-
-        return $this;
-    }
-
-    /**
-     * Asserts that the value is of type scalar.
-     */
-    public function toBeScalar(): Expectation
-    {
-        Assert::assertIsScalar($this->value);
-
-        return $this;
-    }
-
-    /**
-     * Asserts that the value is of type string.
-     */
-    public function toBeString(): Expectation
-    {
-        Assert::assertIsString($this->value);
-
-        return $this;
-    }
-
-    /**
-     * Asserts that the value is NAN.
-     */
-    public function toBeNan(): Expectation
-    {
-        Assert::assertNan($this->value);
-
-        return $this;
-    }
-
-    /**
-     * Asserts that the value is null.
-     */
-    public function toBeNull(): Expectation
-    {
-        Assert::assertNull($this->value);
-
-        return $this;
-    }
-
-    /**
-     * Asserts that the value array has the provided $key.
-     *
-     * @param string|int $key
-     */
-    public function toHaveKey($key): Expectation
-    {
-        Assert::assertArrayHasKey($key, $this->value);
-
-        return $this;
-    }
-
-    /**
-     * Asserts that the value array has the provided $keys.
-     *
-     * @param array<int, int|string> $keys
-     */
-    public function toHaveKeys(array $keys): Expectation
-    {
-        foreach ($keys as $key) {
-            $this->toHaveKey($key);
-        }
-
-        return $this;
-    }
-
-    /**
-     * Asserts that the value is a directory.
-     */
-    public function toBeDirectory(): Expectation
-    {
-        Assert::assertDirectoryExists($this->value);
-
-        return $this;
-    }
-
-    /**
-     * Asserts that the value is a directory and is readable.
-     */
-    public function toBeReadableDirectory(): Expectation
-    {
-        Assert::assertDirectoryIsReadable($this->value);
-
-        return $this;
-    }
-
-    /**
-     * Asserts that the value is a directory and is writable.
-     */
-    public function toBeWritableDirectory(): Expectation
-    {
-        Assert::assertDirectoryIsWritable($this->value);
-
-        return $this;
-    }
-
-    /**
-     * Asserts that the value is a file.
-     */
-    public function toBeFile(): Expectation
-    {
-        Assert::assertFileExists($this->value);
-
-        return $this;
-    }
-
-    /**
-     * Asserts that the value is a file and is readable.
-     */
-    public function toBeReadableFile(): Expectation
-    {
-        Assert::assertFileIsReadable($this->value);
-
-        return $this;
-    }
-
-    /**
-     * Asserts that the value is a file and is writable.
-     */
-    public function toBeWritableFile(): Expectation
-    {
-        Assert::assertFileIsWritable($this->value);
-
-        return $this;
-    }
-
-    /**
-     * Asserts that the value object matches a subset
-     * of the properties of an given object.
-     *
-     * @param array<string, mixed>|object $object
-     */
-    public function toMatchObject($object): Expectation
-    {
-        foreach ((array) $object as $property => $value) {
-            $this->toHaveProperty($property, $value);
-        }
-
-        return $this;
-    }
-
-    /**
-     * Asserts that the value matches a regular expression.
-     */
-    public function toMatch(string $expression): Expectation
-    {
-        Assert::assertMatchesRegularExpression($expression, $this->value);
-
-        return $this;
-    }
-
-    /**
-     * Asserts that the value matches a constraint.
-     */
-    public function toMatchConstraint(Constraint $constraint): Expectation
-    {
-        Assert::assertThat($this->value, $constraint);
-
-        return $this;
-    }
-
-    /**
-     * Dynamically calls methods on the class without any arguments.
-     *
-     * @return Expectation
-     */
-    public function __get(string $name)
-    {
-        /* @phpstan-ignore-next-line */
-        return $this->{$name}();
-    }
-}

src/Factories/TestCaseFactory.php

@@ -5,14 +5,17 @@ declare(strict_types=1);
 namespace Pest\Factories;
 
 use Closure;
+use ParseError;
 use Pest\Concerns;
 use Pest\Contracts\HasPrintableTestCaseName;
 use Pest\Datasets;
 use Pest\Exceptions\ShouldNotHappen;
 use Pest\Support\HigherOrderMessageCollection;
 use Pest\Support\NullClosure;
+use Pest\Support\Str;
 use Pest\TestSuite;
 use PHPUnit\Framework\TestCase;
+use RuntimeException;
 
 /**
  * @internal
@@ -59,7 +62,7 @@ final class TestCaseFactory
     /**
      * Holds the dataset, if any.
      *
-     * @var Closure|iterable<int, mixed>|string|null
+     * @var Closure|iterable<int|string, mixed>|string|null
      */
     public $dataset;
 
@@ -139,6 +142,7 @@ final class TestCaseFactory
             $proxies->proxy($this);
             $chains->chain($this);
 
+            /* @phpstan-ignore-next-line */
             return call_user_func(Closure::bind($factoryTest, $this, get_class($this)), ...func_get_args());
         };
 
@@ -156,14 +160,6 @@ final class TestCaseFactory
         return array_map($createTest, array_keys($datasets), $datasets);
     }
 
-    /**
-     * Makes a fully qualified class name from the current filename.
-     */
-    public function getClassName(): string
-    {
-        return $this->makeClassFromFilename($this->filename);
-    }
-
     /**
      * Makes a fully qualified class name from the given filename.
      */
@@ -176,7 +172,7 @@ final class TestCaseFactory
             }, $filename);
         }
 
-        $filename     = (string) realpath($filename);
+        $filename     = str_replace('\\\\', '\\', addslashes((string) realpath($filename)));
         $rootPath     = TestSuite::getInstance()->rootPath;
         $relativePath = str_replace($rootPath . DIRECTORY_SEPARATOR, '', $filename);
         $relativePath = dirname(ucfirst($relativePath)) . DIRECTORY_SEPARATOR . basename($relativePath, '.php');
@@ -184,8 +180,12 @@ final class TestCaseFactory
 
         // Strip out any %-encoded octets.
         $relativePath = (string) preg_replace('|%[a-fA-F0-9][a-fA-F0-9]|', '', $relativePath);
+        // Remove escaped quote sequences (maintain namespace)
+        $relativePath = str_replace(array_map(function (string $quote): string {
+            return sprintf('\\%s', $quote);
+        }, ['\'', '"']), '', $relativePath);
         // Limit to A-Z, a-z, 0-9, '_', '-'.
-        $relativePath = (string) preg_replace('/[^A-Za-z0-9.\\\]/', '', $relativePath);
+        $relativePath = (string) preg_replace('/[^A-Za-z0-9\\\\]/', '', $relativePath);
 
         $classFQN = 'P\\' . $relativePath;
         if (class_exists($classFQN)) {
@@ -202,15 +202,24 @@ final class TestCaseFactory
         $namespace = implode('\\', $partsFQN);
         $baseClass = sprintf('\%s', $this->class);
 
-        eval("
-            namespace $namespace;
+        if ('' === trim($className)) {
+            $className = 'InvalidTestName' . Str::random();
+            $classFQN .= $className;
+        }
 
-            final class $className extends $baseClass implements $hasPrintableTestCaseClassFQN {
-                $traitsCode
+        try {
+            eval("
+                namespace $namespace;
 
-                private static \$__filename = '$filename';
-            }
-        ");
+                final class $className extends $baseClass implements $hasPrintableTestCaseClassFQN {
+                    $traitsCode
+
+                    private static \$__filename = '$filename';
+                }
+            ");
+        } catch (ParseError $caught) {
+            throw new RuntimeException(sprintf('Unable to create test case for test file at %s', $filename), 1, $caught);
+        }
 
         return $classFQN;
     }

src/Functions.php

@@ -3,7 +3,6 @@
 declare(strict_types=1);
 
 use Pest\Datasets;
-use Pest\Expectation;
 use Pest\PendingObjects\AfterEachCall;
 use Pest\PendingObjects\BeforeEachCall;
 use Pest\PendingObjects\TestCall;
@@ -36,7 +35,7 @@ function beforeEach(Closure $closure = null): BeforeEachCall
 /**
  * Registers the given dataset.
  *
- * @param Closure|iterable $dataset
+ * @param Closure|iterable<int|string, mixed> $dataset
  */
 function dataset(string $name, $dataset): void
 {
@@ -63,7 +62,7 @@ function uses(string ...$classAndTraits): UsesCall
  */
 function test(string $description = null, Closure $closure = null)
 {
-    if ($description === null && TestSuite::getInstance()->test) {
+    if ($description === null && TestSuite::getInstance()->test !== null) {
         return new HigherOrderTapProxy(TestSuite::getInstance()->test);
     }
 
@@ -101,19 +100,7 @@ function afterEach(Closure $closure = null): AfterEachCall
 /**
  * Runs the given closure after all tests in the current file.
  */
-function afterAll(Closure $closure = null): void
+function afterAll(Closure $closure): void
 {
     TestSuite::getInstance()->afterAll->set($closure);
 }
-
-/**
- * Creates a new expectation.
- *
- * @param mixed $value the Value
- *
- * @return Expectation
- */
-function expect($value)
-{
-    return test()->expect($value);
-}

src/Laravel/Commands/PestDuskCommand.php

@@ -0,0 +1,43 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Pest\Laravel\Commands;
+
+use Laravel\Dusk\Console\DuskCommand;
+
+/**
+ * @internal
+ */
+final class PestDuskCommand extends DuskCommand
+{
+    /**
+     * The console command name.
+     *
+     * @var string
+     */
+    protected $signature = 'pest:dusk
+                {--browse : Open a browser instead of using headless mode}
+                {--without-tty : Disable output to TTY}';
+
+    /**
+     * The console command description.
+     *
+     * @var string
+     */
+    protected $description = 'Run the Dusk tests for the application with Pest';
+
+    /**
+     * Get the PHP binary to execute.
+     *
+     * @return array<string>
+     */
+    protected function binary()
+    {
+        if ('phpdbg' === PHP_SAPI) {
+            return [PHP_BINARY, '-qrr', 'vendor/pestphp/pest/bin/pest'];
+        }
+
+        return [PHP_BINARY, 'vendor/pestphp/pest/bin/pest'];
+    }
+}

src/Laravel/Commands/PestInstallCommand.php

@@ -8,7 +8,6 @@ use Illuminate\Console\Command;
 use Illuminate\Support\Facades\File;
 use Pest\Console\Thanks;
 use Pest\Exceptions\InvalidConsoleArgument;
-use Pest\Support\Str;
 
 /**
  * @internal
@@ -36,14 +35,10 @@ final class PestInstallCommand extends Command
     {
         /* @phpstan-ignore-next-line */
         $pest    = base_path('tests/Pest.php');
-        /* @phpstan-ignore-next-line */
-        $helpers = base_path('tests/Helpers.php');
-        $stubs   = $this->isLumen() ? 'stubs/Lumen' : 'stubs/Laravel';
+        $stubs   = 'stubs/Laravel';
 
-        foreach ([$pest, $helpers] as $file) {
-            if (File::exists($file)) {
-                throw new InvalidConsoleArgument(sprintf('%s already exist', $file));
-            }
+        if (File::exists($pest)) {
+            throw new InvalidConsoleArgument(sprintf('%s already exist', $pest));
         }
 
         File::copy(implode(DIRECTORY_SEPARATOR, [
@@ -52,26 +47,10 @@ final class PestInstallCommand extends Command
             'Pest.php',
         ]), $pest);
 
-        File::copy(implode(DIRECTORY_SEPARATOR, [
-            dirname(__DIR__, 3),
-            $stubs,
-            'Helpers.php',
-        ]), $helpers);
-
         $this->output->success('`tests/Pest.php` created successfully.');
-        $this->output->success('`tests/Helpers.php` created successfully.');
 
         if (!(bool) $this->option('no-interaction')) {
             (new Thanks($this->output))();
         }
     }
-
-    /**
-     * Determine if this is a Lumen application.
-     */
-    private function isLumen(): bool
-    {
-        /* @phpstan-ignore-next-line */
-        return Str::startsWith(app()->version(), 'Lumen');
-    }
 }

src/Laravel/Commands/PestTestCommand.php

@@ -19,7 +19,7 @@ final class PestTestCommand extends Command
      *
      * @var string
      */
-    protected $signature = 'pest:test {name : The name of the file} {--unit : Create a unit test}';
+    protected $signature = 'pest:test {name : The name of the file} {--unit : Create a unit test} {--dusk : Create a Dusk test}';
 
     /**
      * The console command description.
@@ -36,7 +36,7 @@ final class PestTestCommand extends Command
         /** @var string $name */
         $name = $this->argument('name');
 
-        $type = ((bool) $this->option('unit')) ? 'Unit' : 'Feature';
+        $type = ((bool) $this->option('unit')) ? 'Unit' : (((bool) $this->option('dusk')) ? 'Browser' : 'Feature');
 
         $relativePath = sprintf('tests/%s/%s.php',
             $type,

src/Laravel/PestServiceProvider.php

@@ -5,7 +5,9 @@ declare(strict_types=1);
 namespace Pest\Laravel;
 
 use Illuminate\Support\ServiceProvider;
+use Laravel\Dusk\Console\DuskCommand;
 use Pest\Laravel\Commands\PestDatasetCommand;
+use Pest\Laravel\Commands\PestDuskCommand;
 use Pest\Laravel\Commands\PestInstallCommand;
 use Pest\Laravel\Commands\PestTestCommand;
 
@@ -22,6 +24,12 @@ final class PestServiceProvider extends ServiceProvider
                 PestTestCommand::class,
                 PestDatasetCommand::class,
             ]);
+
+            if (class_exists(DuskCommand::class)) {
+                $this->commands([
+                    PestDuskCommand::class,
+                ]);
+            }
         }
     }
 }

src/OppositeExpectation.php

@@ -1,100 +0,0 @@
-<?php
-
-declare(strict_types=1);
-
-namespace Pest;
-
-use PHPUnit\Framework\ExpectationFailedException;
-use SebastianBergmann\Exporter\Exporter;
-
-/**
- * @internal
- *
- * @mixin Expectation
- */
-final class OppositeExpectation
-{
-    /**
-     * @var Expectation
-     */
-    private $original;
-
-    /**
-     * Creates a new opposite expectation.
-     */
-    public function __construct(Expectation $original)
-    {
-        $this->original = $original;
-    }
-
-    /**
-     * Asserts that the value array not has the provided $keys.
-     *
-     * @param array<int, int|string> $keys
-     */
-    public function toHaveKeys(array $keys): Expectation
-    {
-        foreach ($keys as $key) {
-            try {
-                $this->original->toHaveKey($key);
-            } catch (ExpectationFailedException $e) {
-                continue;
-            }
-
-            $this->throwExpectationFailedExpection('toHaveKey', [$key]);
-        }
-
-        return $this->original;
-    }
-
-    /**
-     * Handle dynamic method calls into the original expectation.
-     *
-     * @param array<int, mixed> $arguments
-     */
-    public function __call(string $name, array $arguments): Expectation
-    {
-        try {
-            /* @phpstan-ignore-next-line */
-            $this->original->{$name}(...$arguments);
-        } catch (ExpectationFailedException $e) {
-            return $this->original;
-        }
-
-        // @phpstan-ignore-next-line
-        $this->throwExpectationFailedExpection($name, $arguments);
-    }
-
-    /**
-     * Handle dynamic properties gets into the original expectation.
-     */
-    public function __get(string $name): Expectation
-    {
-        try {
-            /* @phpstan-ignore-next-line */
-            $this->original->{$name};
-        } catch (ExpectationFailedException $e) {
-            return $this->original;
-        }
-
-        // @phpstan-ignore-next-line
-        $this->throwExpectationFailedExpection($name);
-    }
-
-    /**
-     * Creates a new expectation failed exception
-     * with a nice readable message.
-     *
-     * @param array<int, mixed> $arguments
-     */
-    private function throwExpectationFailedExpection(string $name, array $arguments = []): void
-    {
-        $exporter = new Exporter();
-
-        $toString = function ($argument) use ($exporter): string {
-            return $exporter->shortenedExport($argument);
-        };
-
-        throw new ExpectationFailedException(sprintf('Expecting %s not %s %s.', $toString($this->original->value), strtolower((string) preg_replace('/(?<!\ )[A-Z]/', ' $0', $name)), implode(' ', array_map(function ($argument) use ($toString): string { return $toString($argument); }, $arguments))));
-    }
-}

src/PendingObjects/TestCall.php

@@ -9,11 +9,10 @@ use Pest\Factories\TestCaseFactory;
 use Pest\Support\Backtrace;
 use Pest\Support\NullClosure;
 use Pest\TestSuite;
-use PHPUnit\Framework\ExecutionOrderDependency;
 use SebastianBergmann\Exporter\Exporter;
 
 /**
- * @method \Pest\Expectation expect(mixed $value)
+ * @method \Pest\Expectations\Expectation expect(mixed $value)
  *
  * @internal
  */
@@ -78,7 +77,7 @@ final class TestCall
      * Runs the current test multiple times with
      * each item of the given `iterable`.
      *
-     * @param \Closure|iterable<int, mixed>|string $data
+     * @param \Closure|iterable<int|string, mixed>|string $data
      */
     public function with($data): TestCall
     {
@@ -92,15 +91,9 @@ final class TestCall
      */
     public function depends(string ...$tests): TestCall
     {
-        $className = $this->testCaseFactory->getClassName();
-
-        $tests = array_map(function (string $test) use ($className): ExecutionOrderDependency {
-            return ExecutionOrderDependency::createFromDependsAnnotation($className, $test);
-        }, $tests);
-
         $this->testCaseFactory
             ->factoryProxies
-            ->add(Backtrace::file(), Backtrace::line(), 'setDependencies', [$tests]);
+            ->add(Backtrace::file(), Backtrace::line(), 'addDependencies', [$tests]);
 
         return $this;
     }

src/PendingObjects/UsesCall.php

@@ -4,6 +4,7 @@ declare(strict_types=1);
 
 namespace Pest\PendingObjects;
 
+use Closure;
 use Pest\Exceptions\InvalidUsesPath;
 use Pest\TestSuite;
 
@@ -12,6 +13,20 @@ use Pest\TestSuite;
  */
 final class UsesCall
 {
+    /**
+     * Contains a global before each hook closure to be executed.
+     *
+     * Array indices here matter. They are mapped as follows:
+     *
+     * - `0` => `beforeAll`
+     * - `1` => `beforeEach`
+     * - `2` => `afterEach`
+     * - `3` => `afterAll`
+     *
+     * @var array<int, Closure>
+     */
+    private $hooks = [];
+
     /**
      * Holds the class and traits.
      *
@@ -97,11 +112,56 @@ final class UsesCall
         return $this;
     }
 
+    /**
+     * Sets the global beforeAll test hook.
+     */
+    public function beforeAll(Closure $hook): UsesCall
+    {
+        $this->hooks[0] = $hook;
+
+        return $this;
+    }
+
+    /**
+     * Sets the global beforeEach test hook.
+     */
+    public function beforeEach(Closure $hook): UsesCall
+    {
+        $this->hooks[1] = $hook;
+
+        return $this;
+    }
+
+    /**
+     * Sets the global afterEach test hook.
+     */
+    public function afterEach(Closure $hook): UsesCall
+    {
+        $this->hooks[2] = $hook;
+
+        return $this;
+    }
+
+    /**
+     * Sets the global afterAll test hook.
+     */
+    public function afterAll(Closure $hook): UsesCall
+    {
+        $this->hooks[3] = $hook;
+
+        return $this;
+    }
+
     /**
      * Dispatch the creation of uses.
      */
     public function __destruct()
     {
-        TestSuite::getInstance()->tests->use($this->classAndTraits, $this->groups, $this->targets);
+        TestSuite::getInstance()->tests->use(
+            $this->classAndTraits,
+            $this->groups,
+            $this->targets,
+            $this->hooks,
+        );
     }
 }

src/Pest.php

@@ -6,5 +6,5 @@ namespace Pest;
 
 function version(): string
 {
-    return '0.3.11';
+    return '1.1.0';
 }

src/Repositories/TestRepository.php

@@ -4,6 +4,7 @@ declare(strict_types=1);
 
 namespace Pest\Repositories;
 
+use Closure;
 use Pest\Exceptions\ShouldNotHappen;
 use Pest\Exceptions\TestAlreadyExist;
 use Pest\Exceptions\TestCaseAlreadyInUse;
@@ -24,7 +25,7 @@ final class TestRepository
     private $state = [];
 
     /**
-     * @var array<string, array<int, array<int, string>>>
+     * @var array<string, array<int, array<int, string|Closure>>>
      */
     private $uses = [];
 
@@ -46,12 +47,13 @@ final class TestRepository
         };
 
         foreach ($this->uses as $path => $uses) {
-            [$classOrTraits, $groups] = $uses;
-            $setClassName             = function (TestCaseFactory $testCase, string $key) use ($path, $classOrTraits, $groups, $startsWith): void {
+            [$classOrTraits, $groups, $hooks] = $uses;
+
+            $setClassName = function (TestCaseFactory $testCase, string $key) use ($path, $classOrTraits, $groups, $startsWith, $hooks): void {
                 [$filename] = explode('@', $key);
 
                 if ((!is_dir($path) && $filename === $path) || (is_dir($path) && $startsWith($filename, $path))) {
-                    foreach ($classOrTraits as $class) {
+                    foreach ($classOrTraits as $class) { /** @var string $class */
                         if (class_exists($class)) {
                             if ($testCase->class !== TestCase::class) {
                                 throw new TestCaseAlreadyInUse($testCase->class, $class, $filename);
@@ -62,10 +64,12 @@ final class TestRepository
                         }
                     }
 
-                    $testCase
-                        ->factoryProxies
-                        // Consider set the real line here.
-                        ->add($filename, 0, 'addGroups', [$groups]);
+                    // IDEA: Consider set the real lines on these.
+                    $testCase->factoryProxies->add($filename, 0, 'addGroups', [$groups]);
+                    $testCase->factoryProxies->add($filename, 0, 'addBeforeAll', [$hooks[0] ?? null]);
+                    $testCase->factoryProxies->add($filename, 0, 'addBeforeEach', [$hooks[1] ?? null]);
+                    $testCase->factoryProxies->add($filename, 0, 'addAfterEach', [$hooks[2] ?? null]);
+                    $testCase->factoryProxies->add($filename, 0, 'addAfterAll', [$hooks[3] ?? null]);
                 }
             };
 
@@ -81,7 +85,7 @@ final class TestRepository
         $state = count($onlyState) > 0 ? $onlyState : $this->state;
 
         foreach ($state as $testFactory) {
-            /* @var TestCaseFactory $testFactory */
+            /** @var TestCaseFactory $testFactory */
             $tests = $testFactory->build($testSuite);
             foreach ($tests as $test) {
                 $each($test);
@@ -92,11 +96,12 @@ final class TestRepository
     /**
      * Uses the given `$testCaseClass` on the given `$paths`.
      *
-     * @param array<int, string> $classOrTraits
-     * @param array<int, string> $groups
-     * @param array<int, string> $paths
+     * @param array<int, string>  $classOrTraits
+     * @param array<int, string>  $groups
+     * @param array<int, string>  $paths
+     * @param array<int, Closure> $hooks
      */
-    public function use(array $classOrTraits, array $groups, array $paths): void
+    public function use(array $classOrTraits, array $groups, array $paths, array $hooks): void
     {
         foreach ($classOrTraits as $classOrTrait) {
             if (!class_exists($classOrTrait) && !trait_exists($classOrTrait)) {
@@ -109,9 +114,10 @@ final class TestRepository
                 $this->uses[$path] = [
                     array_merge($this->uses[$path][0], $classOrTraits),
                     array_merge($this->uses[$path][1], $groups),
+                    $this->uses[$path][2] + $hooks, // NOTE: array_merge will destroy numeric indices
                 ];
             } else {
-                $this->uses[$path] = [$classOrTraits, $groups];
+                $this->uses[$path] = [$classOrTraits, $groups, $hooks];
             }
         }
     }

src/Support/ChainableClosure.php

@@ -12,13 +12,28 @@ use Closure;
 final class ChainableClosure
 {
     /**
-     * Calls the given `$closure` and chains the the `$next` closure.
+     * Calls the given `$closure` and chains the `$next` closure.
      */
     public static function from(Closure $closure, Closure $next): Closure
     {
         return function () use ($closure, $next): void {
+            /* @phpstan-ignore-next-line */
             call_user_func_array(Closure::bind($closure, $this, get_class($this)), func_get_args());
+            /* @phpstan-ignore-next-line */
             call_user_func_array(Closure::bind($next, $this, get_class($this)), func_get_args());
         };
     }
+
+    /**
+     * Call the given static `$closure` and chains the `$next` closure.
+     */
+    public static function fromStatic(Closure $closure, Closure $next): Closure
+    {
+        return static function () use ($closure, $next): void {
+            /* @phpstan-ignore-next-line */
+            call_user_func_array(Closure::bind($closure, null, self::class), func_get_args());
+            /* @phpstan-ignore-next-line */
+            call_user_func_array(Closure::bind($next, null, self::class), func_get_args());
+        };
+    }
 }

src/Support/Container.php

@@ -79,6 +79,7 @@ final class Container
 
                         if ($candidate === null) {
                             $type = $param->getType();
+                            /* @phpstan-ignore-next-line */
                             if ($type !== null && $type->isBuiltin()) {
                                 $candidate = $param->getName();
                             } else {

src/Support/Str.php

@@ -9,6 +9,25 @@ namespace Pest\Support;
  */
 final class Str
 {
+    /**
+     * Pool of alpha-numeric characters for generating (unsafe) random strings
+     * from.
+     */
+    private const POOL = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ';
+
+    /**
+     * Create a (unsecure & non-cryptographically safe) random alpha-numeric
+     * string value.
+     *
+     * @param int $length the length of the resulting randomized string
+     *
+     * @see https://github.com/laravel/framework/blob/4.2/src/Illuminate/Support/Str.php#L240-L242
+     */
+    public static function random(int $length = 16): string
+    {
+        return substr(str_shuffle(str_repeat(self::POOL, 5)), 0, $length);
+    }
+
     /**
      * Checks if the given `$target` starts with the given `$search`.
      */

src/TeamCity.php

@@ -56,7 +56,7 @@ final class TeamCity extends DefaultResultPrinter
     /** @phpstan-ignore-next-line */
     public function startTestSuite(TestSuite $suite): void
     {
-        $this->flowId = getmypid();
+        $this->flowId = (int) getmypid();
 
         if (!$this->isSummaryTestCountPrinted) {
             $this->printEvent(
@@ -205,6 +205,9 @@ final class TeamCity extends DefaultResultPrinter
 
     private static function isPestTest(Test $test): bool
     {
-        return in_array(TestCase::class, class_uses($test), true);
+        /** @var array<string, string> $uses */
+        $uses = class_uses($test);
+
+        return in_array(TestCase::class, $uses, true);
     }
 }

stubs/Browser.php

@@ -0,0 +1,10 @@
+<?php
+
+use Laravel\Dusk\Browser;
+
+it('has {name} page', function () {
+    $this->browse(function (Browser $browser) {
+        $browser->visit('/{name}')
+            ->assertSee('{name}');
+    });
+});

stubs/Laravel/Helpers.php

@@ -1,11 +0,0 @@
-<?php
-
-namespace Tests;
-
-/**
- * A basic assert example.
- */
-function assertExample(): void
-{
-    test()->assertTrue(true);
-}

stubs/Laravel/Pest.php

@@ -1,3 +1,45 @@
 <?php
 
+/*
+|--------------------------------------------------------------------------
+| Test Case
+|--------------------------------------------------------------------------
+|
+| The closure you provide to your test functions is always bound to a specific PHPUnit test
+| case class. By default, that class is "PHPUnit\Framework\TestCase". Of course, you may
+| need to change it using the "uses()" function to bind a different classes or traits.
+|
+*/
+
 uses(Tests\TestCase::class)->in('Feature');
+
+/*
+|--------------------------------------------------------------------------
+| Expectations
+|--------------------------------------------------------------------------
+|
+| When you're writing tests, you often need to check that values meet certain conditions. The
+| "expect()" function gives you access to a set of "expectations" methods that you can use
+| to assert different things. Of course, you may extend the Expectation API at any time.
+|
+*/
+
+expect()->extend('toBeOne', function () {
+    return $this->toBe(1);
+});
+
+/*
+|--------------------------------------------------------------------------
+| Functions
+|--------------------------------------------------------------------------
+|
+| While Pest is very powerful out-of-the-box, you may have some testing code specific to your
+| project that you don't want to repeat in every file. Here you can also expose helpers as
+| global functions to help you to reduce the number of lines of code in your test files.
+|
+*/
+
+function something()
+{
+    // ..
+}

stubs/Lumen/Helpers.php

@@ -1,11 +0,0 @@
-<?php
-
-namespace Tests;
-
-/**
- * A basic assert example.
- */
-function assertExample(): void
-{
-    test()->assertTrue(true);
-}

stubs/Lumen/Pest.php

@@ -1,3 +0,0 @@
-<?php
-
-uses(TestCase::class)->in(__DIR__);

stubs/Lumen/phpunit.xml

@@ -1,17 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<phpunit xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-         xsi:noNamespaceSchemaLocation="./vendor/phpunit/phpunit/phpunit.xsd"
-         bootstrap="vendor/autoload.php"
-         colors="true"
->
-    <testsuites>
-        <testsuite name="Application Test Suite">
-            <directory suffix="Test.php">./tests</directory>
-        </testsuite>
-    </testsuites>
-    <coverage processUncoveredFiles="true">
-        <include>
-            <directory suffix=".php">./app</directory>
-        </include>
-    </coverage>
-</phpunit>

tests/.snapshots/help-command.txt

@@ -0,0 +1,5 @@
+Pest Options:
+  --init                      Initialise a standard Pest configuration
+  --coverage                  Enable coverage and output to standard output
+  --min=<N>                   Set the minimum required coverage percentage (<N>), and fail if not met
+  --group=<name>              Only runs tests from the specified group(s)

tests/.snapshots/success.txt

@@ -2,221 +2,6 @@
    PASS  Tests\CustomTestCase\ExecutedTest
   ✓ that gets executed
 
-   PASS  Tests\Expect\not
-  ✓ not property calls
-
-   PASS  Tests\Expect\toBe
-  ✓ expect true → toBeTrue  → and false → toBeFalse 
-  ✓ strict comparisons
-  ✓ failures
-  ✓ not failures
-
-   PASS  Tests\Expect\toBeArray
-  ✓ pass
-  ✓ failures
-  ✓ not failures
-
-   PASS  Tests\Expect\toBeBool
-  ✓ pass
-  ✓ failures
-  ✓ not failures
-
-   PASS  Tests\Expect\toBeCallable
-  ✓ pass
-  ✓ failures
-  ✓ not failures
-
-   PASS  Tests\Expect\toBeDirectory
-  ✓ pass
-  ✓ failures
-  ✓ not failures
-
-   PASS  Tests\Expect\toBeEmpty
-  ✓ pass
-  ✓ failures
-  ✓ not failures
-
-   PASS  Tests\Expect\toBeFalse
-  ✓ strict comparisons
-  ✓ failures
-  ✓ not failures
-
-   PASS  Tests\Expect\toBeFile
-  ✓ pass
-  ✓ failures
-  ✓ not failures
-
-   PASS  Tests\Expect\toBeFloat
-  ✓ pass
-  ✓ failures
-  ✓ not failures
-
-   PASS  Tests\Expect\toBeGreatherThan
-  ✓ passes
-  ✓ failures
-  ✓ not failures
-
-   PASS  Tests\Expect\toBeGreatherThanOrEqual
-  ✓ passes
-  ✓ failures
-  ✓ not failures
-
-   PASS  Tests\Expect\toBeInfinite
-  ✓ pass
-  ✓ failures
-  ✓ not failures
-
-   PASS  Tests\Expect\toBeInstanceOf
-  ✓ pass
-  ✓ failures
-  ✓ not failures
-
-   PASS  Tests\Expect\toBeInt
-  ✓ pass
-  ✓ failures
-  ✓ not failures
-
-   PASS  Tests\Expect\toBeIterable
-  ✓ pass
-  ✓ failures
-  ✓ not failures
-
-   PASS  Tests\Expect\toBeLessThan
-  ✓ passes
-  ✓ failures
-  ✓ not failures
-
-   PASS  Tests\Expect\toBeLessThanOrEqual
-  ✓ passes
-  ✓ failures
-  ✓ not failures
-
-   PASS  Tests\Expect\toBeNAN
-  ✓ pass
-  ✓ failures
-  ✓ not failures
-
-   PASS  Tests\Expect\toBeNull
-  ✓ pass
-  ✓ failures
-  ✓ not failures
-
-   PASS  Tests\Expect\toBeNumeric
-  ✓ pass
-  ✓ failures
-  ✓ not failures
-
-   PASS  Tests\Expect\toBeObject
-  ✓ pass
-  ✓ failures
-  ✓ not failures
-
-   PASS  Tests\Expect\toBeReadableDirectory
-  ✓ pass
-  ✓ failures
-  ✓ not failures
-
-   PASS  Tests\Expect\toBeReadableFile
-  ✓ pass
-  ✓ failures
-  ✓ not failures
-
-   PASS  Tests\Expect\toBeResource
-  ✓ pass
-  ✓ failures
-  ✓ not failures
-
-   PASS  Tests\Expect\toBeScalar
-  ✓ pass
-  ✓ failures
-  ✓ not failures
-
-   PASS  Tests\Expect\toBeString
-  ✓ pass
-  ✓ failures
-  ✓ not failures
-
-   PASS  Tests\Expect\toBeTrue
-  ✓ strict comparisons
-  ✓ failures
-  ✓ not failures
-
-   PASS  Tests\Expect\toBeWritableDirectory
-  ✓ pass
-  ✓ failures
-  ✓ not failures
-
-   PASS  Tests\Expect\toBeWritableFile
-  ✓ pass
-  ✓ failures
-  ✓ not failures
-
-   PASS  Tests\Expect\toContain
-  ✓ passes strings
-  ✓ passes arrays
-  ✓ failures
-  ✓ not failures
-
-   PASS  Tests\Expect\toEndWith
-  ✓ pass
-  ✓ failures
-  ✓ not failures
-
-   PASS  Tests\Expect\toEqual
-  ✓ pass
-  ✓ failures
-  ✓ not failures
-
-   PASS  Tests\Expect\toEqualCanonicalizing
-  ✓ pass
-  ✓ failures
-  ✓ not failures
-
-   PASS  Tests\Expect\toEqualWithDelta
-  ✓ pass
-  ✓ failures
-  ✓ not failures
-
-   PASS  Tests\Expect\toHaveCount
-  ✓ pass
-  ✓ failures
-  ✓ not failures
-
-   PASS  Tests\Expect\toHaveKey
-  ✓ pass
-  ✓ failures
-  ✓ not failures
-
-   PASS  Tests\Expect\toHaveKeys
-  ✓ pass
-  ✓ failures
-  ✓ not failures
-
-   PASS  Tests\Expect\toHaveProperty
-  ✓ pass
-  ✓ failures
-  ✓ not failures
-
-   PASS  Tests\Expect\toMatch
-  ✓ pass
-  ✓ failures
-  ✓ not failures
-
-   PASS  Tests\Expect\toMatchConstraint
-  ✓ pass
-  ✓ failures
-  ✓ not failures
-
-   PASS  Tests\Expect\toMatchObject
-  ✓ pass
-  ✓ failures
-  ✓ not failures
-
-   PASS  Tests\Expect\toStartWith
-  ✓ pass
-  ✓ failures
-  ✓ not failures
-
    PASS  Tests\Features\AfterAll
   ✓ deletes file after all
 
@@ -318,6 +103,39 @@
    PASS  Tests\Fixtures\ExampleTest
   ✓ it example 2
 
+   PASS  Tests\Hooks\AfterAllTest
+  ✓ global afterAll execution order
+
+   PASS  Tests\Hooks\AfterEachTest
+  ✓ global afterEach execution order
+
+   PASS  Tests\Hooks\BeforeAllTest
+  ✓ global beforeAll execution order
+
+   PASS  Tests\Hooks\BeforeEachTest
+  ✓ global beforeEach execution order
+
+   PASS  Tests\PHPUnit\CustomAffixes\InvalidTestName
+  ✓ it runs file names like `@#$%^&()-_=+.php`
+
+   PASS  Tests\PHPUnit\CustomAffixes\ATestWithSpaces
+  ✓ it runs file names like `A Test With Spaces.php`
+
+   PASS  Tests\PHPUnit\CustomAffixes\AdditionalFileExtensionspec
+  ✓ it runs file names like `AdditionalFileExtension.spec.php`
+
+   PASS  Tests\PHPUnit\CustomAffixes\ManyExtensionsclasstest
+  ✓ it runs file names like `ManyExtensions.class.test.php`
+
+   PASS  Tests\PHPUnit\CustomAffixes\TestCaseWithQuotes
+  ✓ it runs file names like `Test 'Case' With Quotes.php`
+
+   PASS  Tests\PHPUnit\CustomAffixes\kebabcasespec
+  ✓ it runs file names like `kebab-case-spec.php`
+
+   PASS  Tests\PHPUnit\CustomAffixes\snakecasespec
+  ✓ it runs file names like `snake_case_spec.php`
+
    PASS  Tests\PHPUnit\CustomTestCase\UsesPerDirectory
   ✓ closure was bound to CustomTestCase
 
@@ -348,6 +166,9 @@
   ✓ it throws exception when `process isolation` is true
   ✓ it do not throws exception when `process isolation` is false
 
+   PASS  Tests\Unit\Console\Help
+  ✓ it outputs the help information when --help is used
+
    PASS  Tests\Unit\Datasets
   ✓ it show the names of named datasets in their description
 
@@ -374,6 +195,9 @@
    PASS  Tests\Unit\TestSuite
   ✓ it does not allow to add the same test description twice
 
+   PASS  Tests\Visual\Help
+  ✓ visual snapshot of help command output
+
    PASS  Tests\Visual\SingleTestOrDirectory
   ✓ allows to run a single test
   ✓ allows to run a directory
@@ -386,10 +210,16 @@
    PASS  Tests\Features\Depends
   ✓ first
   ✓ second
+  ✓ it asserts true is true
   ✓ depends
   ✓ depends with ...params
   ✓ depends with defined arguments
   ✓ depends run test only once
+  ✓ depends works with the correct test name
 
-  Tests:  7 skipped, 231 passed
+   PASS  Tests\Features\DependsInheritance
+  ✓ it is a test
+  ✓ it uses correct parent class
+
+  Tests:  7 skipped, 119 passed
   

tests/Expect/not.php

@@ -1,10 +0,0 @@
-<?php
-
-test('not property calls', function () {
-    expect(true)
-        ->toBeTrue()
-        ->not()->toBeFalse()
-        ->not->toBeFalse
-        ->and(false)
-        ->toBeFalse();
-});

tests/Expect/toBe.php

@@ -1,20 +0,0 @@
-<?php
-
-use PHPUnit\Framework\ExpectationFailedException;
-
-expect(true)->toBeTrue()->and(false)->toBeFalse();
-
-test('strict comparisons', function () {
-    $nuno = new stdClass();
-    $dries = new stdClass();
-
-    expect($nuno)->toBe($nuno)->not->toBe($dries);
-});
-
-test('failures', function () {
-    expect(1)->toBe(2);
-})->throws(ExpectationFailedException::class);
-
-test('not failures', function () {
-    expect(1)->not->toBe(1);
-})->throws(ExpectationFailedException::class);

tests/Expect/toBeArray.php

@@ -1,16 +0,0 @@
-<?php
-
-use PHPUnit\Framework\ExpectationFailedException;
-
-test('pass', function () {
-    expect([1, 2, 3])->toBeArray();
-    expect('1, 2, 3')->not->toBeArray();
-});
-
-test('failures', function () {
-    expect(null)->toBeArray();
-})->throws(ExpectationFailedException::class);
-
-test('not failures', function () {
-    expect(['a', 'b', 'c'])->not->toBeArray();
-})->throws(ExpectationFailedException::class);

tests/Expect/toBeBool.php

@@ -1,16 +0,0 @@
-<?php
-
-use PHPUnit\Framework\ExpectationFailedException;
-
-test('pass', function () {
-    expect(true)->toBeBool();
-    expect(0)->not->toBeBool();
-});
-
-test('failures', function () {
-    expect(null)->toBeBool();
-})->throws(ExpectationFailedException::class);
-
-test('not failures', function () {
-    expect(false)->not->toBeBool();
-})->throws(ExpectationFailedException::class);

tests/Expect/toBeCallable.php

@@ -1,18 +0,0 @@
-<?php
-
-use PHPUnit\Framework\ExpectationFailedException;
-
-test('pass', function () {
-    expect(function () {})->toBeCallable();
-    expect(null)->not->toBeCallable();
-});
-
-test('failures', function () {
-    $hello = 5;
-
-    expect($hello)->toBeCallable();
-})->throws(ExpectationFailedException::class);
-
-test('not failures', function () {
-    expect(function () { return 42; })->not->toBeCallable();
-})->throws(ExpectationFailedException::class);

tests/Expect/toBeDirectory.php

@@ -1,17 +0,0 @@
-<?php
-
-use PHPUnit\Framework\ExpectationFailedException;
-
-test('pass', function () {
-    $temp = sys_get_temp_dir();
-
-    expect($temp)->toBeDirectory();
-});
-
-test('failures', function () {
-    expect('/random/path/whatever')->toBeDirectory();
-})->throws(ExpectationFailedException::class);
-
-test('not failures', function () {
-    expect('.')->not->toBeDirectory();
-})->throws(ExpectationFailedException::class);

tests/Expect/toBeEmpty.php

@@ -1,18 +0,0 @@
-<?php
-
-use PHPUnit\Framework\ExpectationFailedException;
-
-test('pass', function () {
-    expect([])->toBeEmpty();
-    expect(null)->toBeEmpty();
-});
-
-test('failures', function () {
-    expect([1, 2])->toBeEmpty();
-    expect(' ')->toBeEmpty();
-})->throws(ExpectationFailedException::class);
-
-test('not failures', function () {
-    expect([])->not->toBeEmpty();
-    expect(null)->not->toBeEmpty();
-})->throws(ExpectationFailedException::class);

tests/Expect/toBeFalse.php

@@ -1,15 +0,0 @@
-<?php
-
-use PHPUnit\Framework\ExpectationFailedException;
-
-test('strict comparisons', function () {
-    expect(false)->toBeFalse();
-});
-
-test('failures', function () {
-    expect('')->toBeFalse();
-})->throws(ExpectationFailedException::class);
-
-test('not failures', function () {
-    expect(false)->not->toBe(false);
-})->throws(ExpectationFailedException::class);

tests/Expect/toBeFile.php

@@ -1,23 +0,0 @@
-<?php
-
-use PHPUnit\Framework\ExpectationFailedException;
-
-beforeEach(function () {
-    touch($this->tempFile = sys_get_temp_dir() . '/fake.file');
-});
-
-afterEach(function () {
-    unlink($this->tempFile);
-});
-
-test('pass', function () {
-    expect($this->tempFile)->toBeFile();
-});
-
-test('failures', function () {
-    expect('/random/path/whatever.file')->toBeFile();
-})->throws(ExpectationFailedException::class);
-
-test('not failures', function () {
-    expect($this->tempFile)->not->toBeFile();
-})->throws(ExpectationFailedException::class);

tests/Expect/toBeFloat.php

@@ -1,16 +0,0 @@
-<?php
-
-use PHPUnit\Framework\ExpectationFailedException;
-
-test('pass', function () {
-    expect(1.0)->toBeFloat();
-    expect(1)->not->toBeFloat();
-});
-
-test('failures', function () {
-    expect(42)->toBeFloat();
-})->throws(ExpectationFailedException::class);
-
-test('not failures', function () {
-    expect(log(3))->not->toBeFloat();
-})->throws(ExpectationFailedException::class);

tests/Expect/toBeGreatherThan.php

@@ -1,16 +0,0 @@
-<?php
-
-use PHPUnit\Framework\ExpectationFailedException;
-
-test('passes', function () {
-    expect(42)->toBeGreaterThan(41);
-    expect(4)->toBeGreaterThan(3.9);
-});
-
-test('failures', function () {
-    expect(4)->toBeGreaterThan(4);
-})->throws(ExpectationFailedException::class);
-
-test('not failures', function () {
-    expect(5)->not->toBeGreaterThan(4);
-})->throws(ExpectationFailedException::class);

tests/Expect/toBeGreatherThanOrEqual.php

@@ -1,16 +0,0 @@
-<?php
-
-use PHPUnit\Framework\ExpectationFailedException;
-
-test('passes', function () {
-    expect(42)->toBeGreaterThanOrEqual(41);
-    expect(4)->toBeGreaterThanOrEqual(4);
-});
-
-test('failures', function () {
-    expect(4)->toBeGreaterThanOrEqual(4.1);
-})->throws(ExpectationFailedException::class);
-
-test('not failures', function () {
-    expect(5)->not->toBeGreaterThanOrEqual(5);
-})->throws(ExpectationFailedException::class);

tests/Expect/toBeInfinite.php

@@ -1,16 +0,0 @@
-<?php
-
-use PHPUnit\Framework\ExpectationFailedException;
-
-test('pass', function () {
-    expect(log(0))->toBeInfinite();
-    expect(log(1))->not->toBeInfinite();
-});
-
-test('failures', function () {
-    expect(asin(2))->toBeInfinite();
-})->throws(ExpectationFailedException::class);
-
-test('not failures', function () {
-    expect(INF)->not->toBeInfinite();
-})->throws(ExpectationFailedException::class);

tests/Expect/toBeInstanceOf.php

@@ -1,16 +0,0 @@
-<?php
-
-use PHPUnit\Framework\ExpectationFailedException;
-
-test('pass', function () {
-    expect(new Exception())->toBeInstanceOf(Exception::class);
-    expect(new Exception())->not->toBeInstanceOf(RuntimeException::class);
-});
-
-test('failures', function () {
-    expect(new Exception())->toBeInstanceOf(RuntimeException::class);
-})->throws(ExpectationFailedException::class);
-
-test('not failures', function () {
-    expect(new Exception())->not->toBeInstanceOf(Exception::class);
-})->throws(ExpectationFailedException::class);

tests/Expect/toBeInt.php

@@ -1,16 +0,0 @@
-<?php
-
-use PHPUnit\Framework\ExpectationFailedException;
-
-test('pass', function () {
-    expect(42)->toBeInt();
-    expect(42.0)->not->toBeInt();
-});
-
-test('failures', function () {
-    expect(42.0)->toBeInt();
-})->throws(ExpectationFailedException::class);
-
-test('not failures', function () {
-    expect(6 * 7)->not->toBeInt();
-})->throws(ExpectationFailedException::class);

tests/Expect/toBeIterable.php

@@ -1,23 +0,0 @@
-<?php
-
-use PHPUnit\Framework\ExpectationFailedException;
-
-test('pass', function () {
-    expect([])->toBeIterable();
-    expect(null)->not->toBeIterable();
-});
-
-test('failures', function () {
-    expect(42)->toBeIterable();
-})->throws(ExpectationFailedException::class);
-
-test('not failures', function () {
-    function gen(): iterable
-    {
-        yield 1;
-        yield 2;
-        yield 3;
-    }
-
-    expect(gen())->not->toBeIterable();
-})->throws(ExpectationFailedException::class);

tests/Expect/toBeLessThan.php

@@ -1,16 +0,0 @@
-<?php
-
-use PHPUnit\Framework\ExpectationFailedException;
-
-test('passes', function () {
-    expect(41)->toBeLessThan(42);
-    expect(4)->toBeLessThan(5);
-});
-
-test('failures', function () {
-    expect(4)->toBeLessThan(4);
-})->throws(ExpectationFailedException::class);
-
-test('not failures', function () {
-    expect(5)->not->toBeLessThan(6);
-})->throws(ExpectationFailedException::class);

tests/Expect/toBeLessThanOrEqual.php

@@ -1,16 +0,0 @@
-<?php
-
-use PHPUnit\Framework\ExpectationFailedException;
-
-test('passes', function () {
-    expect(41)->toBeLessThanOrEqual(42);
-    expect(4)->toBeLessThanOrEqual(4);
-});
-
-test('failures', function () {
-    expect(4)->toBeLessThanOrEqual(3.9);
-})->throws(ExpectationFailedException::class);
-
-test('not failures', function () {
-    expect(5)->not->toBeLessThanOrEqual(5);
-})->throws(ExpectationFailedException::class);

tests/Expect/toBeNAN.php

@@ -1,16 +0,0 @@
-<?php
-
-use PHPUnit\Framework\ExpectationFailedException;
-
-test('pass', function () {
-    expect(asin(2))->toBeNan();
-    expect(log(0))->not->toBeNan();
-});
-
-test('failures', function () {
-    expect(1)->toBeNan();
-})->throws(ExpectationFailedException::class);
-
-test('not failures', function () {
-    expect(acos(1.5))->not->toBeNan();
-})->throws(ExpectationFailedException::class);

tests/Expect/toBeNull.php

@@ -1,16 +0,0 @@
-<?php
-
-use PHPUnit\Framework\ExpectationFailedException;
-
-test('pass', function () {
-    expect(null)->toBeNull();
-    expect('')->not->toBeNull();
-});
-
-test('failures', function () {
-    expect('hello')->toBeNull();
-})->throws(ExpectationFailedException::class);
-
-test('not failures', function () {
-    expect(null)->not->toBeNull();
-})->throws(ExpectationFailedException::class);

tests/Expect/toBeNumeric.php

@@ -1,16 +0,0 @@
-<?php
-
-use PHPUnit\Framework\ExpectationFailedException;
-
-test('pass', function () {
-    expect(42)->toBeNumeric();
-    expect('A')->not->toBeNumeric();
-});
-
-test('failures', function () {
-    expect(null)->toBeNumeric();
-})->throws(ExpectationFailedException::class);
-
-test('not failures', function () {
-    expect(6 * 7)->not->toBeNumeric();
-})->throws(ExpectationFailedException::class);

tests/Expect/toBeObject.php

@@ -1,16 +0,0 @@
-<?php
-
-use PHPUnit\Framework\ExpectationFailedException;
-
-test('pass', function () {
-    expect((object) ['a' => 1])->toBeObject();
-    expect(['a' => 1])->not->toBeObject();
-});
-
-test('failures', function () {
-    expect(null)->toBeObject();
-})->throws(ExpectationFailedException::class);
-
-test('not failures', function () {
-    expect((object) 'ciao')->not->toBeObject();
-})->throws(ExpectationFailedException::class);

tests/Expect/toBeReadableDirectory.php

@@ -1,15 +0,0 @@
-<?php
-
-use PHPUnit\Framework\ExpectationFailedException;
-
-test('pass', function () {
-    expect(sys_get_temp_dir())->toBeReadableDirectory();
-});
-
-test('failures', function () {
-    expect('/random/path/whatever')->toBeReadableDirectory();
-})->throws(ExpectationFailedException::class);
-
-test('not failures', function () {
-    expect(sys_get_temp_dir())->not->toBeReadableDirectory();
-})->throws(ExpectationFailedException::class);

tests/Expect/toBeReadableFile.php

@@ -1,23 +0,0 @@
-<?php
-
-use PHPUnit\Framework\ExpectationFailedException;
-
-beforeEach(function () {
-    touch($this->tempFile = sys_get_temp_dir() . '/fake.file');
-});
-
-afterEach(function () {
-    unlink($this->tempFile);
-});
-
-test('pass', function () {
-    expect($this->tempFile)->toBeReadableFile();
-});
-
-test('failures', function () {
-    expect('/random/path/whatever.file')->toBeReadableFile();
-})->throws(ExpectationFailedException::class);
-
-test('not failures', function () {
-    expect($this->tempFile)->not->toBeReadableFile();
-})->throws(ExpectationFailedException::class);

tests/Expect/toBeResource.php

@@ -1,22 +0,0 @@
-<?php
-
-use PHPUnit\Framework\ExpectationFailedException;
-
-$resource = tmpfile();
-
-afterAll(function () use ($resource) {
-    fclose($resource);
-});
-
-test('pass', function () use ($resource) {
-    expect($resource)->toBeResource();
-    expect(null)->not->toBeResource();
-});
-
-test('failures', function () {
-    expect(null)->toBeResource();
-})->throws(ExpectationFailedException::class);
-
-test('not failures', function () use ($resource) {
-    expect($resource)->not->toBeResource();
-})->throws(ExpectationFailedException::class);

tests/Expect/toBeScalar.php

@@ -1,15 +0,0 @@
-<?php
-
-use PHPUnit\Framework\ExpectationFailedException;
-
-test('pass', function () {
-    expect(1.1)->toBeScalar();
-});
-
-test('failures', function () {
-    expect(null)->toBeScalar();
-})->throws(ExpectationFailedException::class);
-
-test('not failures', function () {
-    expect(42)->not->toBeScalar();
-})->throws(ExpectationFailedException::class);

tests/Expect/toBeString.php

@@ -1,16 +0,0 @@
-<?php
-
-use PHPUnit\Framework\ExpectationFailedException;
-
-test('pass', function () {
-    expect('1.1')->toBeString();
-    expect(1.1)->not->toBeString();
-});
-
-test('failures', function () {
-    expect(null)->toBeString();
-})->throws(ExpectationFailedException::class);
-
-test('not failures', function () {
-    expect('42')->not->toBeString();
-})->throws(ExpectationFailedException::class);

tests/Expect/toBeTrue.php

@@ -1,15 +0,0 @@
-<?php
-
-use PHPUnit\Framework\ExpectationFailedException;
-
-test('strict comparisons', function () {
-    expect(true)->toBeTrue();
-});
-
-test('failures', function () {
-    expect('')->toBeTrue();
-})->throws(ExpectationFailedException::class);
-
-test('not failures', function () {
-    expect(false)->not->toBe(false);
-})->throws(ExpectationFailedException::class);

tests/Expect/toBeWritableDirectory.php

@@ -1,15 +0,0 @@
-<?php
-
-use PHPUnit\Framework\ExpectationFailedException;
-
-test('pass', function () {
-    expect(sys_get_temp_dir())->toBeWritableDirectory();
-});
-
-test('failures', function () {
-    expect('/random/path/whatever')->toBeWritableDirectory();
-})->throws(ExpectationFailedException::class);
-
-test('not failures', function () {
-    expect(sys_get_temp_dir())->not->toBeWritableDirectory();
-})->throws(ExpectationFailedException::class);

tests/Expect/toBeWritableFile.php

@@ -1,23 +0,0 @@
-<?php
-
-use PHPUnit\Framework\ExpectationFailedException;
-
-beforeEach(function () {
-    touch($this->tempFile = sys_get_temp_dir() . '/fake.file');
-});
-
-afterEach(function () {
-    unlink($this->tempFile);
-});
-
-test('pass', function () {
-    expect($this->tempFile)->toBeWritableFile();
-});
-
-test('failures', function () {
-    expect('/random/path/whatever.file')->toBeWritableFile();
-})->throws(ExpectationFailedException::class);
-
-test('not failures', function () {
-    expect($this->tempFile)->not->toBeWritableFile();
-})->throws(ExpectationFailedException::class);

tests/Expect/toContain.php

@@ -1,19 +0,0 @@
-<?php
-
-use PHPUnit\Framework\ExpectationFailedException;
-
-test('passes strings', function () {
-    expect([1, 2, 42])->toContain(42);
-});
-
-test('passes arrays', function () {
-    expect('Nuno')->toContain('Nu');
-});
-
-test('failures', function () {
-    expect([1, 2, 42])->toContain(3);
-})->throws(ExpectationFailedException::class);
-
-test('not failures', function () {
-    expect([1, 2, 42])->not->toContain(42);
-})->throws(ExpectationFailedException::class);

tests/Expect/toEndWith.php

@@ -1,15 +0,0 @@
-<?php
-
-use PHPUnit\Framework\ExpectationFailedException;
-
-test('pass', function () {
-    expect('username')->toEndWith('name');
-});
-
-test('failures', function () {
-    expect('username')->toEndWith('password');
-})->throws(ExpectationFailedException::class);
-
-test('not failures', function () {
-    expect('username')->not->toEndWith('name');
-})->throws(ExpectationFailedException::class);

tests/Expect/toEqual.php

@@ -1,15 +0,0 @@
-<?php
-
-use PHPUnit\Framework\ExpectationFailedException;
-
-test('pass', function () {
-    expect('00123')->toEqual(123);
-});
-
-test('failures', function () {
-    expect(['a', 'b', 'c'])->toEqual(['a', 'b']);
-})->throws(ExpectationFailedException::class);
-
-test('not failures', function () {
-    expect('042')->not->toEqual(42);
-})->throws(ExpectationFailedException::class);

tests/Expect/toEqualCanonicalizing.php

@@ -1,16 +0,0 @@
-<?php
-
-use PHPUnit\Framework\ExpectationFailedException;
-
-test('pass', function () {
-    expect([1, 2, 3])->toEqualCanonicalizing([3, 1, 2]);
-    expect(['g', 'a', 'z'])->not->toEqualCanonicalizing(['a', 'z']);
-});
-
-test('failures', function () {
-    expect([3, 2, 1])->toEqualCanonicalizing([1, 2]);
-})->throws(ExpectationFailedException::class);
-
-test('not failures', function () {
-    expect(['a', 'b', 'c'])->not->toEqualCanonicalizing(['b', 'a', 'c']);
-})->throws(ExpectationFailedException::class);

tests/Expect/toEqualWithDelta.php

@@ -1,15 +0,0 @@
-<?php
-
-use PHPUnit\Framework\ExpectationFailedException;
-
-test('pass', function () {
-    expect(1.0)->toEqualWithDelta(1.3, .4);
-});
-
-test('failures', function () {
-    expect(1.0)->toEqualWithDelta(1.5, .1);
-})->throws(ExpectationFailedException::class);
-
-test('not failures', function () {
-    expect(1.0)->not->toEqualWithDelta(1.6, .7);
-})->throws(ExpectationFailedException::class);

tests/Expect/toHaveCount.php

@@ -1,15 +0,0 @@
-<?php
-
-use PHPUnit\Framework\ExpectationFailedException;
-
-test('pass', function () {
-    expect([1, 2, 3])->toHaveCount(3);
-});
-
-test('failures', function () {
-    expect([1, 2, 3])->toHaveCount(4);
-})->throws(ExpectationFailedException::class);
-
-test('not failures', function () {
-    expect([1, 2, 3])->not->toHaveCount(3);
-})->throws(ExpectationFailedException::class);

tests/Expect/toHaveKey.php

@@ -1,15 +0,0 @@
-<?php
-
-use PHPUnit\Framework\ExpectationFailedException;
-
-test('pass', function () {
-    expect(['a' => 1, 'b', 'c' => 'world'])->toHaveKey('c');
-});
-
-test('failures', function () {
-    expect(['a' => 1, 'b', 'c' => 'world'])->toHaveKey('hello');
-})->throws(ExpectationFailedException::class);
-
-test('not failures', function () {
-    expect(['a' => 1, 'hello' => 'world', 'c'])->not->toHaveKey('hello');
-})->throws(ExpectationFailedException::class);

tests/Expect/toHaveKeys.php

@@ -1,15 +0,0 @@
-<?php
-
-use PHPUnit\Framework\ExpectationFailedException;
-
-test('pass', function () {
-    expect(['a' => 1, 'b', 'c' => 'world'])->toHaveKeys(['a', 'c']);
-});
-
-test('failures', function () {
-    expect(['a' => 1, 'b', 'c' => 'world'])->toHaveKeys(['a', 'd']);
-})->throws(ExpectationFailedException::class);
-
-test('not failures', function () {
-    expect(['a' => 1, 'hello' => 'world', 'c'])->not->toHaveKeys(['hello', 'c']);
-})->throws(ExpectationFailedException::class);

tests/Expect/toHaveProperty.php

@@ -1,22 +0,0 @@
-<?php
-
-use PHPUnit\Framework\ExpectationFailedException;
-
-$obj          = new stdClass();
-$obj->foo     = 'bar';
-$obj->fooNull = null;
-
-test('pass', function () use ($obj) {
-    expect($obj)->toHaveProperty('foo');
-    expect($obj)->toHaveProperty('foo', 'bar');
-    expect($obj)->toHaveProperty('fooNull');
-    expect($obj)->toHaveProperty('fooNull', null);
-});
-
-test('failures', function () use ($obj) {
-    expect($obj)->toHaveProperty('bar');
-})->throws(ExpectationFailedException::class);
-
-test('not failures', function () use ($obj) {
-    expect($obj)->not->toHaveProperty('foo');
-})->throws(ExpectationFailedException::class);

tests/Expect/toMatch.php

@@ -1,15 +0,0 @@
-<?php
-
-use PHPUnit\Framework\ExpectationFailedException;
-
-test('pass', function () {
-    expect('Hello World')->toMatch('/^hello wo.*$/i');
-});
-
-test('failures', function () {
-    expect('Hello World')->toMatch('/^hello$/i');
-})->throws(ExpectationFailedException::class);
-
-test('not failures', function () {
-    expect('Hello World')->not->toMatch('/^hello wo.*$/i');
-})->throws(ExpectationFailedException::class);

tests/Expect/toMatchConstraint.php

@@ -1,16 +0,0 @@
-<?php
-
-use PHPUnit\Framework\Constraint\IsTrue;
-use PHPUnit\Framework\ExpectationFailedException;
-
-test('pass', function () {
-    expect(true)->toMatchConstraint(new IsTrue());
-});
-
-test('failures', function () {
-    expect(false)->toMatchConstraint(new IsTrue());
-})->throws(ExpectationFailedException::class);
-
-test('not failures', function () {
-    expect(true)->not->toMatchConstraint(new IsTrue());
-})->throws(ExpectationFailedException::class);

tests/Expect/toMatchObject.php

@@ -1,31 +0,0 @@
-<?php
-
-use PHPUnit\Framework\ExpectationFailedException;
-
-beforeEach(function () {
-    $this->user = (object) [
-        'id'    => 1,
-        'name'  => 'Nuno',
-        'email' => 'enunomaduro@gmail.com',
-    ];
-});
-
-test('pass', function () {
-    expect($this->user)->toMatchObject([
-        'name'  => 'Nuno',
-        'email' => 'enunomaduro@gmail.com',
-    ]);
-});
-
-test('failures', function () {
-    expect($this->user)->toMatchObject([
-        'name'  => 'Not the same name',
-        'email' => 'enunomaduro@gmail.com',
-    ]);
-})->throws(ExpectationFailedException::class);
-
-test('not failures', function () {
-    expect($this->user)->not->toMatchObject([
-        'id' => 1,
-    ]);
-})->throws(ExpectationFailedException::class);

tests/Expect/toStartWith.php

@@ -1,15 +0,0 @@
-<?php
-
-use PHPUnit\Framework\ExpectationFailedException;
-
-test('pass', function () {
-    expect('username')->toStartWith('user');
-});
-
-test('failures', function () {
-    expect('username')->toStartWith('password');
-})->throws(ExpectationFailedException::class);
-
-test('not failures', function () {
-    expect('username')->not->toStartWith('user');
-})->throws(ExpectationFailedException::class);

tests/Features/AfterEach.php

@@ -6,7 +6,7 @@ beforeEach(function () use ($state) {
     $this->state = $state;
 });
 
-afterEach(function () use ($state) {
+afterEach(function () {
     $this->state->bar = 2;
 });
 

tests/Features/Datasets.php

@@ -116,7 +116,7 @@ $namedDatasets = [
     new Bar(),
 ];
 
-test('lazy named datasets', function ($text) use ($state, $datasets) {
+test('lazy named datasets', function ($text) {
     expect(true)->toBeTrue();
 })->with($namedDatasets);
 

tests/Features/Depends.php

@@ -32,3 +32,7 @@ test('depends with defined arguments', function (string $first, string $second)
 test('depends run test only once', function () use (&$runCounter) {
     expect($runCounter)->toBe(2);
 })->depends('first', 'second');
+
+// Regression tests. See https://github.com/pestphp/pest/pull/216
+it('asserts true is true')->assertTrue(true);
+test('depends works with the correct test name')->assertTrue(true)->depends('it asserts true is true');

tests/Features/DependsInheritance.php

@@ -0,0 +1,22 @@
+<?php
+
+use PHPUnit\Framework\TestCase;
+
+class InheritanceTest extends TestCase
+{
+    public function foo()
+    {
+        return 'bar';
+    }
+}
+
+uses(InheritanceTest::class);
+
+it('is a test', function () {
+    expect(true)->toBeTrue();
+});
+
+it('uses correct parent class', function () {
+    expect(get_parent_class($this))->toEqual(InheritanceTest::class);
+    expect($this->foo())->toEqual('bar');
+})->depends('it is a test');

tests/Hooks/AfterAllTest.php

@@ -0,0 +1,27 @@
+<?php
+
+global $globalHook;
+
+uses()->afterAll(function () use ($globalHook) {
+    expect($globalHook)
+        ->toHaveProperty('afterAll')
+        ->and($globalHook->afterAll)
+        ->toBe(0);
+
+    $globalHook->afterAll = 1;
+});
+
+afterAll(function () use ($globalHook) {
+    expect($globalHook)
+        ->toHaveProperty('afterAll')
+        ->and($globalHook->afterAll)
+        ->toBe(1);
+
+    $globalHook->afterAll = 2;
+});
+
+test('global afterAll execution order', function () use ($globalHook) {
+    expect($globalHook)
+        ->not()
+        ->toHaveProperty('afterAll');
+});

tests/Hooks/AfterEachTest.php

@@ -0,0 +1,23 @@
+<?php
+
+uses()->afterEach(function () {
+    expect($this)
+        ->toHaveProperty('ith')
+        ->and($this->ith)
+        ->toBe(0);
+
+    $this->ith = 1;
+});
+
+afterEach(function () {
+    expect($this)
+        ->toHaveProperty('ith')
+        ->and($this->ith)
+        ->toBe(1);
+});
+
+test('global afterEach execution order', function () {
+    expect($this)
+        ->not()
+        ->toHaveProperty('ith');
+});

tests/Hooks/BeforeAllTest.php

@@ -0,0 +1,28 @@
+<?php
+
+global $globalHook;
+
+uses()->beforeAll(function () use ($globalHook) {
+    expect($globalHook)
+        ->toHaveProperty('beforeAll')
+        ->and($globalHook->beforeAll)
+        ->toBe(0);
+
+    $globalHook->beforeAll = 1;
+});
+
+beforeAll(function () use ($globalHook) {
+    expect($globalHook)
+        ->toHaveProperty('beforeAll')
+        ->and($globalHook->beforeAll)
+        ->toBe(1);
+
+    $globalHook->beforeAll = 2;
+});
+
+test('global beforeAll execution order', function () use ($globalHook) {
+    expect($globalHook)
+        ->toHaveProperty('beforeAll')
+        ->and($globalHook->beforeAll)
+        ->toBe(2);
+});

tests/Hooks/BeforeEachTest.php

@@ -0,0 +1,26 @@
+<?php
+
+uses()->beforeEach(function () {
+    expect($this)
+        ->toHaveProperty('baz')
+        ->and($this->baz)
+        ->toBe(0);
+
+    $this->baz = 1;
+});
+
+beforeEach(function () {
+    expect($this)
+        ->toHaveProperty('baz')
+        ->and($this->baz)
+        ->toBe(1);
+
+    $this->baz = 2;
+});
+
+test('global beforeEach execution order', function () {
+    expect($this)
+        ->toHaveProperty('baz')
+        ->and($this->baz)
+        ->toBe(2);
+});

tests/PHPUnit/CustomAffixes/@#$%^&()-_=+.php

@@ -0,0 +1,10 @@
+<?php
+
+/*
+ * NOTE: To preserve cross-platform testing compatibility we cannot use ! * and
+ * other Windows reserved characters in this test's filename.
+ *
+ * See https://docs.microsoft.com/en-us/windows/win32/fileio/naming-a-file#naming-conventions
+ */
+
+it(sprintf('runs file names like `%s`', basename(__FILE__)))->assertTrue(true);

tests/PHPUnit/CustomAffixes/A Test With Spaces.php

@@ -0,0 +1,3 @@
+<?php
+
+it(sprintf('runs file names like `%s`', basename(__FILE__)))->assertTrue(true);

tests/PHPUnit/CustomAffixes/AdditionalFileExtension.spec.php

@@ -0,0 +1,3 @@
+<?php
+
+it(sprintf('runs file names like `%s`', basename(__FILE__)))->assertTrue(true);

tests/PHPUnit/CustomAffixes/ManyExtensions.class.test.php

@@ -0,0 +1,3 @@
+<?php
+
+it(sprintf('runs file names like `%s`', basename(__FILE__)))->assertTrue(true);

tests/PHPUnit/CustomAffixes/Test 'Case' With Quotes.php

@@ -0,0 +1,3 @@
+<?php
+
+it(sprintf('runs file names like `%s`', basename(__FILE__)))->assertTrue(true);

tests/PHPUnit/CustomAffixes/kebab-case-spec.php

@@ -0,0 +1,3 @@
+<?php
+
+it(sprintf('runs file names like `%s`', basename(__FILE__)))->assertTrue(true);

tests/PHPUnit/CustomAffixes/snake_case_spec.php

@@ -0,0 +1,3 @@
+<?php
+
+it(sprintf('runs file names like `%s`', basename(__FILE__)))->assertTrue(true);

tests/Pest.php

@@ -1,3 +1,20 @@
 <?php
 
 uses()->group('integration')->in('Visual');
+
+$globalHook = (object) []; // NOTE: global test value container to be mutated and checked across files, as needed
+
+uses()
+    ->beforeEach(function () {
+        $this->baz = 0;
+    })
+    ->beforeAll(function () use ($globalHook) {
+        $globalHook->beforeAll = 0;
+    })
+    ->afterEach(function () {
+        $this->ith = 0;
+    })
+    ->afterAll(function () use ($globalHook) {
+        $globalHook->afterAll = 0;
+    })
+    ->in('Hooks');

tests/Unit/Actions/AddsTests.php

@@ -22,7 +22,7 @@ test('default php unit tests', function () {
     expect($testSuite->tests())->toHaveCount(1);
 });
 
-it('removes warnings', function () use ($pestTestCase) {
+it('removes warnings', function () {
     $testSuite = new TestSuite();
     $warningTestCase = new WarningTestCase('No tests found in class "Pest\TestCase".');
     $testSuite->addTest($warningTestCase);

tests/Unit/Console/Help.php

@@ -0,0 +1,12 @@
+<?php
+
+use Pest\Console\Help;
+use Symfony\Component\Console\Output\BufferedOutput;
+
+it('outputs the help information when --help is used', function () {
+    $output = new BufferedOutput();
+    $plugin = new Help($output);
+
+    $plugin();
+    expect($output->fetch())->toContain('Pest Options:');
+});

tests/Visual/Help.php

@@ -0,0 +1,27 @@
+<?php
+
+use Pest\Console\Help;
+use Symfony\Component\Console\Output\BufferedOutput;
+
+test('visual snapshot of help command output', function () {
+    $snapshot = __DIR__ . '/../.snapshots/help-command.txt';
+
+    if (getenv('REBUILD_SNAPSHOTS')) {
+        $outputBuffer = new BufferedOutput();
+        $plugin = new Help($outputBuffer);
+
+        $plugin();
+
+        file_put_contents($snapshot, $outputBuffer->fetch());
+    }
+
+    $output = function () {
+        $process = (new Symfony\Component\Process\Process(['php', 'bin/pest', '--help']));
+
+        $process->run();
+
+        return preg_replace('#\\x1b[[][^A-Za-z]*[A-Za-z]#', '', $process->getOutput());
+    };
+
+    expect($output())->toContain(file_get_contents($snapshot));
+})->skip(PHP_OS_FAMILY === 'Windows');