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

src/Concerns/Expectable.php

@@ -12,9 +12,13 @@ use Pest\Expectation;
 trait Expectable
 {
     /**
+     * @template TValue
+     *
      * Creates a new expectation.
      *
-     * @param mixed $value
+     * @param TValue $value
+     *
+     * @return Expectation<TValue>
      */
     public function expect($value): Expectation
     {

src/Concerns/Extendable.php

@@ -4,8 +4,8 @@ declare(strict_types=1);
 
 namespace Pest\Concerns;
 
+use BadMethodCallException;
 use Closure;
-use Pest\HigherOrderExpectation;
 
 /**
  * @internal
@@ -43,7 +43,7 @@ trait Extendable
     public function __call(string $method, array $parameters)
     {
         if (!static::hasExtend($method)) {
-            return new HigherOrderExpectation($this, $method, $parameters);
+            throw new BadMethodCallException("$method is not a callable method name.");
         }
 
         /** @var Closure $extend */

src/Concerns/RetrievesValues.php

@@ -0,0 +1,31 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Pest\Concerns;
+
+/**
+ * @internal
+ */
+trait RetrievesValues
+{
+    /**
+     * @template TRetrievableValue
+     *
+     * Safely retrieve the value at the given key from an object or array.
+     *
+     * @param array<string, TRetrievableValue>|object $value
+     * @param TRetrievableValue|null                  $default
+     *
+     * @return TRetrievableValue|null
+     */
+    private function retrieve(string $key, $value, $default = null)
+    {
+        if (is_array($value)) {
+            return $value[$key] ?? $default;
+        }
+
+        // @phpstan-ignore-next-line
+        return $value->$key ?? $default;
+    }
+}

src/Expectation.php

@@ -6,6 +6,7 @@ namespace Pest;
 
 use BadMethodCallException;
 use Pest\Concerns\Extendable;
+use Pest\Concerns\RetrievesValues;
 use Pest\Support\Arr;
 use PHPUnit\Framework\Assert;
 use PHPUnit\Framework\Constraint\Constraint;
@@ -15,12 +16,17 @@ use SebastianBergmann\Exporter\Exporter;
 /**
  * @internal
  *
+ * @template TValue
+ *
  * @property Expectation $not  Creates the opposite expectation.
  * @property Each        $each Creates an expectation on each element on the traversable value.
  */
 final class Expectation
 {
-    use Extendable;
+    use Extendable {
+        __call as __extendsCall;
+    }
+    use RetrievesValues;
 
     /**
      * The expectation value.
@@ -43,7 +49,7 @@ final class Expectation
     /**
      * Creates a new expectation.
      *
-     * @param mixed $value
+     * @param TValue $value
      */
     public function __construct($value)
     {
@@ -53,13 +59,23 @@ final class Expectation
     /**
      * Creates a new expectation.
      *
-     * @param mixed $value
+     * @param TValue $value
+     *
+     * @return Expectation<TValue>
      */
     public function and($value): Expectation
     {
         return new self($value);
     }
 
+    /**
+     * Creates a new expectation with the decoded JSON value.
+     */
+    public function json(): Expectation
+    {
+        return $this->toBeJson()->and(json_decode($this->value, true));
+    }
+
     /**
      * Dump the expectation value and end the script.
      *
@@ -112,7 +128,7 @@ final class Expectation
 
         if (is_callable($callback)) {
             foreach ($this->value as $item) {
-                $callback(expect($item));
+                $callback(new self($item));
             }
         }
 
@@ -121,8 +137,12 @@ final class Expectation
 
     /**
      * Allows you to specify a sequential set of expectations for each item in a iterable "value".
+     *
+     * @template TSequenceValue
+     *
+     * @param callable(self, self): void|TSequenceValue ...$callbacks
      */
-    public function sequence(callable ...$callbacks): Expectation
+    public function sequence(...$callbacks): Expectation
     {
         if (!is_iterable($this->value)) {
             throw new BadMethodCallException('Expectation value is not iterable.');
@@ -140,7 +160,12 @@ final class Expectation
         }
 
         foreach ($values as $key => $item) {
-            call_user_func($callbacks[$key], expect($item), expect($keys[$key]));
+            if (is_callable($callbacks[$key])) {
+                call_user_func($callbacks[$key], new self($item), new self($keys[$key]));
+                continue;
+            }
+
+            (new self($item))->toEqual($callbacks[$key]);
         }
 
         return $this;
@@ -704,6 +729,24 @@ final class Expectation
         return $this->exporter->export($value);
     }
 
+    /**
+     * Dynamically handle calls to the class or
+     * creates a new higher order expectation.
+     *
+     * @param array<int, mixed> $parameters
+     *
+     * @return HigherOrderExpectation|mixed
+     */
+    public function __call(string $method, array $parameters)
+    {
+        if (!static::hasExtend($method)) {
+            /* @phpstan-ignore-next-line */
+            return new HigherOrderExpectation($this, $this->value->$method(...$parameters));
+        }
+
+        return $this->__extendsCall($method, $parameters);
+    }
+
     /**
      * Dynamically calls methods on the class without any arguments
      * or creates a new higher order expectation.
@@ -713,7 +756,7 @@ final class Expectation
     public function __get(string $name)
     {
         if (!method_exists($this, $name) && !static::hasExtend($name)) {
-            return new HigherOrderExpectation($this, $name);
+            return new HigherOrderExpectation($this, $this->retrieve($name, $this->value));
         }
 
         /* @phpstan-ignore-next-line */

src/HigherOrderExpectation.php

@@ -5,6 +5,7 @@ declare(strict_types=1);
 namespace Pest;
 
 use Pest\Concerns\Expectable;
+use Pest\Concerns\RetrievesValues;
 
 /**
  * @internal
@@ -14,6 +15,7 @@ use Pest\Concerns\Expectable;
 final class HigherOrderExpectation
 {
     use Expectable;
+    use RetrievesValues;
 
     /**
      * @var Expectation
@@ -30,6 +32,11 @@ final class HigherOrderExpectation
      */
     private $opposite = false;
 
+    /**
+     * @var bool
+     */
+    private $shouldReset = false;
+
     /**
      * @var string
      */
@@ -38,45 +45,12 @@ final class HigherOrderExpectation
     /**
      * Creates a new higher order expectation.
      *
-     * @param array<int|string, mixed>|null $parameters
-     * @phpstan-ignore-next-line
+     * @param mixed $value
      */
-    public function __construct(Expectation $original, string $name, ?array $parameters = null)
+    public function __construct(Expectation $original, $value)
     {
-        $this->original = $original;
-        $this->name     = $name;
-
-        $this->expectation = $this->expect(
-            is_null($parameters) ? $this->getPropertyValue() : $this->getMethodValue($parameters)
-        );
-    }
-
-    /**
-     * Retrieves the property value from the original expectation.
-     *
-     * @return mixed
-     */
-    private function getPropertyValue()
-    {
-        if (is_array($this->original->value)) {
-            return $this->original->value[$this->name];
-        }
-
-        // @phpstan-ignore-next-line
-        return $this->original->value->{$this->name};
-    }
-
-    /**
-     * Retrieves the value of the method from the original expectation.
-     *
-     * @param array<int|string, mixed> $arguments
-     *
-     * @return mixed
-     */
-    private function getMethodValue(array $arguments)
-    {
-        // @phpstan-ignore-next-line
-        return $this->original->value->{$this->name}(...$arguments);
+        $this->original     = $original;
+        $this->expectation  = $this->expect($value);
     }
 
     /**
@@ -92,12 +66,13 @@ final class HigherOrderExpectation
     /**
      * Dynamically calls methods on the class with the given arguments.
      *
-     * @param array<int|string, mixed> $arguments
+     * @param array<int, mixed> $arguments
      */
     public function __call(string $name, array $arguments): self
     {
-        if (!$this->originalHasMethod($name)) {
-            return new self($this->original, $name, $arguments);
+        if (!$this->expectationHasMethod($name)) {
+            /* @phpstan-ignore-next-line */
+            return new self($this->original, $this->getValue()->$name(...$arguments));
         }
 
         return $this->performAssertion($name, $arguments);
@@ -112,8 +87,8 @@ final class HigherOrderExpectation
             return $this->not();
         }
 
-        if (!$this->originalHasMethod($name)) {
-            return new self($this->original, $name);
+        if (!$this->expectationHasMethod($name)) {
+            return new self($this->original, $this->retrieve($name, $this->getValue()));
         }
 
         return $this->performAssertion($name, []);
@@ -122,25 +97,33 @@ final class HigherOrderExpectation
     /**
      * Determines if the original expectation has the given method name.
      */
-    private function originalHasMethod(string $name): bool
+    private function expectationHasMethod(string $name): bool
     {
         return method_exists($this->original, $name) || $this->original::hasExtend($name);
     }
 
+    /**
+     * Retrieve the applicable value based on the current reset condition.
+     *
+     * @return mixed
+     */
+    private function getValue()
+    {
+        return $this->shouldReset ? $this->original->value : $this->expectation->value;
+    }
+
     /**
      * Performs the given assertion with the current expectation.
      *
-     * @param array<int|string, mixed> $arguments
+     * @param array<int, mixed> $arguments
      */
     private function performAssertion(string $name, array $arguments): self
     {
-        $expectation = $this->opposite
-            ? $this->expectation->not()
-            : $this->expectation;
+        /* @phpstan-ignore-next-line */
+        $this->expectation = ($this->opposite ? $this->expectation->not() : $this->expectation)->{$name}(...$arguments);
 
-        $this->expectation = $expectation->{$name}(...$arguments); // @phpstan-ignore-line
-
-        $this->opposite = false;
+        $this->opposite    = false;
+        $this->shouldReset = true;
 
         return $this;
     }

src/Pest.php

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