Adds HigherOrderExpectations

src/Concerns/Extendable.php

@@ -4,8 +4,8 @@
 
 namespace Pest\Expectations\Concerns;
 
-use BadMethodCallException;
 use Closure;
+use Pest\Expectations\HigherOrderExpectation;
 
 /**
  * @internal
@@ -40,12 +40,11 @@ public static function hasExtend(string $name): bool
      *
      * @return mixed
      *
-     * @throws BadMethodCallException
      */
     public function __call(string $method, array $parameters)
     {
         if (!static::hasExtend($method)) {
-            throw new BadMethodCallException(sprintf('Method %s::%s does not exist.', static::class, $method));
+            return new HigherOrderExpectation($this, $method, true, ...$parameters);
         }
 
         /** @var Closure $extend */

src/Expectation.php

@@ -680,12 +680,17 @@ private function export($value): string
     }
 
     /**
-     * Dynamically calls methods on the class without any arguments.
+     * Dynamically calls methods on the class without any arguments
+     * or creates a new higher order expectation.
      *
-     * @return Expectation
+     * @return Expectation|HigherOrderExpectation
      */
     public function __get(string $name)
     {
+        if (!method_exists($this, $name) && !static::hasExtend($name)) {
+            return new HigherOrderExpectation($this, $name);
+        }
+
         /* @phpstan-ignore-next-line */
         return $this->{$name}();
     }

src/HigherOrderExpectation.php

@@ -0,0 +1,131 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Pest\Expectations;
+
+use Pest\Expectations\Concerns\Expectations;
+
+/**
+ * @internal
+ *
+ * @mixin Expectation
+ */
+final class HigherOrderExpectation
+{
+    use Expectations;
+
+    /**
+     * @var Expectation
+     */
+    private $original;
+
+    /**
+     * @var Expectation|Each
+     */
+    private $expectation;
+
+    /**
+     * @var bool
+     */
+    private $opposite;
+
+    /**
+     * @var string
+     */
+    private $name;
+
+    /**
+     * Creates a new higher order expectation.
+     */
+    public function __construct(Expectation $original, string $name, bool $asMethod = false, ...$arguments)
+    {
+        $this->original = $original;
+        $this->name = $name;
+        $this->expectation = $this->generateInitialExpectation($asMethod, ...$arguments);
+    }
+
+    /**
+     * Generates the initial state of the expectation.
+     */
+    private function generateInitialExpectation($asMethod, ...$arguments)
+    {
+        return $this->expect($asMethod ? $this->original->value->{$this->name}(...$arguments) : $this->getPropertyValue());
+    }
+
+    /**
+     * Retrieves the property value from the original expectation.
+     */
+    private function getPropertyValue()
+    {
+        if (is_array($this->original->value)) {
+            return $this->original->value[$this->name];
+        }
+
+        if (is_object($this->original->value)) {
+            return $this->original->value->{$this->name};
+        }
+    }
+
+    /**
+     * Creates the opposite expectation for the value.
+     */
+    public function not(): HigherOrderExpectation
+    {
+        $this->opposite = true;
+
+        return $this;
+    }
+
+    /**
+     * Dynamically calls methods on the class with the given arguments on each item.
+     *
+     * @param array<int|string, mixed> $arguments
+     */
+    public function __call(string $name, array $arguments): HigherOrderExpectation
+    {
+        if (!$this->originalHasMethod($name)) {
+            return new static($this->original, $name, true, ...$arguments);
+        }
+
+        return $this->performAssertion($name, ...$arguments);
+    }
+
+    /**
+     * Accesses properties in the value or in the expectation.
+     */
+    public function __get(string $name): HigherOrderExpectation
+    {
+        if ($name == 'not') {
+            return $this->not();
+        }
+
+        if (!$this->originalHasMethod($name)) {
+            return new static($this->original, $name);
+        }
+
+        return $this->performAssertion($name);
+    }
+
+    /**
+     * Determines if the original expectation has the given method name.
+     */
+    private function originalHasMethod($name): bool
+    {
+        return method_exists($this->original, $name) || $this->original::hasExtend($name);
+    }
+
+    /**
+     * Performs the given assertion with the current expectation.
+     */
+    private function performAssertion($name, ...$arguments)
+    {
+        $this->expectation = $this->opposite
+            ? $this->expectation->not()->{$name}(...$arguments)
+            : $this->expectation->{$name}(...$arguments);
+
+        $this->opposite = false;
+
+        return $this;
+    }
+}

tests/Expect/HigherOrder/methods.php

@@ -0,0 +1,100 @@
+<?php
+
+it('can access methods', function () {
+    expect(new HasMethods)
+        ->name()->toBeString()->toEqual('Has Methods');
+});
+
+it('can access multiple methods', function () {
+    expect(new HasMethods)
+        ->name()->toBeString()->toEqual('Has Methods')
+        ->quantity()->toBeInt()->toEqual(20);
+});
+
+it('works with not', function () {
+    expect(new HasMethods)
+        ->name()->not->toEqual('world')->toEqual('Has Methods')
+        ->quantity()->toEqual(20)->not()->toEqual('bar')->not->toBeNull;
+});
+
+it('can accept arguments', function () {
+    expect(new HasMethods)
+        ->multiply(5, 4)->toBeInt->toEqual(20);
+});
+
+it('works with each', function () {
+    expect(new HasMethods)
+        ->attributes()->toBeArray->each->not()->toBeNull
+        ->attributes()->each(function ($attribute) {
+            $attribute->not->toBeNull();
+        });
+});
+
+it('works inside of each', function () {
+    expect(new HasMethods)
+        ->books()->each(function ($book) {
+            $book->title->not->toBeNull->cost->toBeGreaterThan(19);
+        });
+});
+
+it('works with sequence', function () {
+    expect(new HasMethods)
+        ->books()->sequence(
+            function ($book) { $book->title->toEqual('Foo')->cost->toEqual(20); },
+            function ($book) { $book->title->toEqual('Bar')->cost->toEqual(30); },
+        );
+});
+
+it('can compose complex expectations', function () {
+    expect(new HasMethods)
+        ->toBeObject()
+        ->name()->toEqual('Has Methods')->not()->toEqual('bar')
+        ->quantity()->not->toEqual('world')->toEqual(20)->toBeInt
+        ->multiply(3, 4)->not->toBeString->toEqual(12)
+        ->attributes()->toBeArray()
+        ->books()->toBeArray->each->not->toBeEmpty
+        ->books()->sequence(
+            function ($book) { $book->title->toEqual('Foo')->cost->toEqual(20); },
+            function ($book) { $book->title->toEqual('Bar')->cost->toEqual(30); },
+        );
+});
+
+class HasMethods
+{
+    public function name()
+    {
+        return 'Has Methods';
+    }
+
+    public function quantity()
+    {
+        return 20;
+    }
+
+    public function multiply($x, $y)
+    {
+        return $x * $y;
+    }
+
+    public function attributes()
+    {
+        return [
+            'name' => $this->name(),
+            'quantity' => $this->quantity()
+        ];
+    }
+
+    public function books()
+    {
+        return [
+            [
+                'title' => 'Foo',
+                'cost' => 20,
+            ],
+            [
+                'title' => 'Bar',
+                'cost' => 30,
+            ],
+        ];
+    }
+}

tests/Expect/HigherOrder/methodsAndProperties.php

@@ -0,0 +1,49 @@
+<?php
+
+it('can access methods and properties', function () {
+    expect(new HasMethodsAndProperties)
+        ->name->toEqual('Has Methods and Properties')->not()->toEqual('bar')
+        ->multiply(3, 4)->not->toBeString->toEqual(12)
+        ->posts->each(fn ($post) => $post->is_published->toBeTrue)
+        ->books()->toBeArray()
+        ->posts->toBeArray->each->not->toBeEmpty
+        ->books()->sequence(
+            function ($book) { $book->title->toEqual('Foo')->cost->toEqual(20); },
+            function ($book) { $book->title->toEqual('Bar')->cost->toEqual(30); },
+        );
+});
+
+class HasMethodsAndProperties
+{
+    public $name = 'Has Methods and Properties';
+
+    public $posts = [
+        [
+            'is_published' => true,
+            'title' => 'Foo'
+        ],
+        [
+            'is_published' => true,
+            'title' => 'Bar'
+        ]
+    ];
+
+    public function books()
+    {
+        return [
+            [
+                'title' => 'Foo',
+                'cost' => 20,
+            ],
+            [
+                'title' => 'Bar',
+                'cost' => 30,
+            ],
+        ];
+    }
+
+    public function multiply($x, $y)
+    {
+        return $x * $y;
+    }
+}