Add support for union types

src/Illuminate/Testing/Fluent/Concerns/Matching.php

@@ -4,6 +4,7 @@
 
 use Closure;
 use Illuminate\Contracts\Support\Arrayable;
+use Illuminate\Support\Arr;
 use Illuminate\Support\Collection;
 use PHPUnit\Framework\Assert as PHPUnit;
 
@@ -65,20 +66,24 @@ public function whereAll(array $bindings): self
     /**
      * Asserts that the property is of the expected type.
      *
-     * @param  string $key
-     * @param  string $expected
+     * @param  string       $key
+     * @param  string|array $expected
      * @return $this
      */
-    public function whereType(string $key, string $expected): self
+    public function whereType(string $key, $expected): self
     {
         $this->has($key);
 
         $actual = $this->prop($key);
 
-        PHPUnit::assertSame(
-            $expected,
+        if (! is_array($expected)) {
+            $expected = explode('|', $expected);
+        }
+
+        PHPUnit::assertContains(
             strtolower(gettype($actual)),
-            sprintf('Property [%s] is not of expected type [%s].', $this->dotPath($key), $expected)
+            $expected,
+            sprintf('Property [%s] is not of expected type [%s].', $this->dotPath($key), implode('|', $expected))
         );
 
         return $this;

tests/Testing/Fluent/AssertTest.php

@@ -783,6 +783,65 @@ public function testAssertWhereAllType()
         ]);
     }
 
+    public function testAssertWhereTypeWhenWrongTypeIsGiven()
+    {
+        $assert = AssertableJson::fromArray([
+            'foo' => 'bar',
+        ]);
+
+        $this->expectException(AssertionFailedError::class);
+        $this->expectExceptionMessage('Property [foo] is not of expected type [integer].');
+
+        $assert->whereType('foo', 'integer');
+    }
+
+    public function testAssertWhereTypeWithUnionTypes()
+    {
+        $firstAssert = AssertableJson::fromArray([
+            'foo' => 'bar',
+        ]);
+
+        $secondAssert = AssertableJson::fromArray([
+            'foo' => null,
+        ]);
+
+        $firstAssert->whereType('foo', ['string', 'null']);
+        $secondAssert->whereType('foo', ['string', 'null']);
+    }
+
+    public function testAssertWhereTypeWhenWrongUnionTypeIsGiven()
+    {
+        $assert = AssertableJson::fromArray([
+            'foo' => 123,
+        ]);
+
+        $this->expectException(AssertionFailedError::class);
+        $this->expectExceptionMessage('Property [foo] is not of expected type [string|null].');
+
+        $assert->whereType('foo', ['string', 'null']);
+    }
+
+    public function testAssertWhereTypeWithPipeInUnionType()
+    {
+        $assert = AssertableJson::fromArray([
+             'foo' => 'bar',
+        ]);
+
+        $assert->whereType('foo', 'string|null');
+    }
+
+    public function testAssertWhereTypeWithPipeInWrongUnionType()
+    {
+        $assert = AssertableJson::fromArray([
+            'foo' => 'bar',
+        ]);
+
+        $this->expectException(AssertionFailedError::class);
+        $this->expectExceptionMessage('Property [foo] is not of expected type [integer|null].');
+
+        $assert->whereType('foo', 'integer|null');
+    }
+
     public function testAssertHasAll()
     {
         $assert = AssertableJson::fromArray([