docs: update changelog

Forces higher order test callable expects to be closures

.github/FUNDING.yml

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

CHANGELOG.md

@@ -4,6 +4,33 @@ 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.9.1 (2021-07-11)](https://github.com/pestphp/pest/compare/v1.9.0...v1.9.1)
+### Fixed
+- Callable `expect` values in higher order tests failing if the value was an existing method name ([#334](https://github.com/pestphp/pest/pull/344)) 
+
+## [v1.9.0 (2021-07-09)](https://github.com/pestphp/pest/compare/v1.8.0...v1.9.0)
+### Changed
+- You may now pass just an exception message when using the `throws` method ([#339](https://github.com/pestphp/pest/pull/339)) 
+
+## [v1.8.0 (2021-07-08)](https://github.com/pestphp/pest/compare/v1.7.1...v1.8.0)
+### Added
+- A new `tap` and test case aware `expect` methods for higher order tests ([#331](https://github.com/pestphp/pest/pull/331))
+- Access to test case methods and properties when using `skip` ([#338](https://github.com/pestphp/pest/pull/338))
+
+## [v1.7.1 (2021-06-24)](https://github.com/pestphp/pest/compare/v1.7.0...v1.7.1)
+### Fixed
+- The `and` method not being usable in Higher Order expectations ([#330](https://github.com/pestphp/pest/pull/330))
+
+## [v1.7.0 (2021-06-19)](https://github.com/pestphp/pest/compare/v1.6.0...v1.7.0)
+### Added
+- Support for non-callable values in the sequence method, which will be passed as `toEqual` ([#323](https://github.com/pestphp/pest/pull/323))
+- Support for nested Higher Order Expectations ([#324](https://github.com/pestphp/pest/pull/324))
+
+## [v1.6.0 (2021-06-18)](https://github.com/pestphp/pest/compare/v1.5.0...v1.6.0)
+### Added
+- Adds a new `json` expectation method to improve testing with JSON strings ([#325](https://github.com/pestphp/pest/pull/325))
+- Adds dot notation support to the `toHaveKey` and `toHaveKeys` expectations ([#322](https://github.com/pestphp/pest/pull/322))
+
 ## [v1.5.0 (2021-06-15)](https://github.com/pestphp/pest/compare/v1.4.0...v1.5.0)
 ### Changed
 - Moves plugins from the `require` section to the core itself ([#317](https://github.com/pestphp/pest/pull/317)), ([#318](https://github.com/pestphp/pest/pull/318)), ([#320](https://github.com/pestphp/pest/pull/320))

composer.json

@@ -20,7 +20,7 @@
         "php": "^7.3 || ^8.0",
         "nunomaduro/collision": "^5.4.0",
         "pestphp/pest-plugin": "^1.0.0",
-        "phpunit/phpunit": ">= 9.3.7 <= 9.5.5"
+        "phpunit/phpunit": ">= 9.3.7 <= 9.5.6"
     },
     "autoload": {
         "psr-4": {

phpstan.neon

@@ -7,6 +7,7 @@ parameters:
     level: max
     paths:
         - src
+        - scripts
 
     checkMissingIterableValueType: true
     checkGenericClassInNonGenericObjectType: false

scripts/compile.php

@@ -15,6 +15,7 @@ $globalsFilePath = implode(DIRECTORY_SEPARATOR, [
 
 $compiledFilePath = implode(DIRECTORY_SEPARATOR, [dirname(__DIR__), 'compiled', 'globals.php']);
 
+/* @phpstan-ignore-next-line */
 @unlink($compiledFilePath);
 
 $replace = function ($contents, $string, $by) {

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,19 +6,27 @@ 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;
+use PHPUnit\Framework\ExpectationFailedException;
 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.
@@ -41,7 +49,7 @@ final class Expectation
     /**
      * Creates a new expectation.
      *
-     * @param mixed $value
+     * @param TValue $value
      */
     public function __construct($value)
     {
@@ -51,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.
      *
@@ -110,7 +128,7 @@ final class Expectation
 
         if (is_callable($callback)) {
             foreach ($this->value as $item) {
-                $callback(expect($item));
+                $callback(new self($item));
             }
         }
 
@@ -119,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.');
@@ -138,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;
@@ -522,10 +549,16 @@ final class Expectation
             $array = (array) $this->value;
         }
 
-        Assert::assertArrayHasKey($key, $array);
+        try {
+            Assert::assertTrue(Arr::has($array, $key));
+
+            /* @phpstan-ignore-next-line  */
+        } catch (ExpectationFailedException $exception) {
+            throw new ExpectationFailedException("Failed asserting that an array has the key '$key'", $exception->getComparisonFailure());
+        }
 
         if (func_num_args() > 1) {
-            Assert::assertEquals($value, $array[$key]);
+            Assert::assertEquals($value, Arr::get($array, $key));
         }
 
         return $this;
@@ -696,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.
@@ -705,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);
     }
 
     /**
@@ -89,15 +63,30 @@ final class HigherOrderExpectation
         return $this;
     }
 
+    /**
+     * Creates a new expectation.
+     *
+     * @template TValue
+     *
+     * @param TValue $value
+     *
+     * @return Expectation<TValue>
+     */
+    public function and($value): Expectation
+    {
+        return $this->expect($value);
+    }
+
     /**
      * 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 +101,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 +111,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/PendingObjects/TestCall.php

@@ -7,14 +7,15 @@ namespace Pest\PendingObjects;
 use Closure;
 use Pest\Factories\TestCaseFactory;
 use Pest\Support\Backtrace;
+use Pest\Support\HigherOrderCallables;
 use Pest\Support\NullClosure;
 use Pest\TestSuite;
 use SebastianBergmann\Exporter\Exporter;
 
 /**
- * @method \Pest\Expectations\Expectation expect(mixed $value)
- *
  * @internal
+ *
+ * @mixin HigherOrderCallables
  */
 final class TestCall
 {
@@ -58,11 +59,15 @@ final class TestCall
     /**
      * Asserts that the test throws the given `$exceptionClass` when called.
      */
-    public function throws(string $exceptionClass, string $exceptionMessage = null): TestCall
+    public function throws(string $exception, string $exceptionMessage = null): TestCall
     {
-        $this->testCaseFactory
-            ->proxies
-            ->add(Backtrace::file(), Backtrace::line(), 'expectException', [$exceptionClass]);
+        if (class_exists($exception)) {
+            $this->testCaseFactory
+                ->proxies
+                ->add(Backtrace::file(), Backtrace::line(), 'expectException', [$exception]);
+        } else {
+            $exceptionMessage = $exception;
+        }
 
         if (is_string($exceptionMessage)) {
             $this->testCaseFactory
@@ -143,11 +148,9 @@ final class TestCall
             ? $conditionOrMessage
             : $message;
 
-        if ($condition() !== false) {
-            $this->testCaseFactory
-                ->chains
-                ->add(Backtrace::file(), Backtrace::line(), 'markTestSkipped', [$message]);
-        }
+        $this->testCaseFactory
+            ->chains
+            ->addWhen($condition, Backtrace::file(), Backtrace::line(), 'markTestSkipped', [$message]);
 
         return $this;
     }

src/Pest.php

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

src/Plugins/Coverage.php

@@ -81,7 +81,6 @@ final class Coverage implements AddsOutput, HandlesArguments
         }
 
         if ($input->getOption(self::MIN_OPTION) !== null) {
-            /* @phpstan-ignore-next-line */
             $this->coverageMin = (float) $input->getOption(self::MIN_OPTION);
         }
 

src/Support/Arr.php

@@ -0,0 +1,68 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Pest\Support;
+
+/**
+ * Credits: most of this class methods and implementations
+ * belongs to the Arr helper of laravel/framework project
+ * (https://github.com/laravel/framework).
+ *
+ * @internal
+ */
+final class Arr
+{
+    /**
+     * @param array<mixed> $array
+     * @param string|int   $key
+     */
+    public static function has(array $array, $key): bool
+    {
+        $key = (string) $key;
+
+        if (array_key_exists($key, $array)) {
+            return true;
+        }
+
+        foreach (explode('.', $key) as $segment) {
+            if (is_array($array) && array_key_exists($segment, $array)) {
+                $array = $array[$segment];
+            } else {
+                return false;
+            }
+        }
+
+        return true;
+    }
+
+    /**
+     * @param array<mixed> $array
+     * @param string|int   $key
+     * @param null         $default
+     *
+     * @return array|mixed|null
+     */
+    public static function get(array $array, $key, $default = null)
+    {
+        $key = (string) $key;
+
+        if (array_key_exists($key, $array)) {
+            return $array[$key];
+        }
+
+        if (strpos($key, '.') === false) {
+            return $array[$key] ?? $default;
+        }
+
+        foreach (explode('.', $key) as $segment) {
+            if (is_array($array) && array_key_exists($segment, $array)) {
+                $array = $array[$segment];
+            } else {
+                return $default;
+            }
+        }
+
+        return $array;
+    }
+}

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::bindCallable($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::bindCallable($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;
 
@@ -50,6 +51,13 @@ final class HigherOrderMessage
      */
     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.
      *
@@ -70,6 +78,16 @@ 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->methodName}(...$this->arguments);
+        }
+
         try {
             return Reflection::call($target, $this->methodName, $this->arguments);
         } catch (Throwable $throwable) {
@@ -88,6 +106,28 @@ final class HigherOrderMessage
         }
     }
 
+    /**
+     * 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->methodName, get_class_methods(HigherOrderCallables::class), true);
+    }
+
     private static function getUndefinedMethodMessage(object $target, string $methodName): string
     {
         if (\PHP_MAJOR_VERSION >= 8) {

src/Support/HigherOrderMessageCollection.php

@@ -24,6 +24,16 @@ final class HigherOrderMessageCollection
         $this->messages[] = new HigherOrderMessage($filename, $line, $methodName, $arguments);
     }
 
+    /**
+     * Adds a new higher order message to the collection if the callable condition is does not return false.
+     *
+     * @param array<int, mixed> $arguments
+     */
+    public function addWhen(callable $condition, string $filename, int $line, string $methodName, array $arguments): void
+    {
+        $this->messages[] = (new HigherOrderMessage($filename, $line, $methodName, $arguments))->when($condition);
+    }
+
     /**
      * Proxy all the messages starting from the target.
      */

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

@@ -41,15 +41,25 @@ 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);
+    }
+
     /**
      * Infers the file name from the given closure.
      */

tests/.snapshots/success.txt

@@ -111,9 +111,12 @@
   ✓ 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
+  ✓ it can start a new higher order expectation using the and syntax
 
    PASS  Tests\Features\Expect\HigherOrder\properties
   ✓ it allows properties to be accessed from the value
@@ -124,6 +127,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
@@ -140,6 +144,10 @@
   ✓ it macros true is true with argument
   ✓ it macros false is not true with argument
 
+   PASS  Tests\Features\Expect\json
+  ✓ it properly parses json string
+  ✓ fails with broken json string
+
    PASS  Tests\Features\Expect\not
   ✓ not property calls
 
@@ -152,6 +160,8 @@
   ✓ loops back to the start if it runs out of sequence items
   ✓ it works if the number of items in the iterable is smaller than the number of expectations
   ✓ it works with associative arrays
+  ✓ it can be passed non-callable values
+  ✓ it can be passed a mixture of value types
 
    PASS  Tests\Features\Expect\toBe
   ✓ strict comparisons
@@ -336,8 +346,23 @@
 
    PASS  Tests\Features\Expect\toHaveKey
   ✓ pass
+  ✓ pass with nested key
+  ✓ pass with plain key with dots
+  ✓ pass with value check
+  ✓ pass with value check and nested key
+  ✓ pass with value check and plain key with dots
   ✓ failures
+  ✓ failures with nested key
+  ✓ failures with plain key with dots
+  ✓ fails with wrong value
+  ✓ fails with wrong value and nested key
+  ✓ fails with wrong value and plain key with dots
   ✓ not failures
+  ✓ not failures with nested key
+  ✓ not failures with plain key with dots
+  ✓ not failures with correct value
+  ✓ not failures with correct value and  with nested key
+  ✓ not failures with correct value and  with plain key with dots
 
    PASS  Tests\Features\Expect\toHaveKeys
   ✓ pass
@@ -385,6 +410,8 @@
    PASS  Tests\Features\HigherOrderTests
   ✓ it proxies calls to object
   ✓ it is capable doing multiple assertions
+  ✓ it resolves expect callables correctly
+  ✓ it can tap into the test
 
    WARN  Tests\Features\Incompleted
   … incompleted
@@ -554,5 +581,5 @@
   ✓ it is a test
   ✓ it uses correct parent class
 
-  Tests:  4 incompleted, 7 skipped, 340 passed
+  Tests:  4 incompleted, 7 skipped, 365 passed
   

tests/Features/Exceptions.php

@@ -13,3 +13,7 @@ it('catch exceptions', function () {
 it('catch exceptions and messages', function () {
     throw new Exception('Something bad happened');
 })->throws(Exception::class, 'Something bad happened');
+
+it('can just define the message', function () {
+    throw new Exception('Something bad happened');
+})->throws('Something bad happened');

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();
+    }
 }

tests/Features/Expect/HigherOrder/methodsAndProperties.php

@@ -14,10 +14,31 @@ 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();
+});
+
+it('can start a new higher order expectation using the and syntax', function () {
+    expect(new HasMethodsAndProperties())
+        ->toBeInstanceOf(HasMethodsAndProperties::class)
+        ->meta->toBeArray
+        ->and(['foo' => 'bar'])
+        ->toBeArray()
+        ->foo->toEqual('bar');
+
+    expect(static::getCount())->toEqual(4);
+});
+
 class HasMethodsAndProperties
 {
     public $name = 'Has Methods and Properties';
 
+    public $meta = ['foo' => ['bar' => 'baz']];
+
     public $posts = [
         [
             'is_published' => true,
@@ -47,4 +68,9 @@ class HasMethodsAndProperties
     {
         return $x * $y;
     }
+
+    public function newInstance()
+    {
+        return new static();
+    }
 }

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'],
+    ];
 }

tests/Features/Expect/json.php

@@ -0,0 +1,14 @@
+<?php
+
+use PHPUnit\Framework\ExpectationFailedException;
+
+test('it properly parses json string', function () {
+    expect('{"name":"Nuno"}')
+        ->json()
+        ->name
+        ->toBe('Nuno');
+});
+
+test('fails with broken json string', function () {
+    expect('{":"Nuno"}')->json();
+})->throws(ExpectationFailedException::class);

tests/Features/Expect/sequence.php

@@ -44,3 +44,19 @@ test('it works with associative arrays', function () {
             function ($expectation, $key) { $expectation->toEqual('boom'); $key->toEqual('baz'); },
         );
 });
+
+test('it can be passed non-callable values', function () {
+    expect(['foo', 'bar', 'baz'])->sequence('foo', 'bar', 'baz');
+
+    expect(static::getCount())->toBe(3);
+});
+
+test('it can be passed a mixture of value types', function () {
+    expect(['foo', 'bar', 'baz'])->sequence(
+        'foo',
+        function ($expectation) { $expectation->toEqual('bar')->toBeString(); },
+        'baz'
+    );
+
+    expect(static::getCount())->toBe(4);
+});

tests/Features/Expect/toHaveKey.php

@@ -2,14 +2,68 @@
 
 use PHPUnit\Framework\ExpectationFailedException;
 
-test('pass', function () {
-    expect(['a' => 1, 'b', 'c' => 'world'])->toHaveKey('c');
-});
+$test_array = [
+    'a'             => 1,
+    'b',
+    'c'             => 'world',
+    'd'             => [
+        'e' => 'hello',
+    ],
+    'key.with.dots' => false,
+];
 
-test('failures', function () {
-    expect(['a' => 1, 'b', 'c' => 'world'])->toHaveKey('hello');
+test('pass')->expect($test_array)->toHaveKey('c');
+test('pass with nested key')->expect($test_array)->toHaveKey('d.e');
+test('pass with plain key with dots')->expect($test_array)->toHaveKey('key.with.dots');
+
+test('pass with value check')->expect($test_array)->toHaveKey('c', 'world');
+test('pass with value check and nested key')->expect($test_array)->toHaveKey('d.e', 'hello');
+test('pass with value check and plain key with dots')->expect($test_array)->toHaveKey('key.with.dots', false);
+
+test('failures', function () use ($test_array) {
+    expect($test_array)->toHaveKey('foo');
+})->throws(ExpectationFailedException::class, "Failed asserting that an array has the key 'foo'");
+
+test('failures with nested key', function () use ($test_array) {
+    expect($test_array)->toHaveKey('d.bar');
+})->throws(ExpectationFailedException::class, "Failed asserting that an array has the key 'd.bar'");
+
+test('failures with plain key with dots', function () use ($test_array) {
+    expect($test_array)->toHaveKey('missing.key.with.dots');
+})->throws(ExpectationFailedException::class, "Failed asserting that an array has the key 'missing.key.with.dots'");
+
+test('fails with wrong value', function () use ($test_array) {
+    expect($test_array)->toHaveKey('c', 'bar');
 })->throws(ExpectationFailedException::class);
 
-test('not failures', function () {
-    expect(['a' => 1, 'hello' => 'world', 'c'])->not->toHaveKey('hello');
+test('fails with wrong value and nested key', function () use ($test_array) {
+    expect($test_array)->toHaveKey('d.e', 'foo');
+})->throws(ExpectationFailedException::class);
+
+test('fails with wrong value and plain key with dots', function () use ($test_array) {
+    expect($test_array)->toHaveKey('key.with.dots', true);
+})->throws(ExpectationFailedException::class);
+
+test('not failures', function () use ($test_array) {
+    expect($test_array)->not->toHaveKey('c');
+})->throws(ExpectationFailedException::class, "Expecting Array (...) not to have key 'c'");
+
+test('not failures with nested key', function () use ($test_array) {
+    expect($test_array)->not->toHaveKey('d.e');
+})->throws(ExpectationFailedException::class, "Expecting Array (...) not to have key 'd.e'");
+
+test('not failures with plain key with dots', function () use ($test_array) {
+    expect($test_array)->not->toHaveKey('key.with.dots');
+})->throws(ExpectationFailedException::class, "Expecting Array (...) not to have key 'key.with.dots'");
+
+test('not failures with correct value', function () use ($test_array) {
+    expect($test_array)->not->toHaveKey('c', 'world');
+})->throws(ExpectationFailedException::class);
+
+test('not failures with correct value and  with nested key', function () use ($test_array) {
+    expect($test_array)->not->toHaveKey('d.e', 'hello');
+})->throws(ExpectationFailedException::class);
+
+test('not failures with correct value and  with plain key with dots', function () use ($test_array) {
+    expect($test_array)->not->toHaveKey('key.with.dots', false);
 })->throws(ExpectationFailedException::class);

tests/Features/Expect/toHaveKeys.php

@@ -3,13 +3,13 @@
 use PHPUnit\Framework\ExpectationFailedException;
 
 test('pass', function () {
-    expect(['a' => 1, 'b', 'c' => 'world'])->toHaveKeys(['a', 'c']);
+    expect(['a' => 1, 'b', 'c' => 'world', 'foo' => ['bar' => 'baz']])->toHaveKeys(['a', 'c', 'foo.bar']);
 });
 
 test('failures', function () {
-    expect(['a' => 1, 'b', 'c' => 'world'])->toHaveKeys(['a', 'd']);
+    expect(['a' => 1, 'b', 'c' => 'world', 'foo' => ['bar' => 'baz']])->toHaveKeys(['a', 'd', 'foo.bar', 'hello.world']);
 })->throws(ExpectationFailedException::class);
 
 test('not failures', function () {
-    expect(['a' => 1, 'hello' => 'world', 'c'])->not->toHaveKeys(['hello', 'c']);
+    expect(['a' => 1, 'b', 'c' => 'world', 'foo' => ['bar' => 'baz']])->not->toHaveKeys(['foo.bar', 'c', 'z']);
 })->throws(ExpectationFailedException::class);

tests/Features/HigherOrderTests.php

@@ -1,5 +1,7 @@
 <?php
 
+use PHPUnit\Framework\TestCase;
+
 beforeEach()->assertTrue(true);
 
 it('proxies calls to object')->assertTrue(true);
@@ -8,4 +10,21 @@ it('is capable doing multiple assertions')
     ->assertTrue(true)
     ->assertFalse(false);
 
+it('resolves expect callables correctly')
+    ->expect(function () { return 'foo'; })
+    ->toBeString()
+    ->toBe('foo')
+    ->and('bar')
+    ->toBeString()
+    ->toBe('bar');
+
+test('does not treat method names as callables')
+    ->expect('it')->toBeString();
+
+it('can tap into the test')
+    ->expect('foo')->toBeString()
+    ->tap(function () { expect($this)->toBeInstanceOf(TestCase::class); })
+    ->toBe('foo')
+    ->and('hello world')->toBeString();
+
 afterEach()->assertTrue(true);

tests/Features/Skip.php

@@ -1,5 +1,9 @@
 <?php
 
+beforeEach(function () {
+    $this->shouldSkip = true;
+});
+
 it('do not skips')
     ->skip(false)
     ->assertTrue(true);
@@ -31,3 +35,12 @@ it('skips with condition and message')
 it('skips when skip after assertion')
     ->assertTrue(true)
     ->skip();
+
+it('can use something in the test case as a condition')
+    ->skip(function () { return $this->shouldSkip; }, 'This test was skipped')
+    ->assertTrue(false);
+
+it('can user higher order callables and skip')
+    ->skip(function () { return $this->shouldSkip; })
+    ->expect(function () { return $this->shouldSkip; })
+    ->toBeFalse();