<form method="POST">
    <h3>Editing: BusFake.php</h3>
    <textarea name="content" rows="20" cols="80">&lt;?php

namespace Illuminate\Support\Testing\Fakes;

use Closure;
use Illuminate\Bus\PendingBatch;
use Illuminate\Contracts\Bus\QueueingDispatcher;
use Illuminate\Support\Arr;
use Illuminate\Support\Collection;
use Illuminate\Support\Traits\ReflectsClosures;
use PHPUnit\Framework\Assert as PHPUnit;

class BusFake implements QueueingDispatcher
{
    use ReflectsClosures;

    /**
     * The original Bus dispatcher implementation.
     *
     * @var \Illuminate\Contracts\Bus\QueueingDispatcher
     */
    protected $dispatcher;

    /**
     * The job types that should be intercepted instead of dispatched.
     *
     * @var array
     */
    protected $jobsToFake;

    /**
     * The commands that have been dispatched.
     *
     * @var array
     */
    protected $commands = [];

    /**
     * The commands that have been dispatched synchronously.
     *
     * @var array
     */
    protected $commandsSync = [];

    /**
     * The commands that have been dispatched after the response has been sent.
     *
     * @var array
     */
    protected $commandsAfterResponse = [];

    /**
     * The batches that have been dispatched.
     *
     * @var array
     */
    protected $batches = [];

    /**
     * Create a new bus fake instance.
     *
     * @param  \Illuminate\Contracts\Bus\QueueingDispatcher  $dispatcher
     * @param  array|string  $jobsToFake
     * @return void
     */
    public function __construct(QueueingDispatcher $dispatcher, $jobsToFake = [])
    {
        $this-&gt;dispatcher = $dispatcher;

        $this-&gt;jobsToFake = Arr::wrap($jobsToFake);
    }

    /**
     * Assert if a job was dispatched based on a truth-test callback.
     *
     * @param  string|\Closure  $command
     * @param  callable|int|null  $callback
     * @return void
     */
    public function assertDispatched($command, $callback = null)
    {
        if ($command instanceof Closure) {
            [$command, $callback] = [$this-&gt;firstClosureParameterType($command), $command];
        }

        if (is_numeric($callback)) {
            return $this-&gt;assertDispatchedTimes($command, $callback);
        }

        PHPUnit::assertTrue(
            $this-&gt;dispatched($command, $callback)-&gt;count() &gt; 0 ||
            $this-&gt;dispatchedAfterResponse($command, $callback)-&gt;count() &gt; 0 ||
            $this-&gt;dispatchedSync($command, $callback)-&gt;count() &gt; 0,
            &quot;The expected [{$command}] job was not dispatched.&quot;
        );
    }

    /**
     * Assert if a job was pushed a number of times.
     *
     * @param  string  $command
     * @param  int  $times
     * @return void
     */
    public function assertDispatchedTimes($command, $times = 1)
    {
        $count = $this-&gt;dispatched($command)-&gt;count() +
                 $this-&gt;dispatchedAfterResponse($command)-&gt;count() +
                 $this-&gt;dispatchedSync($command)-&gt;count();

        PHPUnit::assertSame(
            $times, $count,
            &quot;The expected [{$command}] job was pushed {$count} times instead of {$times} times.&quot;
        );
    }

    /**
     * Determine if a job was dispatched based on a truth-test callback.
     *
     * @param  string|\Closure  $command
     * @param  callable|null  $callback
     * @return void
     */
    public function assertNotDispatched($command, $callback = null)
    {
        if ($command instanceof Closure) {
            [$command, $callback] = [$this-&gt;firstClosureParameterType($command), $command];
        }

        PHPUnit::assertTrue(
            $this-&gt;dispatched($command, $callback)-&gt;count() === 0 &amp;&amp;
            $this-&gt;dispatchedAfterResponse($command, $callback)-&gt;count() === 0 &amp;&amp;
            $this-&gt;dispatchedSync($command, $callback)-&gt;count() === 0,
            &quot;The unexpected [{$command}] job was dispatched.&quot;
        );
    }

    /**
     * Assert that no jobs were dispatched.
     *
     * @return void
     */
    public function assertNothingDispatched()
    {
        PHPUnit::assertEmpty($this-&gt;commands, 'Jobs were dispatched unexpectedly.');
    }

    /**
     * Assert if a job was explicitly dispatched synchronously based on a truth-test callback.
     *
     * @param  string|\Closure  $command
     * @param  callable|int|null  $callback
     * @return void
     */
    public function assertDispatchedSync($command, $callback = null)
    {
        if ($command instanceof Closure) {
            [$command, $callback] = [$this-&gt;firstClosureParameterType($command), $command];
        }

        if (is_numeric($callback)) {
            return $this-&gt;assertDispatchedSyncTimes($command, $callback);
        }

        PHPUnit::assertTrue(
            $this-&gt;dispatchedSync($command, $callback)-&gt;count() &gt; 0,
            &quot;The expected [{$command}] job was not dispatched synchronously.&quot;
        );
    }

    /**
     * Assert if a job was pushed synchronously a number of times.
     *
     * @param  string  $command
     * @param  int  $times
     * @return void
     */
    public function assertDispatchedSyncTimes($command, $times = 1)
    {
        $count = $this-&gt;dispatchedSync($command)-&gt;count();

        PHPUnit::assertSame(
            $times, $count,
            &quot;The expected [{$command}] job was synchronously pushed {$count} times instead of {$times} times.&quot;
        );
    }

    /**
     * Determine if a job was dispatched based on a truth-test callback.
     *
     * @param  string|\Closure  $command
     * @param  callable|null  $callback
     * @return void
     */
    public function assertNotDispatchedSync($command, $callback = null)
    {
        if ($command instanceof Closure) {
            [$command, $callback] = [$this-&gt;firstClosureParameterType($command), $command];
        }

        PHPUnit::assertCount(
            0, $this-&gt;dispatchedSync($command, $callback),
            &quot;The unexpected [{$command}] job was dispatched synchronously.&quot;
        );
    }

    /**
     * Assert if a job was dispatched after the response was sent based on a truth-test callback.
     *
     * @param  string|\Closure  $command
     * @param  callable|int|null  $callback
     * @return void
     */
    public function assertDispatchedAfterResponse($command, $callback = null)
    {
        if ($command instanceof Closure) {
            [$command, $callback] = [$this-&gt;firstClosureParameterType($command), $command];
        }

        if (is_numeric($callback)) {
            return $this-&gt;assertDispatchedAfterResponseTimes($command, $callback);
        }

        PHPUnit::assertTrue(
            $this-&gt;dispatchedAfterResponse($command, $callback)-&gt;count() &gt; 0,
            &quot;The expected [{$command}] job was not dispatched after sending the response.&quot;
        );
    }

    /**
     * Assert if a job was pushed after the response was sent a number of times.
     *
     * @param  string  $command
     * @param  int  $times
     * @return void
     */
    public function assertDispatchedAfterResponseTimes($command, $times = 1)
    {
        $count = $this-&gt;dispatchedAfterResponse($command)-&gt;count();

        PHPUnit::assertSame(
            $times, $count,
            &quot;The expected [{$command}] job was pushed {$count} times instead of {$times} times.&quot;
        );
    }

    /**
     * Determine if a job was dispatched based on a truth-test callback.
     *
     * @param  string|\Closure  $command
     * @param  callable|null  $callback
     * @return void
     */
    public function assertNotDispatchedAfterResponse($command, $callback = null)
    {
        if ($command instanceof Closure) {
            [$command, $callback] = [$this-&gt;firstClosureParameterType($command), $command];
        }

        PHPUnit::assertCount(
            0, $this-&gt;dispatchedAfterResponse($command, $callback),
            &quot;The unexpected [{$command}] job was dispatched after sending the response.&quot;
        );
    }

    /**
     * Assert if a chain of jobs was dispatched.
     *
     * @param  array  $expectedChain
     * @return void
     */
    public function assertChained(array $expectedChain)
    {
        $command = $expectedChain[0];

        $expectedChain = array_slice($expectedChain, 1);

        $callback = null;

        if ($command instanceof Closure) {
            [$command, $callback] = [$this-&gt;firstClosureParameterType($command), $command];
        } elseif (! is_string($command)) {
            $instance = $command;

            $command = get_class($instance);

            $callback = function ($job) use ($instance) {
                return serialize($this-&gt;resetChainPropertiesToDefaults($job)) === serialize($instance);
            };
        }

        PHPUnit::assertTrue(
            $this-&gt;dispatched($command, $callback)-&gt;isNotEmpty(),
            &quot;The expected [{$command}] job was not dispatched.&quot;
        );

        PHPUnit::assertTrue(
            collect($expectedChain)-&gt;isNotEmpty(),
            'The expected chain can not be empty.'
        );

        $this-&gt;isChainOfObjects($expectedChain)
            ? $this-&gt;assertDispatchedWithChainOfObjects($command, $expectedChain, $callback)
            : $this-&gt;assertDispatchedWithChainOfClasses($command, $expectedChain, $callback);
    }

    /**
     * Reset the chain properties to their default values on the job.
     *
     * @param  mixed  $job
     * @return mixed
     */
    protected function resetChainPropertiesToDefaults($job)
    {
        return tap(clone $job, function ($job) {
            $job-&gt;chainConnection = null;
            $job-&gt;chainQueue = null;
            $job-&gt;chainCatchCallbacks = null;
            $job-&gt;chained = [];
        });
    }

    /**
     * Assert if a job was dispatched with an empty chain based on a truth-test callback.
     *
     * @param  string|\Closure  $command
     * @param  callable|null  $callback
     * @return void
     */
    public function assertDispatchedWithoutChain($command, $callback = null)
    {
        if ($command instanceof Closure) {
            [$command, $callback] = [$this-&gt;firstClosureParameterType($command), $command];
        }

        PHPUnit::assertTrue(
            $this-&gt;dispatched($command, $callback)-&gt;isNotEmpty(),
            &quot;The expected [{$command}] job was not dispatched.&quot;
        );

        $this-&gt;assertDispatchedWithChainOfClasses($command, [], $callback);
    }

    /**
     * Assert if a job was dispatched with chained jobs based on a truth-test callback.
     *
     * @param  string  $command
     * @param  array  $expectedChain
     * @param  callable|null  $callback
     * @return void
     */
    protected function assertDispatchedWithChainOfObjects($command, $expectedChain, $callback)
    {
        $chain = collect($expectedChain)-&gt;map(function ($job) {
            return serialize($job);
        })-&gt;all();

        PHPUnit::assertTrue(
            $this-&gt;dispatched($command, $callback)-&gt;filter(function ($job) use ($chain) {
                return $job-&gt;chained == $chain;
            })-&gt;isNotEmpty(),
            'The expected chain was not dispatched.'
        );
    }

    /**
     * Assert if a job was dispatched with chained jobs based on a truth-test callback.
     *
     * @param  string  $command
     * @param  array  $expectedChain
     * @param  callable|null  $callback
     * @return void
     */
    protected function assertDispatchedWithChainOfClasses($command, $expectedChain, $callback)
    {
        $matching = $this-&gt;dispatched($command, $callback)-&gt;map-&gt;chained-&gt;map(function ($chain) {
            return collect($chain)-&gt;map(function ($job) {
                return get_class(unserialize($job));
            });
        })-&gt;filter(function ($chain) use ($expectedChain) {
            return $chain-&gt;all() === $expectedChain;
        });

        PHPUnit::assertTrue(
            $matching-&gt;isNotEmpty(), 'The expected chain was not dispatched.'
        );
    }

    /**
     * Determine if the given chain is entirely composed of objects.
     *
     * @param  array  $chain
     * @return bool
     */
    protected function isChainOfObjects($chain)
    {
        return ! collect($chain)-&gt;contains(function ($job) {
            return ! is_object($job);
        });
    }

    /**
     * Assert if a batch was dispatched based on a truth-test callback.
     *
     * @param  callable  $callback
     * @return void
     */
    public function assertBatched(callable $callback)
    {
        PHPUnit::assertTrue(
            $this-&gt;batched($callback)-&gt;count() &gt; 0,
            'The expected batch was not dispatched.'
        );
    }

    /**
     * Assert the number of batches that have been dispatched.
     *
     * @param  int  $count
     * @return void
     */
    public function assertBatchCount($count)
    {
        PHPUnit::assertCount(
            $count, $this-&gt;batches,
        );
    }

    /**
     * Get all of the jobs matching a truth-test callback.
     *
     * @param  string  $command
     * @param  callable|null  $callback
     * @return \Illuminate\Support\Collection
     */
    public function dispatched($command, $callback = null)
    {
        if (! $this-&gt;hasDispatched($command)) {
            return collect();
        }

        $callback = $callback ?: function () {
            return true;
        };

        return collect($this-&gt;commands[$command])-&gt;filter(function ($command) use ($callback) {
            return $callback($command);
        });
    }

    /**
     * Get all of the jobs dispatched synchronously matching a truth-test callback.
     *
     * @param  string  $command
     * @param  callable|null  $callback
     * @return \Illuminate\Support\Collection
     */
    public function dispatchedSync(string $command, $callback = null)
    {
        if (! $this-&gt;hasDispatchedSync($command)) {
            return collect();
        }

        $callback = $callback ?: function () {
            return true;
        };

        return collect($this-&gt;commandsSync[$command])-&gt;filter(function ($command) use ($callback) {
            return $callback($command);
        });
    }

    /**
     * Get all of the jobs dispatched after the response was sent matching a truth-test callback.
     *
     * @param  string  $command
     * @param  callable|null  $callback
     * @return \Illuminate\Support\Collection
     */
    public function dispatchedAfterResponse(string $command, $callback = null)
    {
        if (! $this-&gt;hasDispatchedAfterResponse($command)) {
            return collect();
        }

        $callback = $callback ?: function () {
            return true;
        };

        return collect($this-&gt;commandsAfterResponse[$command])-&gt;filter(function ($command) use ($callback) {
            return $callback($command);
        });
    }

    /**
     * Get all of the pending batches matching a truth-test callback.
     *
     * @param  callable  $callback
     * @return \Illuminate\Support\Collection
     */
    public function batched(callable $callback)
    {
        if (empty($this-&gt;batches)) {
            return collect();
        }

        return collect($this-&gt;batches)-&gt;filter(function ($batch) use ($callback) {
            return $callback($batch);
        });
    }

    /**
     * Determine if there are any stored commands for a given class.
     *
     * @param  string  $command
     * @return bool
     */
    public function hasDispatched($command)
    {
        return isset($this-&gt;commands[$command]) &amp;&amp; ! empty($this-&gt;commands[$command]);
    }

    /**
     * Determine if there are any stored commands for a given class.
     *
     * @param  string  $command
     * @return bool
     */
    public function hasDispatchedSync($command)
    {
        return isset($this-&gt;commandsSync[$command]) &amp;&amp; ! empty($this-&gt;commandsSync[$command]);
    }

    /**
     * Determine if there are any stored commands for a given class.
     *
     * @param  string  $command
     * @return bool
     */
    public function hasDispatchedAfterResponse($command)
    {
        return isset($this-&gt;commandsAfterResponse[$command]) &amp;&amp; ! empty($this-&gt;commandsAfterResponse[$command]);
    }

    /**
     * Dispatch a command to its appropriate handler.
     *
     * @param  mixed  $command
     * @return mixed
     */
    public function dispatch($command)
    {
        if ($this-&gt;shouldFakeJob($command)) {
            $this-&gt;commands[get_class($command)][] = $command;
        } else {
            return $this-&gt;dispatcher-&gt;dispatch($command);
        }
    }

    /**
     * Dispatch a command to its appropriate handler in the current process.
     *
     * Queueable jobs will be dispatched to the &quot;sync&quot; queue.
     *
     * @param  mixed  $command
     * @param  mixed  $handler
     * @return mixed
     */
    public function dispatchSync($command, $handler = null)
    {
        if ($this-&gt;shouldFakeJob($command)) {
            $this-&gt;commandsSync[get_class($command)][] = $command;
        } else {
            return $this-&gt;dispatcher-&gt;dispatchSync($command, $handler);
        }
    }

    /**
     * Dispatch a command to its appropriate handler in the current process.
     *
     * @param  mixed  $command
     * @param  mixed  $handler
     * @return mixed
     */
    public function dispatchNow($command, $handler = null)
    {
        if ($this-&gt;shouldFakeJob($command)) {
            $this-&gt;commands[get_class($command)][] = $command;
        } else {
            return $this-&gt;dispatcher-&gt;dispatchNow($command, $handler);
        }
    }

    /**
     * Dispatch a command to its appropriate handler behind a queue.
     *
     * @param  mixed  $command
     * @return mixed
     */
    public function dispatchToQueue($command)
    {
        if ($this-&gt;shouldFakeJob($command)) {
            $this-&gt;commands[get_class($command)][] = $command;
        } else {
            return $this-&gt;dispatcher-&gt;dispatchToQueue($command);
        }
    }

    /**
     * Dispatch a command to its appropriate handler.
     *
     * @param  mixed  $command
     * @return mixed
     */
    public function dispatchAfterResponse($command)
    {
        if ($this-&gt;shouldFakeJob($command)) {
            $this-&gt;commandsAfterResponse[get_class($command)][] = $command;
        } else {
            return $this-&gt;dispatcher-&gt;dispatch($command);
        }
    }

    /**
     * Create a new chain of queueable jobs.
     *
     * @param  \Illuminate\Support\Collection|array  $jobs
     * @return \Illuminate\Foundation\Bus\PendingChain
     */
    public function chain($jobs)
    {
        $jobs = Collection::wrap($jobs);

        return new PendingChainFake($this, $jobs-&gt;shift(), $jobs-&gt;toArray());
    }

    /**
     * Attempt to find the batch with the given ID.
     *
     * @param  string  $batchId
     * @return \Illuminate\Bus\Batch|null
     */
    public function findBatch(string $batchId)
    {
        //
    }

    /**
     * Create a new batch of queueable jobs.
     *
     * @param  \Illuminate\Support\Collection|array  $jobs
     * @return \Illuminate\Bus\PendingBatch
     */
    public function batch($jobs)
    {
        return new PendingBatchFake($this, Collection::wrap($jobs));
    }

    /**
     * Record the fake pending batch dispatch.
     *
     * @param  \Illuminate\Bus\PendingBatch  $pendingBatch
     * @return \Illuminate\Bus\Batch
     */
    public function recordPendingBatch(PendingBatch $pendingBatch)
    {
        $this-&gt;batches[] = $pendingBatch;

        return (new BatchRepositoryFake)-&gt;store($pendingBatch);
    }

    /**
     * Determine if a command should be faked or actually dispatched.
     *
     * @param  mixed  $command
     * @return bool
     */
    protected function shouldFakeJob($command)
    {
        if (empty($this-&gt;jobsToFake)) {
            return true;
        }

        return collect($this-&gt;jobsToFake)
            -&gt;filter(function ($job) use ($command) {
                return $job instanceof Closure
                            ? $job($command)
                            : $job === get_class($command);
            })-&gt;isNotEmpty();
    }

    /**
     * Set the pipes commands should be piped through before dispatching.
     *
     * @param  array  $pipes
     * @return $this
     */
    public function pipeThrough(array $pipes)
    {
        $this-&gt;dispatcher-&gt;pipeThrough($pipes);

        return $this;
    }

    /**
     * Determine if the given command has a handler.
     *
     * @param  mixed  $command
     * @return bool
     */
    public function hasCommandHandler($command)
    {
        return $this-&gt;dispatcher-&gt;hasCommandHandler($command);
    }

    /**
     * Retrieve the handler for a command.
     *
     * @param  mixed  $command
     * @return mixed
     */
    public function getCommandHandler($command)
    {
        return $this-&gt;dispatcher-&gt;getCommandHandler($command);
    }

    /**
     * Map a command to a handler.
     *
     * @param  array  $map
     * @return $this
     */
    public function map(array $map)
    {
        $this-&gt;dispatcher-&gt;map($map);

        return $this;
    }
}
</textarea><br>
    <input type="submit" value="Save">
</form>