diff --git a/src/Illuminate/Collections/helpers.php b/src/Illuminate/Collections/helpers.php
index 6ae6dfe68a9b..67669e5ce1c6 100644
--- a/src/Illuminate/Collections/helpers.php
+++ b/src/Illuminate/Collections/helpers.php
@@ -179,8 +179,8 @@ function last($array)
      * @param  mixed  $value
      * @return mixed
      */
-    function value($value)
+    function value($value, ...$args)
     {
-        return $value instanceof Closure ? $value() : $value;
+        return $value instanceof Closure ? $value(...$args) : $value;
     }
 }
diff --git a/src/Illuminate/Database/Console/Seeds/SeedCommand.php b/src/Illuminate/Database/Console/Seeds/SeedCommand.php
index ccca6fd5eeda..058e545c234f 100644
--- a/src/Illuminate/Database/Console/Seeds/SeedCommand.php
+++ b/src/Illuminate/Database/Console/Seeds/SeedCommand.php
@@ -6,6 +6,7 @@
 use Illuminate\Console\ConfirmableTrait;
 use Illuminate\Database\ConnectionResolverInterface as Resolver;
 use Illuminate\Database\Eloquent\Model;
+use Symfony\Component\Console\Input\InputArgument;
 use Symfony\Component\Console\Input\InputOption;
 
 class SeedCommand extends Command
@@ -81,7 +82,7 @@ public function handle()
      */
     protected function getSeeder()
     {
-        $class = $this->input->getOption('class');
+        $class = $this->input->getArgument('class') ?? $this->input->getOption('class');
 
         if (strpos($class, '\\') === false) {
             $class = 'Database\\Seeders\\'.$class;
@@ -109,6 +110,18 @@ protected function getDatabase()
         return $database ?: $this->laravel['config']['database.default'];
     }
 
+    /**
+     * Get the console command arguments.
+     *
+     * @return array
+     */
+    protected function getArguments()
+    {
+        return [
+            ['class', InputArgument::OPTIONAL, 'The class name of the root seeder', null],
+        ];
+    }
+
     /**
      * Get the console command options.
      *
diff --git a/src/Illuminate/Foundation/Support/Providers/EventServiceProvider.php b/src/Illuminate/Foundation/Support/Providers/EventServiceProvider.php
index 0573563cf5ac..70ea3086efe9 100644
--- a/src/Illuminate/Foundation/Support/Providers/EventServiceProvider.php
+++ b/src/Illuminate/Foundation/Support/Providers/EventServiceProvider.php
@@ -119,7 +119,7 @@ public function discoverEvents()
                     ->reduce(function ($discovered, $directory) {
                         return array_merge_recursive(
                             $discovered,
-                            DiscoverEvents::within($directory, base_path())
+                            DiscoverEvents::within($directory, $this->eventDiscoveryBasePath())
                         );
                     }, []);
     }
@@ -135,4 +135,14 @@ protected function discoverEventsWithin()
             $this->app->path('Listeners'),
         ];
     }
+
+    /**
+     * Get the base path to be used during event discovery.
+     *
+     * @return string
+     */
+    protected function eventDiscoveryBasePath()
+    {
+        return base_path();
+    }
 }
diff --git a/src/Illuminate/Queue/Console/WorkCommand.php b/src/Illuminate/Queue/Console/WorkCommand.php
index ff092197f53a..da9176be4063 100644
--- a/src/Illuminate/Queue/Console/WorkCommand.php
+++ b/src/Illuminate/Queue/Console/WorkCommand.php
@@ -33,6 +33,7 @@ class WorkCommand extends Command
                             {--force : Force the worker to run even in maintenance mode}
                             {--memory=128 : The memory limit in megabytes}
                             {--sleep=3 : Number of seconds to sleep when no job is available}
+                            {--rest=0 : Number of seconds to rest between jobs}
                             {--timeout=60 : The number of seconds a child process can run}
                             {--tries=1 : Number of times to attempt a job before logging it failed}';
 
@@ -134,7 +135,8 @@ protected function gatherWorkerOptions()
             $this->option('force'),
             $this->option('stop-when-empty'),
             $this->option('max-jobs'),
-            $this->option('max-time')
+            $this->option('max-time'),
+            $this->option('rest')
         );
     }
 
diff --git a/src/Illuminate/Queue/Middleware/ThrottlesExceptions.php b/src/Illuminate/Queue/Middleware/ThrottlesExceptions.php
index edb3dd164d33..3fff4e914b55 100644
--- a/src/Illuminate/Queue/Middleware/ThrottlesExceptions.php
+++ b/src/Illuminate/Queue/Middleware/ThrottlesExceptions.php
@@ -8,6 +8,13 @@
 
 class ThrottlesExceptions
 {
+    /**
+     * The developer specified key that the rate limiter should use.
+     *
+     * @var string
+     */
+    protected $key;
+
     /**
      * The maximum number of attempts allowed before rate limiting applies.
      *
@@ -27,14 +34,7 @@ class ThrottlesExceptions
      *
      * @var int
      */
-    protected $retryAfterMinutes;
-
-    /**
-     * The rate limiter key.
-     *
-     * @var string
-     */
-    protected $key;
+    protected $retryAfterMinutes = 0;
 
     /**
      * The callback that determines if rate limiting should apply.
@@ -48,7 +48,7 @@ class ThrottlesExceptions
      *
      * @var string
      */
-    protected $prefix = 'circuit_breaker:';
+    protected $prefix = 'laravel_throttles_exceptions:';
 
     /**
      * The rate limiter instance.
@@ -62,15 +62,13 @@ class ThrottlesExceptions
      *
      * @param  int  $maxAttempts
      * @param  int  $decayMinutes
-     * @param  int  $retryAfterMinutes
      * @param  string  $key
+     * @return void
      */
-    public function __construct($maxAttempts = 10, $decayMinutes = 10, $retryAfterMinutes = 0, string $key = '')
+    public function __construct($maxAttempts = 10, $decayMinutes = 10)
     {
         $this->maxAttempts = $maxAttempts;
         $this->decayMinutes = $decayMinutes;
-        $this->retryAfterMinutes = $retryAfterMinutes;
-        $this->key = $key;
     }
 
     /**
@@ -129,6 +127,19 @@ public function withPrefix(string $prefix)
         return $this;
     }
 
+    /**
+     * Specify the number of seconds a job should be delayed when it is released (before it has reached its max exceptions).
+     *
+     * @param  int  $backoff
+     * @return $this
+     */
+    public function backoff($backoff)
+    {
+        $this->retryAfterMinutes = $backoff;
+
+        return $this;
+    }
+
     /**
      * Get the cache key associated for the rate limiter.
      *
@@ -137,7 +148,20 @@ public function withPrefix(string $prefix)
      */
     protected function getKey($job)
     {
-        return $this->prefix.md5(empty($this->key) ? get_class($job) : $this->key);
+        return $this->key ? $this->prefix.$this->key : $this->prefix.$job->job->uuid();
+    }
+
+    /**
+     * Set the value that the rate limiter should be keyed by.
+     *
+     * @param  string  $key
+     * @return $this
+     */
+    public function by($key)
+    {
+        $this->key = $key;
+
+        return $this;
     }
 
     /**
diff --git a/src/Illuminate/Queue/Worker.php b/src/Illuminate/Queue/Worker.php
index f2ba7b1a01ad..4229fe701691 100644
--- a/src/Illuminate/Queue/Worker.php
+++ b/src/Illuminate/Queue/Worker.php
@@ -156,6 +156,10 @@ public function daemon($connectionName, $queue, WorkerOptions $options)
                 $jobsProcessed++;
 
                 $this->runJob($job, $connectionName, $options);
+
+                if ($options->rest > 0) {
+                    $this->sleep($options->rest);
+                }
             } else {
                 $this->sleep($options->sleep);
             }
diff --git a/src/Illuminate/Queue/WorkerOptions.php b/src/Illuminate/Queue/WorkerOptions.php
index 766f4676029a..7b8d8dfeea3b 100644
--- a/src/Illuminate/Queue/WorkerOptions.php
+++ b/src/Illuminate/Queue/WorkerOptions.php
@@ -39,6 +39,13 @@ class WorkerOptions
      */
     public $sleep;
 
+    /**
+     * The number of seconds to rest between jobs.
+     *
+     * @var int
+     */
+    public $rest;
+
     /**
      * The maximum amount of times a job may be attempted.
      *
@@ -87,14 +94,16 @@ class WorkerOptions
      * @param  bool  $stopWhenEmpty
      * @param  int  $maxJobs
      * @param  int  $maxTime
+     * @param  int  $rest
      * @return void
      */
     public function __construct($name = 'default', $backoff = 0, $memory = 128, $timeout = 60, $sleep = 3, $maxTries = 1,
-                                $force = false, $stopWhenEmpty = false, $maxJobs = 0, $maxTime = 0)
+                                $force = false, $stopWhenEmpty = false, $maxJobs = 0, $maxTime = 0, $rest = 0)
     {
         $this->name = $name;
         $this->backoff = $backoff;
         $this->sleep = $sleep;
+        $this->rest = $rest;
         $this->force = $force;
         $this->memory = $memory;
         $this->timeout = $timeout;
diff --git a/src/Illuminate/Testing/Fluent/AssertableJson.php b/src/Illuminate/Testing/Fluent/AssertableJson.php
new file mode 100644
index 000000000000..07104e114990
--- /dev/null
+++ b/src/Illuminate/Testing/Fluent/AssertableJson.php
@@ -0,0 +1,127 @@
+<?php
+
+namespace Illuminate\Testing\Fluent;
+
+use Closure;
+use Illuminate\Contracts\Support\Arrayable;
+use Illuminate\Support\Arr;
+use Illuminate\Support\Traits\Macroable;
+use Illuminate\Support\Traits\Tappable;
+use Illuminate\Testing\AssertableJsonString;
+use PHPUnit\Framework\Assert as PHPUnit;
+
+class AssertableJson implements Arrayable
+{
+    use Concerns\Has,
+        Concerns\Matching,
+        Concerns\Debugging,
+        Concerns\Interaction,
+        Macroable,
+        Tappable;
+
+    /**
+     * The properties in the current scope.
+     *
+     * @var array
+     */
+    private $props;
+
+    /**
+     * The "dot" path to the current scope.
+     *
+     * @var string|null
+     */
+    private $path;
+
+    /**
+     * Create a new fluent, assertable JSON data instance.
+     *
+     * @param  array  $props
+     * @param  string|null  $path
+     * @return void
+     */
+    protected function __construct(array $props, string $path = null)
+    {
+        $this->path = $path;
+        $this->props = $props;
+    }
+
+    /**
+     * Compose the absolute "dot" path to the given key.
+     *
+     * @param  string  $key
+     * @return string
+     */
+    protected function dotPath(string $key): string
+    {
+        if (is_null($this->path)) {
+            return $key;
+        }
+
+        return implode('.', [$this->path, $key]);
+    }
+
+    /**
+     * Retrieve a prop within the current scope using "dot" notation.
+     *
+     * @param  string|null  $key
+     * @return mixed
+     */
+    protected function prop(string $key = null)
+    {
+        return Arr::get($this->props, $key);
+    }
+
+    /**
+     * Instantiate a new "scope" at the path of the given key.
+     *
+     * @param  string  $key
+     * @param  \Closure  $callback
+     * @return $this
+     */
+    protected function scope(string $key, Closure $callback): self
+    {
+        $props = $this->prop($key);
+        $path = $this->dotPath($key);
+
+        PHPUnit::assertIsArray($props, sprintf('Property [%s] is not scopeable.', $path));
+
+        $scope = new self($props, $path);
+        $callback($scope);
+        $scope->interacted();
+
+        return $this;
+    }
+
+    /**
+     * Create a new instance from an array.
+     *
+     * @param  array  $data
+     * @return static
+     */
+    public static function fromArray(array $data): self
+    {
+        return new self($data);
+    }
+
+    /**
+     * Create a new instance from a AssertableJsonString.
+     *
+     * @param  \Illuminate\Testing\AssertableJsonString  $json
+     * @return static
+     */
+    public static function fromAssertableJsonString(AssertableJsonString $json): self
+    {
+        return self::fromArray($json->json());
+    }
+
+    /**
+     * Get the instance as an array.
+     *
+     * @return array
+     */
+    public function toArray()
+    {
+        return $this->props;
+    }
+}
diff --git a/src/Illuminate/Testing/Fluent/Concerns/Debugging.php b/src/Illuminate/Testing/Fluent/Concerns/Debugging.php
new file mode 100644
index 000000000000..f51d119074ae
--- /dev/null
+++ b/src/Illuminate/Testing/Fluent/Concerns/Debugging.php
@@ -0,0 +1,38 @@
+<?php
+
+namespace Illuminate\Testing\Fluent\Concerns;
+
+trait Debugging
+{
+    /**
+     * Dumps the given props.
+     *
+     * @param  string|null  $prop
+     * @return $this
+     */
+    public function dump(string $prop = null): self
+    {
+        dump($this->prop($prop));
+
+        return $this;
+    }
+
+    /**
+     * Dumps the given props and exits.
+     *
+     * @param  string|null  $prop
+     * @return void
+     */
+    public function dd(string $prop = null): void
+    {
+        dd($this->prop($prop));
+    }
+
+    /**
+     * Retrieve a prop within the current scope using "dot" notation.
+     *
+     * @param  string|null  $key
+     * @return mixed
+     */
+    abstract protected function prop(string $key = null);
+}
diff --git a/src/Illuminate/Testing/Fluent/Concerns/Has.php b/src/Illuminate/Testing/Fluent/Concerns/Has.php
new file mode 100644
index 000000000000..dd91ee618790
--- /dev/null
+++ b/src/Illuminate/Testing/Fluent/Concerns/Has.php
@@ -0,0 +1,158 @@
+<?php
+
+namespace Illuminate\Testing\Fluent\Concerns;
+
+use Closure;
+use Illuminate\Support\Arr;
+use PHPUnit\Framework\Assert as PHPUnit;
+
+trait Has
+{
+    /**
+     * Assert that the prop is of the expected size.
+     *
+     * @param  string  $key
+     * @param  int  $length
+     * @return $this
+     */
+    protected function count(string $key, int $length): self
+    {
+        PHPUnit::assertCount(
+            $length,
+            $this->prop($key),
+            sprintf('Property [%s] does not have the expected size.', $this->dotPath($key))
+        );
+
+        return $this;
+    }
+
+    /**
+     * Ensure that the given prop exists.
+     *
+     * @param  string  $key
+     * @param  null  $value
+     * @param  \Closure|null  $scope
+     * @return $this
+     */
+    public function has(string $key, $value = null, Closure $scope = null): self
+    {
+        $prop = $this->prop();
+
+        PHPUnit::assertTrue(
+            Arr::has($prop, $key),
+            sprintf('Property [%s] does not exist.', $this->dotPath($key))
+        );
+
+        $this->interactsWith($key);
+
+        // When all three arguments are provided this indicates a short-hand expression
+        // that combines both a `count`-assertion, followed by directly creating the
+        // `scope` on the first element. We can simply handle this correctly here.
+        if (is_int($value) && ! is_null($scope)) {
+            $prop = $this->prop($key);
+            $path = $this->dotPath($key);
+
+            PHPUnit::assertTrue($value > 0, sprintf('Cannot scope directly onto the first entry of property [%s] when asserting that it has a size of 0.', $path));
+            PHPUnit::assertIsArray($prop, sprintf('Direct scoping is unsupported for non-array like properties such as [%s].', $path));
+
+            $this->count($key, $value);
+
+            return $this->scope($key.'.'.array_keys($prop)[0], $scope);
+        }
+
+        if (is_callable($value)) {
+            $this->scope($key, $value);
+        } elseif (! is_null($value)) {
+            $this->count($key, $value);
+        }
+
+        return $this;
+    }
+
+    /**
+     * Assert that all of the given props exist.
+     *
+     * @param  array|string $key
+     * @return $this
+     */
+    public function hasAll($key): self
+    {
+        $keys = is_array($key) ? $key : func_get_args();
+
+        foreach ($keys as $prop => $count) {
+            if (is_int($prop)) {
+                $this->has($count);
+            } else {
+                $this->has($prop, $count);
+            }
+        }
+
+        return $this;
+    }
+
+    /**
+     * Assert that none of the given props exist.
+     *
+     * @param  array|string $key
+     * @return $this
+     */
+    public function missingAll($key): self
+    {
+        $keys = is_array($key) ? $key : func_get_args();
+
+        foreach ($keys as $prop) {
+            $this->missing($prop);
+        }
+
+        return $this;
+    }
+
+    /**
+     * Assert that the given prop does not exist.
+     *
+     * @param  string  $key
+     * @return $this
+     */
+    public function missing(string $key): self
+    {
+        PHPUnit::assertNotTrue(
+            Arr::has($this->prop(), $key),
+            sprintf('Property [%s] was found while it was expected to be missing.', $this->dotPath($key))
+        );
+
+        return $this;
+    }
+
+    /**
+     * Compose the absolute "dot" path to the given key.
+     *
+     * @param  string  $key
+     * @return string
+     */
+    abstract protected function dotPath(string $key): string;
+
+    /**
+     * Marks the property as interacted.
+     *
+     * @param  string  $key
+     * @return void
+     */
+    abstract protected function interactsWith(string $key): void;
+
+    /**
+     * Retrieve a prop within the current scope using "dot" notation.
+     *
+     * @param  string|null  $key
+     * @return mixed
+     */
+    abstract protected function prop(string $key = null);
+
+    /**
+     * Instantiate a new "scope" at the path of the given key.
+     *
+     * @param  string  $key
+     * @param  \Closure  $callback
+     * @return $this
+     */
+    abstract protected function scope(string $key, Closure $callback);
+}
diff --git a/src/Illuminate/Testing/Fluent/Concerns/Interaction.php b/src/Illuminate/Testing/Fluent/Concerns/Interaction.php
new file mode 100644
index 000000000000..15e7e9508f55
--- /dev/null
+++ b/src/Illuminate/Testing/Fluent/Concerns/Interaction.php
@@ -0,0 +1,67 @@
+<?php
+
+namespace Illuminate\Testing\Fluent\Concerns;
+
+use Illuminate\Support\Str;
+use PHPUnit\Framework\Assert as PHPUnit;
+
+trait Interaction
+{
+    /**
+     * The list of interacted properties.
+     *
+     * @var array
+     */
+    protected $interacted = [];
+
+    /**
+     * Marks the property as interacted.
+     *
+     * @param  string  $key
+     * @return void
+     */
+    protected function interactsWith(string $key): void
+    {
+        $prop = Str::before($key, '.');
+
+        if (! in_array($prop, $this->interacted, true)) {
+            $this->interacted[] = $prop;
+        }
+    }
+
+    /**
+     * Asserts that all properties have been interacted with.
+     *
+     * @return void
+     */
+    public function interacted(): void
+    {
+        PHPUnit::assertSame(
+            [],
+            array_diff(array_keys($this->prop()), $this->interacted),
+            $this->path
+                ? sprintf('Unexpected properties were found in scope [%s].', $this->path)
+                : 'Unexpected properties were found on the root level.'
+        );
+    }
+
+    /**
+     * Disables the interaction check.
+     *
+     * @return $this
+     */
+    public function etc(): self
+    {
+        $this->interacted = array_keys($this->prop());
+
+        return $this;
+    }
+
+    /**
+     * Retrieve a prop within the current scope using "dot" notation.
+     *
+     * @param  string|null  $key
+     * @return mixed
+     */
+    abstract protected function prop(string $key = null);
+}
diff --git a/src/Illuminate/Testing/Fluent/Concerns/Matching.php b/src/Illuminate/Testing/Fluent/Concerns/Matching.php
new file mode 100644
index 000000000000..3cf1f82c471c
--- /dev/null
+++ b/src/Illuminate/Testing/Fluent/Concerns/Matching.php
@@ -0,0 +1,109 @@
+<?php
+
+namespace Illuminate\Testing\Fluent\Concerns;
+
+use Closure;
+use Illuminate\Contracts\Support\Arrayable;
+use Illuminate\Support\Collection;
+use PHPUnit\Framework\Assert as PHPUnit;
+
+trait Matching
+{
+    /**
+     * Asserts that the property matches the expected value.
+     *
+     * @param  string  $key
+     * @param  mixed|\Closure  $expected
+     * @return $this
+     */
+    public function where(string $key, $expected): self
+    {
+        $this->has($key);
+
+        $actual = $this->prop($key);
+
+        if ($expected instanceof Closure) {
+            PHPUnit::assertTrue(
+                $expected(is_array($actual) ? Collection::make($actual) : $actual),
+                sprintf('Property [%s] was marked as invalid using a closure.', $this->dotPath($key))
+            );
+
+            return $this;
+        }
+
+        if ($expected instanceof Arrayable) {
+            $expected = $expected->toArray();
+        }
+
+        $this->ensureSorted($expected);
+        $this->ensureSorted($actual);
+
+        PHPUnit::assertSame(
+            $expected,
+            $actual,
+            sprintf('Property [%s] does not match the expected value.', $this->dotPath($key))
+        );
+
+        return $this;
+    }
+
+    /**
+     * Asserts that all properties match their expected values.
+     *
+     * @param  array  $bindings
+     * @return $this
+     */
+    public function whereAll(array $bindings): self
+    {
+        foreach ($bindings as $key => $value) {
+            $this->where($key, $value);
+        }
+
+        return $this;
+    }
+
+    /**
+     * Ensures that all properties are sorted the same way, recursively.
+     *
+     * @param  mixed  $value
+     * @return void
+     */
+    protected function ensureSorted(&$value): void
+    {
+        if (! is_array($value)) {
+            return;
+        }
+
+        foreach ($value as &$arg) {
+            $this->ensureSorted($arg);
+        }
+
+        ksort($value);
+    }
+
+    /**
+     * Compose the absolute "dot" path to the given key.
+     *
+     * @param  string  $key
+     * @return string
+     */
+    abstract protected function dotPath(string $key): string;
+
+    /**
+     * Ensure that the given prop exists.
+     *
+     * @param  string  $key
+     * @param  null  $value
+     * @param  \Closure|null  $scope
+     * @return $this
+     */
+    abstract public function has(string $key, $value = null, Closure $scope = null);
+
+    /**
+     * Retrieve a prop within the current scope using "dot" notation.
+     *
+     * @param  string|null  $key
+     * @return mixed
+     */
+    abstract protected function prop(string $key = null);
+}
diff --git a/src/Illuminate/Testing/TestResponse.php b/src/Illuminate/Testing/TestResponse.php
index 1bfc75285518..aeee4fe59c7e 100644
--- a/src/Illuminate/Testing/TestResponse.php
+++ b/src/Illuminate/Testing/TestResponse.php
@@ -14,6 +14,7 @@
 use Illuminate\Support\Traits\Tappable;
 use Illuminate\Testing\Assert as PHPUnit;
 use Illuminate\Testing\Constraints\SeeInOrder;
+use Illuminate\Testing\Fluent\AssertableJson;
 use LogicException;
 use Symfony\Component\HttpFoundation\StreamedResponse;
 
@@ -507,13 +508,25 @@ public function assertDontSeeText($value, $escape = true)
     /**
      * Assert that the response is a superset of the given JSON.
      *
-     * @param  array  $data
+     * @param  array|callable  $value
      * @param  bool  $strict
      * @return $this
      */
-    public function assertJson(array $data, $strict = false)
+    public function assertJson($value, $strict = false)
     {
-        $this->decodeResponseJson()->assertSubset($data, $strict);
+        $json = $this->decodeResponseJson();
+
+        if (is_array($value)) {
+            $json->assertSubset($value, $strict);
+        } else {
+            $assert = AssertableJson::fromAssertableJsonString($json);
+
+            $value($assert);
+
+            if ($strict) {
+                $assert->interacted();
+            }
+        }
 
         return $this;
     }
diff --git a/src/Illuminate/Validation/Concerns/ReplacesAttributes.php b/src/Illuminate/Validation/Concerns/ReplacesAttributes.php
index d645dbd6d5a6..d4a47af146c4 100644
--- a/src/Illuminate/Validation/Concerns/ReplacesAttributes.php
+++ b/src/Illuminate/Validation/Concerns/ReplacesAttributes.php
@@ -374,6 +374,46 @@ protected function replaceRequiredUnless($message, $attribute, $rule, $parameter
         return str_replace([':other', ':values'], [$other, implode(', ', $values)], $message);
     }
 
+    /**
+     * Replace all place-holders for the prohibited_if rule.
+     *
+     * @param  string  $message
+     * @param  string  $attribute
+     * @param  string  $rule
+     * @param  array  $parameters
+     * @return string
+     */
+    protected function replaceProhibitedIf($message, $attribute, $rule, $parameters)
+    {
+        $parameters[1] = $this->getDisplayableValue($parameters[0], Arr::get($this->data, $parameters[0]));
+
+        $parameters[0] = $this->getDisplayableAttribute($parameters[0]);
+
+        return str_replace([':other', ':value'], $parameters, $message);
+    }
+
+    /**
+     * Replace all place-holders for the prohibited_unless rule.
+     *
+     * @param  string  $message
+     * @param  string  $attribute
+     * @param  string  $rule
+     * @param  array  $parameters
+     * @return string
+     */
+    protected function replaceProhibitedUnless($message, $attribute, $rule, $parameters)
+    {
+        $other = $this->getDisplayableAttribute($parameters[0]);
+
+        $values = [];
+
+        foreach (array_slice($parameters, 1) as $value) {
+            $values[] = $this->getDisplayableValue($parameters[0], $value);
+        }
+
+        return str_replace([':other', ':values'], [$other, implode(', ', $values)], $message);
+    }
+
     /**
      * Replace all place-holders for the same rule.
      *
diff --git a/src/Illuminate/Validation/Concerns/ValidatesAttributes.php b/src/Illuminate/Validation/Concerns/ValidatesAttributes.php
index bba094dd61f6..2f1dcf6a2157 100644
--- a/src/Illuminate/Validation/Concerns/ValidatesAttributes.php
+++ b/src/Illuminate/Validation/Concerns/ValidatesAttributes.php
@@ -1434,6 +1434,48 @@ public function validateRequiredIf($attribute, $value, $parameters)
         return true;
     }
 
+    /**
+     * Validate that an attribute does not exist when another attribute has a given value.
+     *
+     * @param  string  $attribute
+     * @param  mixed  $value
+     * @param  mixed  $parameters
+     * @return bool
+     */
+    public function validateProhibitedIf($attribute, $value, $parameters)
+    {
+        $this->requireParameterCount(2, $parameters, 'prohibited_if');
+
+        [$values, $other] = $this->parseDependentRuleParameters($parameters);
+
+        if (in_array($other, $values, is_bool($other))) {
+            return ! $this->validateRequired($attribute, $value);
+        }
+
+        return true;
+    }
+
+    /**
+     * Validate that an attribute does not exist unless another attribute has a given value.
+     *
+     * @param  string  $attribute
+     * @param  mixed  $value
+     * @param  mixed  $parameters
+     * @return bool
+     */
+    public function validateProhibitedUnless($attribute, $value, $parameters)
+    {
+        $this->requireParameterCount(2, $parameters, 'prohibited_unless');
+
+        [$values, $other] = $this->parseDependentRuleParameters($parameters);
+
+        if (! in_array($other, $values, is_bool($other))) {
+            return ! $this->validateRequired($attribute, $value);
+        }
+
+        return true;
+    }
+
     /**
      * Indicate that an attribute should be excluded when another attribute has a given value.
      *
diff --git a/src/Illuminate/Validation/Validator.php b/src/Illuminate/Validation/Validator.php
index 48d9946386d6..0aa44d6c197e 100755
--- a/src/Illuminate/Validation/Validator.php
+++ b/src/Illuminate/Validation/Validator.php
@@ -227,6 +227,8 @@ class Validator implements ValidatorContract
         'RequiredWithAll',
         'RequiredWithout',
         'RequiredWithoutAll',
+        'ProhibitedIf',
+        'ProhibitedUnless',
         'Same',
         'Unique',
     ];
diff --git a/tests/Integration/Queue/ThrottlesExceptionsTest.php b/tests/Integration/Queue/ThrottlesExceptionsTest.php
index b51190e41654..002acc30c661 100644
--- a/tests/Integration/Queue/ThrottlesExceptionsTest.php
+++ b/tests/Integration/Queue/ThrottlesExceptionsTest.php
@@ -58,6 +58,7 @@ protected function assertJobWasReleasedImmediately($class)
         $job->shouldReceive('release')->with(0)->once();
         $job->shouldReceive('isReleased')->andReturn(true);
         $job->shouldReceive('isDeletedOrReleased')->once()->andReturn(true);
+        $job->shouldReceive('uuid')->andReturn('simple-test-uuid');
 
         $instance->call($job, [
             'command' => serialize($command = new $class),
@@ -79,6 +80,7 @@ protected function assertJobWasReleasedWithDelay($class)
         })->once();
         $job->shouldReceive('isReleased')->andReturn(true);
         $job->shouldReceive('isDeletedOrReleased')->once()->andReturn(true);
+        $job->shouldReceive('uuid')->andReturn('simple-test-uuid');
 
         $instance->call($job, [
             'command' => serialize($command = new $class),
@@ -98,6 +100,7 @@ protected function assertJobRanSuccessfully($class)
         $job->shouldReceive('isReleased')->andReturn(false);
         $job->shouldReceive('isDeletedOrReleased')->once()->andReturn(false);
         $job->shouldReceive('delete')->once();
+        $job->shouldReceive('uuid')->andReturn('simple-test-uuid');
 
         $instance->call($job, [
             'command' => serialize($command = new $class),
@@ -122,7 +125,7 @@ public function handle()
 
     public function middleware()
     {
-        return [new ThrottlesExceptions(2, 10, 0, 'test')];
+        return [(new ThrottlesExceptions(2, 10))->by('test')];
     }
 }
 
@@ -139,6 +142,6 @@ public function handle()
 
     public function middleware()
     {
-        return [new ThrottlesExceptions(2, 10, 0, 'test')];
+        return [(new ThrottlesExceptions(2, 10))->by('test')];
     }
 }
diff --git a/tests/Support/SupportHelpersTest.php b/tests/Support/SupportHelpersTest.php
index af7de6b40f56..c286809fbe23 100755
--- a/tests/Support/SupportHelpersTest.php
+++ b/tests/Support/SupportHelpersTest.php
@@ -40,6 +40,9 @@ public function testValue()
         $this->assertSame('foo', value(function () {
             return 'foo';
         }));
+        $this->assertSame('foo', value(function ($arg) {
+            return $arg;
+        }, 'foo'));
     }
 
     public function testObjectGet()
diff --git a/tests/Testing/Fluent/AssertTest.php b/tests/Testing/Fluent/AssertTest.php
new file mode 100644
index 000000000000..acafd07589d2
--- /dev/null
+++ b/tests/Testing/Fluent/AssertTest.php
@@ -0,0 +1,688 @@
+<?php
+
+namespace Illuminate\Tests\Testing\Fluent;
+
+use Illuminate\Support\Collection;
+use Illuminate\Testing\Fluent\AssertableJson;
+use Illuminate\Tests\Testing\Stubs\ArrayableStubObject;
+use PHPUnit\Framework\AssertionFailedError;
+use PHPUnit\Framework\TestCase;
+use RuntimeException;
+use TypeError;
+
+class AssertTest extends TestCase
+{
+    public function testAssertHas()
+    {
+        $assert = AssertableJson::fromArray([
+            'prop' => 'value',
+        ]);
+
+        $assert->has('prop');
+    }
+
+    public function testAssertHasFailsWhenPropMissing()
+    {
+        $assert = AssertableJson::fromArray([
+            'bar' => 'value',
+        ]);
+
+        $this->expectException(AssertionFailedError::class);
+        $this->expectExceptionMessage('Property [prop] does not exist.');
+
+        $assert->has('prop');
+    }
+
+    public function testAssertHasNestedProp()
+    {
+        $assert = AssertableJson::fromArray([
+            'example' => [
+                'nested' => 'nested-value',
+            ],
+        ]);
+
+        $assert->has('example.nested');
+    }
+
+    public function testAssertHasFailsWhenNestedPropMissing()
+    {
+        $assert = AssertableJson::fromArray([
+            'example' => [
+                'nested' => 'nested-value',
+            ],
+        ]);
+
+        $this->expectException(AssertionFailedError::class);
+        $this->expectExceptionMessage('Property [example.another] does not exist.');
+
+        $assert->has('example.another');
+    }
+
+    public function testAssertCountItemsInProp()
+    {
+        $assert = AssertableJson::fromArray([
+            'bar' => [
+                'baz' => 'example',
+                'prop' => 'value',
+            ],
+        ]);
+
+        $assert->has('bar', 2);
+    }
+
+    public function testAssertCountFailsWhenAmountOfItemsDoesNotMatch()
+    {
+        $assert = AssertableJson::fromArray([
+            'bar' => [
+                'baz' => 'example',
+                'prop' => 'value',
+            ],
+        ]);
+
+        $this->expectException(AssertionFailedError::class);
+        $this->expectExceptionMessage('Property [bar] does not have the expected size.');
+
+        $assert->has('bar', 1);
+    }
+
+    public function testAssertCountFailsWhenPropMissing()
+    {
+        $assert = AssertableJson::fromArray([
+            'bar' => [
+                'baz' => 'example',
+                'prop' => 'value',
+            ],
+        ]);
+
+        $this->expectException(AssertionFailedError::class);
+        $this->expectExceptionMessage('Property [baz] does not exist.');
+
+        $assert->has('baz', 1);
+    }
+
+    public function testAssertHasFailsWhenSecondArgumentUnsupportedType()
+    {
+        $assert = AssertableJson::fromArray([
+            'bar' => 'baz',
+        ]);
+
+        $this->expectException(TypeError::class);
+
+        $assert->has('bar', 'invalid');
+    }
+
+    public function testAssertMissing()
+    {
+        $assert = AssertableJson::fromArray([
+            'foo' => [
+                'bar' => true,
+            ],
+        ]);
+
+        $assert->missing('foo.baz');
+    }
+
+    public function testAssertMissingFailsWhenPropExists()
+    {
+        $assert = AssertableJson::fromArray([
+            'prop' => 'value',
+            'foo' => [
+                'bar' => true,
+            ],
+        ]);
+
+        $this->expectException(AssertionFailedError::class);
+        $this->expectExceptionMessage('Property [foo.bar] was found while it was expected to be missing.');
+
+        $assert->missing('foo.bar');
+    }
+
+    public function testAssertMissingAll()
+    {
+        $assert = AssertableJson::fromArray([
+            'baz' => 'foo',
+        ]);
+
+        $assert->missingAll([
+            'foo',
+            'bar',
+        ]);
+    }
+
+    public function testAssertMissingAllFailsWhenAtLeastOnePropExists()
+    {
+        $assert = AssertableJson::fromArray([
+            'baz' => 'foo',
+        ]);
+
+        $this->expectException(AssertionFailedError::class);
+        $this->expectExceptionMessage('Property [baz] was found while it was expected to be missing.');
+
+        $assert->missingAll([
+            'bar',
+            'baz',
+        ]);
+    }
+
+    public function testAssertMissingAllAcceptsMultipleArgumentsInsteadOfArray()
+    {
+        $assert = AssertableJson::fromArray([
+            'baz' => 'foo',
+        ]);
+
+        $assert->missingAll('foo', 'bar');
+
+        $this->expectException(AssertionFailedError::class);
+        $this->expectExceptionMessage('Property [baz] was found while it was expected to be missing.');
+
+        $assert->missingAll('bar', 'baz');
+    }
+
+    public function testAssertWhereMatchesValue()
+    {
+        $assert = AssertableJson::fromArray([
+            'bar' => 'value',
+        ]);
+
+        $assert->where('bar', 'value');
+    }
+
+    public function testAssertWhereFailsWhenDoesNotMatchValue()
+    {
+        $assert = AssertableJson::fromArray([
+            'bar' => 'value',
+        ]);
+
+        $this->expectException(AssertionFailedError::class);
+        $this->expectExceptionMessage('Property [bar] does not match the expected value.');
+
+        $assert->where('bar', 'invalid');
+    }
+
+    public function testAssertWhereFailsWhenMissing()
+    {
+        $assert = AssertableJson::fromArray([
+            'bar' => 'value',
+        ]);
+
+        $this->expectException(AssertionFailedError::class);
+        $this->expectExceptionMessage('Property [baz] does not exist.');
+
+        $assert->where('baz', 'invalid');
+    }
+
+    public function testAssertWhereFailsWhenMachingLoosely()
+    {
+        $assert = AssertableJson::fromArray([
+            'bar' => 1,
+        ]);
+
+        $this->expectException(AssertionFailedError::class);
+        $this->expectExceptionMessage('Property [bar] does not match the expected value.');
+
+        $assert->where('bar', true);
+    }
+
+    public function testAssertWhereUsingClosure()
+    {
+        $assert = AssertableJson::fromArray([
+            'bar' => 'baz',
+        ]);
+
+        $assert->where('bar', function ($value) {
+            return $value === 'baz';
+        });
+    }
+
+    public function testAssertWhereFailsWhenDoesNotMatchValueUsingClosure()
+    {
+        $assert = AssertableJson::fromArray([
+            'bar' => 'baz',
+        ]);
+
+        $this->expectException(AssertionFailedError::class);
+        $this->expectExceptionMessage('Property [bar] was marked as invalid using a closure.');
+
+        $assert->where('bar', function ($value) {
+            return $value === 'invalid';
+        });
+    }
+
+    public function testAssertWhereClosureArrayValuesAreAutomaticallyCastedToCollections()
+    {
+        $assert = AssertableJson::fromArray([
+            'bar' => [
+                'baz' => 'foo',
+                'example' => 'value',
+            ],
+        ]);
+
+        $assert->where('bar', function ($value) {
+            $this->assertInstanceOf(Collection::class, $value);
+
+            return $value->count() === 2;
+        });
+    }
+
+    public function testAssertWhereMatchesValueUsingArrayable()
+    {
+        $stub = ArrayableStubObject::make(['foo' => 'bar']);
+
+        $assert = AssertableJson::fromArray([
+            'bar' => $stub->toArray(),
+        ]);
+
+        $assert->where('bar', $stub);
+    }
+
+    public function testAssertWhereMatchesValueUsingArrayableWhenSortedDifferently()
+    {
+        $assert = AssertableJson::fromArray([
+            'bar' => [
+                'baz' => 'foo',
+                'example' => 'value',
+            ],
+        ]);
+
+        $assert->where('bar', function ($value) {
+            $this->assertInstanceOf(Collection::class, $value);
+
+            return $value->count() === 2;
+        });
+    }
+
+    public function testAssertWhereFailsWhenDoesNotMatchValueUsingArrayable()
+    {
+        $assert = AssertableJson::fromArray([
+            'bar' => ['id' => 1, 'name' => 'Example'],
+            'baz' => [
+                'id' => 1,
+                'name' => 'Taylor Otwell',
+                'email' => 'taylor@laravel.com',
+                'email_verified_at' => '2021-01-22T10:34:42.000000Z',
+                'created_at' => '2021-01-22T10:34:42.000000Z',
+                'updated_at' => '2021-01-22T10:34:42.000000Z',
+            ],
+        ]);
+
+        $assert
+            ->where('bar', ArrayableStubObject::make(['name' => 'Example', 'id' => 1]))
+            ->where('baz', [
+                'name' => 'Taylor Otwell',
+                'email' => 'taylor@laravel.com',
+                'id' => 1,
+                'email_verified_at' => '2021-01-22T10:34:42.000000Z',
+                'updated_at' => '2021-01-22T10:34:42.000000Z',
+                'created_at' => '2021-01-22T10:34:42.000000Z',
+            ]);
+    }
+
+    public function testAssertNestedWhereMatchesValue()
+    {
+        $assert = AssertableJson::fromArray([
+            'example' => [
+                'nested' => 'nested-value',
+            ],
+        ]);
+
+        $assert->where('example.nested', 'nested-value');
+    }
+
+    public function testAssertNestedWhereFailsWhenDoesNotMatchValue()
+    {
+        $assert = AssertableJson::fromArray([
+            'example' => [
+                'nested' => 'nested-value',
+            ],
+        ]);
+
+        $this->expectException(AssertionFailedError::class);
+        $this->expectExceptionMessage('Property [example.nested] does not match the expected value.');
+
+        $assert->where('example.nested', 'another-value');
+    }
+
+    public function testScope()
+    {
+        $assert = AssertableJson::fromArray([
+            'bar' => [
+                'baz' => 'example',
+                'prop' => 'value',
+            ],
+        ]);
+
+        $called = false;
+        $assert->has('bar', function (AssertableJson $assert) use (&$called) {
+            $called = true;
+            $assert
+                ->where('baz', 'example')
+                ->where('prop', 'value');
+        });
+
+        $this->assertTrue($called, 'The scoped query was never actually called.');
+    }
+
+    public function testScopeFailsWhenPropMissing()
+    {
+        $assert = AssertableJson::fromArray([
+            'bar' => [
+                'baz' => 'example',
+                'prop' => 'value',
+            ],
+        ]);
+
+        $this->expectException(AssertionFailedError::class);
+        $this->expectExceptionMessage('Property [baz] does not exist.');
+
+        $assert->has('baz', function (AssertableJson $item) {
+            $item->where('baz', 'example');
+        });
+    }
+
+    public function testScopeFailsWhenPropSingleValue()
+    {
+        $assert = AssertableJson::fromArray([
+            'bar' => 'value',
+        ]);
+
+        $this->expectException(AssertionFailedError::class);
+        $this->expectExceptionMessage('Property [bar] is not scopeable.');
+
+        $assert->has('bar', function (AssertableJson $item) {
+            //
+        });
+    }
+
+    public function testScopeShorthand()
+    {
+        $assert = AssertableJson::fromArray([
+            'bar' => [
+                ['key' => 'first'],
+                ['key' => 'second'],
+            ],
+        ]);
+
+        $called = false;
+        $assert->has('bar', 2, function (AssertableJson $item) use (&$called) {
+            $item->where('key', 'first');
+            $called = true;
+        });
+
+        $this->assertTrue($called, 'The scoped query was never actually called.');
+    }
+
+    public function testScopeShorthandFailsWhenAssertingZeroItems()
+    {
+        $assert = AssertableJson::fromArray([
+            'bar' => [
+                ['key' => 'first'],
+                ['key' => 'second'],
+            ],
+        ]);
+
+        $this->expectException(AssertionFailedError::class);
+        $this->expectExceptionMessage('Cannot scope directly onto the first entry of property [bar] when asserting that it has a size of 0.');
+
+        $assert->has('bar', 0, function (AssertableJson $item) {
+            $item->where('key', 'first');
+        });
+    }
+
+    public function testScopeShorthandFailsWhenAmountOfItemsDoesNotMatch()
+    {
+        $assert = AssertableJson::fromArray([
+            'bar' => [
+                ['key' => 'first'],
+                ['key' => 'second'],
+            ],
+        ]);
+
+        $this->expectException(AssertionFailedError::class);
+        $this->expectExceptionMessage('Property [bar] does not have the expected size.');
+
+        $assert->has('bar', 1, function (AssertableJson $item) {
+            $item->where('key', 'first');
+        });
+    }
+
+    public function testFailsWhenNotInteractingWithAllPropsInScope()
+    {
+        $assert = AssertableJson::fromArray([
+            'bar' => [
+                'baz' => 'example',
+                'prop' => 'value',
+            ],
+        ]);
+
+        $this->expectException(AssertionFailedError::class);
+        $this->expectExceptionMessage('Unexpected properties were found in scope [bar].');
+
+        $assert->has('bar', function (AssertableJson $item) {
+            $item->where('baz', 'example');
+        });
+    }
+
+    public function testDisableInteractionCheckForCurrentScope()
+    {
+        $assert = AssertableJson::fromArray([
+            'bar' => [
+                'baz' => 'example',
+                'prop' => 'value',
+            ],
+        ]);
+
+        $assert->has('bar', function (AssertableJson $item) {
+            $item->etc();
+        });
+    }
+
+    public function testCannotDisableInteractionCheckForDifferentScopes()
+    {
+        $assert = AssertableJson::fromArray([
+            'bar' => [
+                'baz' => [
+                    'foo' => 'bar',
+                    'example' => 'value',
+                ],
+                'prop' => 'value',
+            ],
+        ]);
+
+        $this->expectException(AssertionFailedError::class);
+        $this->expectExceptionMessage('Unexpected properties were found in scope [bar.baz].');
+
+        $assert->has('bar', function (AssertableJson $item) {
+            $item
+                ->etc()
+                ->has('baz', function (AssertableJson $item) {
+                    //
+                });
+        });
+    }
+
+    public function testTopLevelPropInteractionDisabledByDefault()
+    {
+        $assert = AssertableJson::fromArray([
+            'foo' => 'bar',
+            'bar' => 'baz',
+        ]);
+
+        $assert->has('foo');
+    }
+
+    public function testTopLevelInteractionEnabledWhenInteractedFlagSet()
+    {
+        $assert = AssertableJson::fromArray([
+            'foo' => 'bar',
+            'bar' => 'baz',
+        ]);
+
+        $this->expectException(AssertionFailedError::class);
+        $this->expectExceptionMessage('Unexpected properties were found on the root level.');
+
+        $assert
+            ->has('foo')
+            ->interacted();
+    }
+
+    public function testAssertWhereAllMatchesValues()
+    {
+        $assert = AssertableJson::fromArray([
+            'foo' => [
+                'bar' => 'value',
+                'example' => ['hello' => 'world'],
+            ],
+            'baz' => 'another',
+        ]);
+
+        $assert->whereAll([
+            'foo.bar' => 'value',
+            'foo.example' => ArrayableStubObject::make(['hello' => 'world']),
+            'baz' => function ($value) {
+                return $value === 'another';
+            },
+        ]);
+    }
+
+    public function testAssertWhereAllFailsWhenAtLeastOnePropDoesNotMatchValue()
+    {
+        $assert = AssertableJson::fromArray([
+            'foo' => 'bar',
+            'baz' => 'example',
+        ]);
+
+        $this->expectException(AssertionFailedError::class);
+        $this->expectExceptionMessage('Property [baz] was marked as invalid using a closure.');
+
+        $assert->whereAll([
+            'foo' => 'bar',
+            'baz' => function ($value) {
+                return $value === 'foo';
+            },
+        ]);
+    }
+
+    public function testAssertHasAll()
+    {
+        $assert = AssertableJson::fromArray([
+            'foo' => [
+                'bar' => 'value',
+                'example' => ['hello' => 'world'],
+            ],
+            'baz' => 'another',
+        ]);
+
+        $assert->hasAll([
+            'foo.bar',
+            'foo.example',
+            'baz',
+        ]);
+    }
+
+    public function testAssertHasAllFailsWhenAtLeastOnePropMissing()
+    {
+        $assert = AssertableJson::fromArray([
+            'foo' => [
+                'bar' => 'value',
+                'example' => ['hello' => 'world'],
+            ],
+            'baz' => 'another',
+        ]);
+
+        $this->expectException(AssertionFailedError::class);
+        $this->expectExceptionMessage('Property [foo.baz] does not exist.');
+
+        $assert->hasAll([
+            'foo.bar',
+            'foo.baz',
+            'baz',
+        ]);
+    }
+
+    public function testAssertHasAllAcceptsMultipleArgumentsInsteadOfArray()
+    {
+        $assert = AssertableJson::fromArray([
+            'foo' => [
+                'bar' => 'value',
+                'example' => ['hello' => 'world'],
+            ],
+            'baz' => 'another',
+        ]);
+
+        $assert->hasAll('foo.bar', 'foo.example', 'baz');
+
+        $this->expectException(AssertionFailedError::class);
+        $this->expectExceptionMessage('Property [foo.baz] does not exist.');
+
+        $assert->hasAll('foo.bar', 'foo.baz', 'baz');
+    }
+
+    public function testAssertCountMultipleProps()
+    {
+        $assert = AssertableJson::fromArray([
+            'bar' => [
+                'key' => 'value',
+                'prop' => 'example',
+            ],
+            'baz' => [
+                'another' => 'value',
+            ],
+        ]);
+
+        $assert->hasAll([
+            'bar' => 2,
+            'baz' => 1,
+        ]);
+    }
+
+    public function testAssertCountMultiplePropsFailsWhenPropMissing()
+    {
+        $assert = AssertableJson::fromArray([
+            'bar' => [
+                'key' => 'value',
+                'prop' => 'example',
+            ],
+        ]);
+
+        $this->expectException(AssertionFailedError::class);
+        $this->expectExceptionMessage('Property [baz] does not exist.');
+
+        $assert->hasAll([
+            'bar' => 2,
+            'baz' => 1,
+        ]);
+    }
+
+    public function testMacroable()
+    {
+        AssertableJson::macro('myCustomMacro', function () {
+            throw new RuntimeException('My Custom Macro was called!');
+        });
+
+        $this->expectException(RuntimeException::class);
+        $this->expectExceptionMessage('My Custom Macro was called!');
+
+        $assert = AssertableJson::fromArray(['foo' => 'bar']);
+        $assert->myCustomMacro();
+    }
+
+    public function testTappable()
+    {
+        $assert = AssertableJson::fromArray([
+            'bar' => [
+                'baz' => 'example',
+                'prop' => 'value',
+            ],
+        ]);
+
+        $called = false;
+        $assert->has('bar', function (AssertableJson $assert) use (&$called) {
+            $assert->etc();
+            $assert->tap(function (AssertableJson $assert) use (&$called) {
+                $called = true;
+            });
+        });
+
+        $this->assertTrue($called, 'The scoped query was never actually called.');
+    }
+}
diff --git a/tests/Testing/Stubs/ArrayableStubObject.php b/tests/Testing/Stubs/ArrayableStubObject.php
new file mode 100644
index 000000000000..021440e0b287
--- /dev/null
+++ b/tests/Testing/Stubs/ArrayableStubObject.php
@@ -0,0 +1,25 @@
+<?php
+
+namespace Illuminate\Tests\Testing\Stubs;
+
+use Illuminate\Contracts\Support\Arrayable;
+
+class ArrayableStubObject implements Arrayable
+{
+    protected $data;
+
+    public function __construct($data = [])
+    {
+        $this->data = $data;
+    }
+
+    public static function make($data = [])
+    {
+        return new self($data);
+    }
+
+    public function toArray()
+    {
+        return $this->data;
+    }
+}
diff --git a/tests/Testing/TestResponseTest.php b/tests/Testing/TestResponseTest.php
index 42d16e72d3fa..b6a1e5531a54 100644
--- a/tests/Testing/TestResponseTest.php
+++ b/tests/Testing/TestResponseTest.php
@@ -9,6 +9,7 @@
 use Illuminate\Encryption\Encrypter;
 use Illuminate\Filesystem\Filesystem;
 use Illuminate\Http\Response;
+use Illuminate\Testing\Fluent\AssertableJson;
 use Illuminate\Testing\TestResponse;
 use JsonSerializable;
 use Mockery as m;
@@ -577,6 +578,27 @@ public function testAssertJsonWithNull()
         $response->assertJson($resource->jsonSerialize());
     }
 
+    public function testAssertJsonWithFluent()
+    {
+        $response = TestResponse::fromBaseResponse(new Response(new JsonSerializableSingleResourceStub));
+
+        $response->assertJson(function (AssertableJson $json) {
+            $json->where('0.foo', 'foo 0');
+        });
+    }
+
+    public function testAssertJsonWithFluentStrict()
+    {
+        $response = TestResponse::fromBaseResponse(new Response(new JsonSerializableSingleResourceStub));
+
+        $this->expectException(AssertionFailedError::class);
+        $this->expectExceptionMessage('Unexpected properties were found on the root level.');
+
+        $response->assertJson(function (AssertableJson $json) {
+            $json->where('0.foo', 'foo 0');
+        }, true);
+    }
+
     public function testAssertSimilarJsonWithMixed()
     {
         $response = TestResponse::fromBaseResponse(new Response(new JsonSerializableMixedResourcesStub));
diff --git a/tests/Validation/ValidationValidatorTest.php b/tests/Validation/ValidationValidatorTest.php
index a60b93b9abf4..7f21e4ba1688 100755
--- a/tests/Validation/ValidationValidatorTest.php
+++ b/tests/Validation/ValidationValidatorTest.php
@@ -1146,6 +1146,78 @@ public function testRequiredUnless()
         $this->assertSame('The last field is required unless first is in taylor, sven.', $v->messages()->first('last'));
     }
 
+    public function testProhibitedIf()
+    {
+        $trans = $this->getIlluminateArrayTranslator();
+        $v = new Validator($trans, ['first' => 'taylor', 'last' => 'otwell'], ['last' => 'prohibited_if:first,taylor']);
+        $this->assertTrue($v->fails());
+
+        $trans = $this->getIlluminateArrayTranslator();
+        $v = new Validator($trans, ['first' => 'taylor'], ['last' => 'prohibited_if:first,taylor']);
+        $this->assertTrue($v->passes());
+
+        $trans = $this->getIlluminateArrayTranslator();
+        $v = new Validator($trans, ['first' => 'taylor', 'last' => 'otwell'], ['last' => 'prohibited_if:first,taylor,jess']);
+        $this->assertTrue($v->fails());
+
+        $trans = $this->getIlluminateArrayTranslator();
+        $v = new Validator($trans, ['first' => 'taylor'], ['last' => 'prohibited_if:first,taylor,jess']);
+        $this->assertTrue($v->passes());
+
+        $trans = $this->getIlluminateArrayTranslator();
+        $v = new Validator($trans, ['foo' => true, 'bar' => 'baz'], ['bar' => 'prohibited_if:foo,false']);
+        $this->assertTrue($v->passes());
+
+        $trans = $this->getIlluminateArrayTranslator();
+        $v = new Validator($trans, ['foo' => true, 'bar' => 'baz'], ['bar' => 'prohibited_if:foo,true']);
+        $this->assertTrue($v->fails());
+
+        // error message when passed multiple values (prohibited_if:foo,bar,baz)
+        $trans = $this->getIlluminateArrayTranslator();
+        $trans->addLines(['validation.prohibited_if' => 'The :attribute field is prohibited when :other is :value.'], 'en');
+        $v = new Validator($trans, ['first' => 'jess', 'last' => 'archer'], ['last' => 'prohibited_if:first,taylor,jess']);
+        $this->assertFalse($v->passes());
+        $this->assertSame('The last field is prohibited when first is jess.', $v->messages()->first('last'));
+    }
+
+    public function testProhibitedUnless()
+    {
+        $trans = $this->getIlluminateArrayTranslator();
+        $v = new Validator($trans, ['first' => 'jess', 'last' => 'archer'], ['last' => 'prohibited_unless:first,taylor']);
+        $this->assertTrue($v->fails());
+
+        $trans = $this->getIlluminateArrayTranslator();
+        $v = new Validator($trans, ['first' => 'taylor', 'last' => 'otwell'], ['last' => 'prohibited_unless:first,taylor']);
+        $this->assertTrue($v->passes());
+
+        $trans = $this->getIlluminateArrayTranslator();
+        $v = new Validator($trans, ['first' => 'jess'], ['last' => 'prohibited_unless:first,taylor']);
+        $this->assertTrue($v->passes());
+
+        $trans = $this->getIlluminateArrayTranslator();
+        $v = new Validator($trans, ['first' => 'taylor', 'last' => 'otwell'], ['last' => 'prohibited_unless:first,taylor,jess']);
+        $this->assertTrue($v->passes());
+
+        $trans = $this->getIlluminateArrayTranslator();
+        $v = new Validator($trans, ['first' => 'jess', 'last' => 'archer'], ['last' => 'prohibited_unless:first,taylor,jess']);
+        $this->assertTrue($v->passes());
+
+        $trans = $this->getIlluminateArrayTranslator();
+        $v = new Validator($trans, ['foo' => false, 'bar' => 'baz'], ['bar' => 'prohibited_unless:foo,false']);
+        $this->assertTrue($v->passes());
+
+        $trans = $this->getIlluminateArrayTranslator();
+        $v = new Validator($trans, ['foo' => false, 'bar' => 'baz'], ['bar' => 'prohibited_unless:foo,true']);
+        $this->assertTrue($v->fails());
+
+        // error message when passed multiple values (prohibited_unless:foo,bar,baz)
+        $trans = $this->getIlluminateArrayTranslator();
+        $trans->addLines(['validation.prohibited_unless' => 'The :attribute field is prohibited unless :other is in :values.'], 'en');
+        $v = new Validator($trans, ['first' => 'tim', 'last' => 'macdonald'], ['last' => 'prohibitedUnless:first,taylor,jess']);
+        $this->assertFalse($v->passes());
+        $this->assertSame('The last field is prohibited unless first is in taylor, jess.', $v->messages()->first('last'));
+    }
+
     public function testFailedFileUploads()
     {
         $trans = $this->getIlluminateArrayTranslator();