diff --git a/src/Concerns/Extendable.php b/src/Concerns/Extendable.php index 36c39243..ee87f9ab 100644 --- a/src/Concerns/Extendable.php +++ b/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 */ diff --git a/src/Concerns/RetrievesValues.php b/src/Concerns/RetrievesValues.php new file mode 100644 index 00000000..c38f5abd --- /dev/null +++ b/src/Concerns/RetrievesValues.php @@ -0,0 +1,29 @@ +|object $value + * @param mixed $default + * + * @return mixed + */ + private function retrieve(string $key, $value, $default = null) + { + if (is_array($value)) { + return $value[$key] ?? $default; + } + + // @phpstan-ignore-next-line + return $value->$key ?? $default; + } +} diff --git a/src/Expectation.php b/src/Expectation.php index e35acc5f..11d7c579 100644 --- a/src/Expectation.php +++ b/src/Expectation.php @@ -6,6 +6,7 @@ namespace Pest; use BadMethodCallException; use Pest\Concerns\Extendable; +use Pest\Concerns\RetrievesValues; use PHPUnit\Framework\Assert; use PHPUnit\Framework\Constraint\Constraint; use SebastianBergmann\Exporter\Exporter; @@ -18,7 +19,10 @@ use SebastianBergmann\Exporter\Exporter; */ final class Expectation { - use Extendable; + use Extendable { + __call as __extendsCall; + } + use RetrievesValues; /** * The expectation value. @@ -696,6 +700,24 @@ final class Expectation return $this->exporter->export($value); } + /** + * Dynamically handle calls to the class or + * creates a new higher order expectation. + * + * @param array $parameters + * + * @return 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. @@ -705,7 +727,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 */ diff --git a/src/HigherOrderExpectation.php b/src/HigherOrderExpectation.php index 90044d6a..d2710ecc 100644 --- a/src/HigherOrderExpectation.php +++ b/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|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 $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); } /** @@ -96,8 +70,9 @@ final class HigherOrderExpectation */ 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,11 +97,21 @@ 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. * @@ -134,13 +119,11 @@ final class HigherOrderExpectation */ 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; } diff --git a/tests/.snapshots/success.txt b/tests/.snapshots/success.txt index 9f57d4fa..e6496067 100644 --- a/tests/.snapshots/success.txt +++ b/tests/.snapshots/success.txt @@ -111,9 +111,11 @@ ✓ it works inside of each ✓ it works with sequence ✓ it can compose complex expectations + ✓ it can handle nested method calls PASS Tests\Features\Expect\HigherOrder\methodsAndProperties ✓ it can access methods and properties + ✓ it can handle nested methods and properties PASS Tests\Features\Expect\HigherOrder\properties ✓ it allows properties to be accessed from the value @@ -124,6 +126,7 @@ ✓ it works with sequence ✓ it can compose complex expectations ✓ it works with objects + ✓ it works with nested properties PASS Tests\Features\Expect\each ✓ an exception is thrown if the the type is not iterable @@ -554,5 +557,5 @@ ✓ it is a test ✓ it uses correct parent class - Tests: 4 incompleted, 7 skipped, 340 passed + Tests: 4 incompleted, 7 skipped, 343 passed \ No newline at end of file diff --git a/tests/Features/Expect/HigherOrder/methods.php b/tests/Features/Expect/HigherOrder/methods.php index 7f340f4a..66329b73 100644 --- a/tests/Features/Expect/HigherOrder/methods.php +++ b/tests/Features/Expect/HigherOrder/methods.php @@ -59,6 +59,14 @@ it('can compose complex expectations', function () { ); }); +it('can handle nested method calls', function () { + expect(new HasMethods()) + ->newInstance()->newInstance()->name()->toEqual('Has Methods')->toBeString() + ->newInstance()->name()->toEqual('Has Methods')->not->toBeInt + ->name()->toEqual('Has Methods') + ->books()->each->toBeArray(); +}); + class HasMethods { public function name() @@ -97,4 +105,9 @@ class HasMethods ], ]; } + + public function newInstance() + { + return new static(); + } } diff --git a/tests/Features/Expect/HigherOrder/methodsAndProperties.php b/tests/Features/Expect/HigherOrder/methodsAndProperties.php index 34ce09b4..f75f698a 100644 --- a/tests/Features/Expect/HigherOrder/methodsAndProperties.php +++ b/tests/Features/Expect/HigherOrder/methodsAndProperties.php @@ -14,10 +14,20 @@ it('can access methods and properties', function () { ); }); +it('can handle nested methods and properties', function () { + expect(new HasMethodsAndProperties()) + ->meta->foo->bar->toBeString()->toEqual('baz')->not->toBeInt + ->newInstance()->meta->foo->toBeArray() + ->newInstance()->multiply(2, 2)->toEqual(4)->not->toEqual(5) + ->newInstance()->books()->toBeArray(); +}); + class HasMethodsAndProperties { public $name = 'Has Methods and Properties'; + public $meta = ['foo' => ['bar' => 'baz']]; + public $posts = [ [ 'is_published' => true, @@ -47,4 +57,9 @@ class HasMethodsAndProperties { return $x * $y; } + + public function newInstance() + { + return new static(); + } } diff --git a/tests/Features/Expect/HigherOrder/properties.php b/tests/Features/Expect/HigherOrder/properties.php index c73e3d03..154d17e4 100644 --- a/tests/Features/Expect/HigherOrder/properties.php +++ b/tests/Features/Expect/HigherOrder/properties.php @@ -58,6 +58,12 @@ it('works with objects', function () { ); }); +it('works with nested properties', function () { + expect(new HasProperties()) + ->nested->foo->bar->toBeString()->toEqual('baz') + ->posts->toBeArray()->toHaveCount(2); +}); + class HasProperties { public $name = 'foo'; @@ -72,4 +78,8 @@ class HasProperties 'title' => 'Bar', ], ]; + + public $nested = [ + 'foo' => ['bar' => 'baz'], + ]; }