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

namespace Illuminate\Foundation\Testing\Concerns;

use Illuminate\Contracts\Bus\Dispatcher as BusDispatcherContract;
use Illuminate\Contracts\Events\Dispatcher as EventsDispatcherContract;
use Illuminate\Contracts\Notifications\Dispatcher as NotificationDispatcher;
use Illuminate\Support\Facades\Event;
use Mockery;

/**
 * @deprecated Will be removed in a future Laravel version.
 */
trait MocksApplicationServices
{
    /**
     * All of the fired events.
     *
     * @var array
     */
    protected $firedEvents = [];

    /**
     * All of the fired model events.
     *
     * @var array
     */
    protected $firedModelEvents = [];

    /**
     * All of the dispatched jobs.
     *
     * @var array
     */
    protected $dispatchedJobs = [];

    /**
     * All of the dispatched notifications.
     *
     * @var array
     */
    protected $dispatchedNotifications = [];

    /**
     * Specify a list of events that should be fired for the given operation.
     *
     * These events will be mocked, so that handlers will not actually be executed.
     *
     * @param  array|string  $events
     * @return $this
     *
     * @throws \Exception
     */
    public function expectsEvents($events)
    {
        $events = is_array($events) ? $events : func_get_args();

        $this-&gt;withoutEvents();

        $this-&gt;beforeApplicationDestroyed(function () use ($events) {
            $fired = $this-&gt;getFiredEvents($events);

            $this-&gt;assertEmpty(
                $eventsNotFired = array_diff($events, $fired),
                'These expected events were not fired: ['.implode(', ', $eventsNotFired).']'
            );
        });

        return $this;
    }

    /**
     * Specify a list of events that should not be fired for the given operation.
     *
     * These events will be mocked, so that handlers will not actually be executed.
     *
     * @param  array|string  $events
     * @return $this
     */
    public function doesntExpectEvents($events)
    {
        $events = is_array($events) ? $events : func_get_args();

        $this-&gt;withoutEvents();

        $this-&gt;beforeApplicationDestroyed(function () use ($events) {
            $this-&gt;assertEmpty(
                $fired = $this-&gt;getFiredEvents($events),
                'These unexpected events were fired: ['.implode(', ', $fired).']'
            );
        });

        return $this;
    }

    /**
     * Mock the event dispatcher so all events are silenced and collected.
     *
     * @return $this
     */
    protected function withoutEvents()
    {
        $mock = Mockery::mock(EventsDispatcherContract::class)-&gt;shouldIgnoreMissing();

        $mock-&gt;shouldReceive('dispatch', 'until')-&gt;andReturnUsing(function ($called) {
            $this-&gt;firedEvents[] = $called;
        });

        Event::clearResolvedInstances();

        $this-&gt;app-&gt;instance('events', $mock);

        return $this;
    }

    /**
     * Filter the given events against the fired events.
     *
     * @param  array  $events
     * @return array
     */
    protected function getFiredEvents(array $events)
    {
        return $this-&gt;getDispatched($events, $this-&gt;firedEvents);
    }

    /**
     * Specify a list of jobs that should be dispatched for the given operation.
     *
     * These jobs will be mocked, so that handlers will not actually be executed.
     *
     * @param  array|string  $jobs
     * @return $this
     */
    protected function expectsJobs($jobs)
    {
        $jobs = is_array($jobs) ? $jobs : func_get_args();

        $this-&gt;withoutJobs();

        $this-&gt;beforeApplicationDestroyed(function () use ($jobs) {
            $dispatched = $this-&gt;getDispatchedJobs($jobs);

            $this-&gt;assertEmpty(
                $jobsNotDispatched = array_diff($jobs, $dispatched),
                'These expected jobs were not dispatched: ['.implode(', ', $jobsNotDispatched).']'
            );
        });

        return $this;
    }

    /**
     * Specify a list of jobs that should not be dispatched for the given operation.
     *
     * These jobs will be mocked, so that handlers will not actually be executed.
     *
     * @param  array|string  $jobs
     * @return $this
     */
    protected function doesntExpectJobs($jobs)
    {
        $jobs = is_array($jobs) ? $jobs : func_get_args();

        $this-&gt;withoutJobs();

        $this-&gt;beforeApplicationDestroyed(function () use ($jobs) {
            $this-&gt;assertEmpty(
                $dispatched = $this-&gt;getDispatchedJobs($jobs),
                'These unexpected jobs were dispatched: ['.implode(', ', $dispatched).']'
            );
        });

        return $this;
    }

    /**
     * Mock the job dispatcher so all jobs are silenced and collected.
     *
     * @return $this
     */
    protected function withoutJobs()
    {
        $mock = Mockery::mock(BusDispatcherContract::class)-&gt;shouldIgnoreMissing();

        $mock-&gt;shouldReceive('dispatch', 'dispatchNow')-&gt;andReturnUsing(function ($dispatched) {
            $this-&gt;dispatchedJobs[] = $dispatched;
        });

        $this-&gt;app-&gt;instance(
            BusDispatcherContract::class, $mock
        );

        return $this;
    }

    /**
     * Filter the given jobs against the dispatched jobs.
     *
     * @param  array  $jobs
     * @return array
     */
    protected function getDispatchedJobs(array $jobs)
    {
        return $this-&gt;getDispatched($jobs, $this-&gt;dispatchedJobs);
    }

    /**
     * Filter the given classes against an array of dispatched classes.
     *
     * @param  array  $classes
     * @param  array  $dispatched
     * @return array
     */
    protected function getDispatched(array $classes, array $dispatched)
    {
        return array_filter($classes, function ($class) use ($dispatched) {
            return $this-&gt;wasDispatched($class, $dispatched);
        });
    }

    /**
     * Check if the given class exists in an array of dispatched classes.
     *
     * @param  string  $needle
     * @param  array  $haystack
     * @return bool
     */
    protected function wasDispatched($needle, array $haystack)
    {
        foreach ($haystack as $dispatched) {
            if ((is_string($dispatched) &amp;&amp; ($dispatched === $needle || is_subclass_of($dispatched, $needle))) ||
                $dispatched instanceof $needle) {
                return true;
            }
        }

        return false;
    }

    /**
     * Mock the notification dispatcher so all notifications are silenced.
     *
     * @return $this
     */
    protected function withoutNotifications()
    {
        $mock = Mockery::mock(NotificationDispatcher::class);

        $mock-&gt;shouldReceive('send')-&gt;andReturnUsing(function ($notifiable, $instance, $channels = []) {
            $this-&gt;dispatchedNotifications[] = compact(
                'notifiable', 'instance', 'channels'
            );
        });

        $this-&gt;app-&gt;instance(NotificationDispatcher::class, $mock);

        return $this;
    }

    /**
     * Specify a notification that is expected to be dispatched.
     *
     * @param  mixed  $notifiable
     * @param  string  $notification
     * @return $this
     */
    protected function expectsNotification($notifiable, $notification)
    {
        $this-&gt;withoutNotifications();

        $this-&gt;beforeApplicationDestroyed(function () use ($notifiable, $notification) {
            foreach ($this-&gt;dispatchedNotifications as $dispatched) {
                $notified = $dispatched['notifiable'];

                if (($notified === $notifiable ||
                     $notified-&gt;getKey() == $notifiable-&gt;getKey()) &amp;&amp;
                    get_class($dispatched['instance']) === $notification
                ) {
                    return $this;
                }
            }

            $this-&gt;fail('The following expected notification were not dispatched: ['.$notification.']');
        });

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