Adds an every call that can be chained in expectations for traversable

src/Every.php

@@ -0,0 +1,53 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Pest\Expectations;
+
+use BadMethodCallException;
+
+/**
+ * @internal
+ *
+ * @mixin Expectation
+ */
+class Every
+{
+
+    /**
+     * @var Expectation
+     */
+    private $original;
+
+    /**
+     * Creates a new iterable expectation.
+     */
+    public function __construct(Expectation $original)
+    {
+        $this->original = $original;
+
+        if (!is_iterable($this->original->value)) {
+            throw new BadMethodCallException("The `every` call only support iterable types.");
+        }
+    }
+
+    public function and($value)
+    {
+        return new Expectation($value);
+    }
+
+    public function not()
+    {
+        return $this->original->not();
+    }
+
+    public function __call(string $name, array $arguments)
+    {
+        foreach ($this->original->value as $item) {
+            (new Expectation($item))->$name(...$arguments);
+        }
+
+        return $this;
+    }
+
+}

src/Expectation.php

@@ -64,6 +64,14 @@ public function not(): OppositeExpectation
         return new OppositeExpectation($this);
     }
 
+    /**
+     * Allows for expectations to be run over Iterables.
+     */
+    public function every()
+    {
+        return new Every($this);
+    }
+
     /**
      * Asserts that two variables have the same type and
      * value. Used on objects, it asserts that two

tests/Expect/every.php

@@ -0,0 +1,46 @@
+<?php
+
+test('an exception is thrown if the the type is not iterable', function() {
+    $this->expectException(BadMethodCallException::class);
+
+    expect('Foobar')
+        ->every()
+        ->toEqual('Foobar');
+});
+
+test('it maps over each iterable', function () {
+    expect([1, 1, 1])
+        ->every()
+        ->toEqual(1);
+});
+
+test('it accepts chained expectations', function() {
+    expect([1, 1, 1])
+        ->every()
+        ->toBeInt()
+        ->toEqual(1);
+});
+
+test('it works with the not operator', function() {
+    expect([1, 2, 3])
+        ->every()
+        ->not()->toEqual(4);
+});
+
+test('it works with the and operator', function() {
+    expect([1, 2, 3])
+        ->every()
+        ->not()->toEqual(4)
+        ->and([4, 5, 6])
+        ->every()
+        ->toBeLessThan(7)
+        ->toBeGreaterThan(3)
+        ->and('Hello World')
+        ->toBeString()
+        ->toEqual('Hello World');
+});
+
+test('it can be called as a higher order function', function () {
+    expect([1, 1, 1])
+        ->every->toEqual(1);
+});