Merge branch 'master' into fix-missing-dataset-errors

src/Support/HigherOrderCallables.php

@@ -0,0 +1,66 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Pest\Support;
+
+use Closure;
+use Pest\Expectation;
+use Pest\PendingObjects\TestCall;
+use PHPUnit\Framework\TestCase;
+
+/**
+ * @internal
+ */
+final class HigherOrderCallables
+{
+    /**
+     * @var object
+     */
+    private $target;
+
+    public function __construct(object $target)
+    {
+        $this->target = $target;
+    }
+
+    /**
+     * @template TValue
+     *
+     * Create a new expectation. Callable values will be executed prior to returning the new expectation.
+     *
+     * @param callable|TValue $value
+     *
+     * @return Expectation<TValue>
+     */
+    public function expect($value)
+    {
+        return new Expectation($value instanceof Closure ? Reflection::bindCallableWithData($value) : $value);
+    }
+
+    /**
+     * @template TValue
+     *
+     * Create a new expectation. Callable values will be executed prior to returning the new expectation.
+     *
+     * @param callable|TValue $value
+     *
+     * @return Expectation<TValue>
+     */
+    public function and($value)
+    {
+        return $this->expect($value);
+    }
+
+    /**
+     * Tap into the test case to perform an action and return the test case.
+     *
+     * @return TestCall|TestCase|object
+     */
+    public function tap(callable $callable)
+    {
+        Reflection::bindCallableWithData($callable);
+
+        return $this->target;
+    }
+}

src/Support/HigherOrderMessage.php

@@ -4,6 +4,7 @@ declare(strict_types=1);
 
 namespace Pest\Support;
 
+use Closure;
 use ReflectionClass;
 use Throwable;
 
@@ -33,33 +34,40 @@ final class HigherOrderMessage
     public $line;
 
     /**
-     * The method name.
+     * The method or property name to access.
      *
      * @readonly
      *
      * @var string
      */
-    public $methodName;
+    public $name;
 
     /**
      * The arguments.
      *
-     * @var array<int, mixed>
+     * @var array<int, mixed>|null
      *
      * @readonly
      */
     public $arguments;
 
+    /**
+     * An optional condition that will determine if the message will be executed.
+     *
+     * @var callable(): bool|null
+     */
+    public $condition = null;
+
     /**
      * Creates a new higher order message.
      *
-     * @param array<int, mixed> $arguments
+     * @param array<int, mixed>|null $arguments
      */
-    public function __construct(string $filename, int $line, string $methodName, array $arguments)
+    public function __construct(string $filename, int $line, string $methodName, $arguments)
     {
         $this->filename   = $filename;
         $this->line       = $line;
-        $this->methodName = $methodName;
+        $this->name       = $methodName;
         $this->arguments  = $arguments;
     }
 
@@ -70,24 +78,58 @@ final class HigherOrderMessage
      */
     public function call(object $target)
     {
+        /* @phpstan-ignore-next-line */
+        if (is_callable($this->condition) && call_user_func(Closure::bind($this->condition, $target)) === false) {
+            return $target;
+        }
+
+        if ($this->hasHigherOrderCallable()) {
+            /* @phpstan-ignore-next-line */
+            return (new HigherOrderCallables($target))->{$this->name}(...$this->arguments);
+        }
+
         try {
-            return Reflection::call($target, $this->methodName, $this->arguments);
+            return is_array($this->arguments)
+                ? Reflection::call($target, $this->name, $this->arguments)
+                : $target->{$this->name}; /* @phpstan-ignore-line */
         } catch (Throwable $throwable) {
             Reflection::setPropertyValue($throwable, 'file', $this->filename);
             Reflection::setPropertyValue($throwable, 'line', $this->line);
 
-            if ($throwable->getMessage() === self::getUndefinedMethodMessage($target, $this->methodName)) {
+            if ($throwable->getMessage() === self::getUndefinedMethodMessage($target, $this->name)) {
                 /** @var ReflectionClass $reflection */
                 $reflection = new ReflectionClass($target);
                 /* @phpstan-ignore-next-line */
                 $reflection = $reflection->getParentClass() ?: $reflection;
-                Reflection::setPropertyValue($throwable, 'message', sprintf('Call to undefined method %s::%s()', $reflection->getName(), $this->methodName));
+                Reflection::setPropertyValue($throwable, 'message', sprintf('Call to undefined method %s::%s()', $reflection->getName(), $this->name));
             }
 
             throw $throwable;
         }
     }
 
+    /**
+     * Indicates that this message should only be called when the given condition is true.
+     *
+     * @param callable(): bool $condition
+     */
+    public function when(callable $condition): self
+    {
+        $this->condition = $condition;
+
+        return $this;
+    }
+
+    /**
+     * Determines whether or not there exists a higher order callable with the message name.
+     *
+     * @return bool
+     */
+    private function hasHigherOrderCallable()
+    {
+        return in_array($this->name, get_class_methods(HigherOrderCallables::class), true);
+    }
+
     private static function getUndefinedMethodMessage(object $target, string $methodName): string
     {
         if (\PHP_MAJOR_VERSION >= 8) {

src/Support/HigherOrderMessageCollection.php

@@ -17,11 +17,21 @@ final class HigherOrderMessageCollection
     /**
      * Adds a new higher order message to the collection.
      *
-     * @param array<int, mixed> $arguments
+     * @param array<int, mixed>|null $arguments
      */
-    public function add(string $filename, int $line, string $methodName, array $arguments): void
+    public function add(string $filename, int $line, string $name, array $arguments = null): void
     {
-        $this->messages[] = new HigherOrderMessage($filename, $line, $methodName, $arguments);
+        $this->messages[] = new HigherOrderMessage($filename, $line, $name, $arguments);
+    }
+
+    /**
+     * Adds a new higher order message to the collection if the callable condition is does not return false.
+     *
+     * @param array<int, mixed>|null $arguments
+     */
+    public function addWhen(callable $condition, string $filename, int $line, string $name, array $arguments = null): void
+    {
+        $this->messages[] = (new HigherOrderMessage($filename, $line, $name, $arguments))->when($condition);
     }
 
     /**

src/Support/HigherOrderTapProxy.php

@@ -4,6 +4,7 @@ declare(strict_types=1);
 
 namespace Pest\Support;
 
+use PHPUnit\Framework\TestCase;
 use ReflectionClass;
 use Throwable;
 
@@ -17,16 +18,14 @@ final class HigherOrderTapProxy
     /**
      * The target being tapped.
      *
-     * @var mixed
+     * @var TestCase
      */
     public $target;
 
     /**
      * Create a new tap proxy instance.
-     *
-     * @param mixed $target
      */
-    public function __construct($target)
+    public function __construct(TestCase $target)
     {
         $this->target = $target;
     }

src/Support/Reflection.php

@@ -42,15 +42,40 @@ final class Reflection
             }
 
             if (is_callable($method)) {
-                return Closure::fromCallable($method)->bindTo(
-                    TestSuite::getInstance()->test
-                )(...$args);
+                return static::bindCallable($method, $args);
             }
 
             throw $exception;
         }
     }
 
+    /**
+     * Bind a callable to the TestCase and return the result.
+     *
+     * @param array<int, mixed> $args
+     *
+     * @return mixed
+     */
+    public static function bindCallable(callable $callable, array $args = [])
+    {
+        return Closure::fromCallable($callable)->bindTo(TestSuite::getInstance()->test)(...$args);
+    }
+
+    /**
+     * Bind a callable to the TestCase and return the result,
+     * passing in the current dataset values as arguments.
+     *
+     * @return mixed
+     */
+    public static function bindCallableWithData(callable $callable)
+    {
+        $test = TestSuite::getInstance()->test;
+
+        return $test === null
+            ? static::bindCallable($callable)
+            : Closure::fromCallable($callable)->bindTo($test)(...$test->getProvidedData());
+    }
+
     /**
      * Infers the file name from the given closure.
      */
@@ -85,10 +110,6 @@ final class Reflection
             }
         }
 
-        if ($reflectionProperty === null) {
-            throw ShouldNotHappen::fromMessage('Reflection property not found.');
-        }
-
         $reflectionProperty->setAccessible(true);
 
         return $reflectionProperty->getValue($object);
@@ -119,10 +140,6 @@ final class Reflection
             }
         }
 
-        if ($reflectionProperty === null) {
-            throw ShouldNotHappen::fromMessage('Reflection property not found.');
-        }
-
         $reflectionProperty->setAccessible(true);
         $reflectionProperty->setValue($object, $value);
     }