[9.x] Implement except method for fake classes to define what should not be faked

src/Illuminate/Support/Testing/Fakes/EventFake.php

@@ -26,7 +26,14 @@ class EventFake implements Dispatcher
      *
      * @var array
      */
-    protected $eventsToFake;
+    protected $eventsToFake = [];
+
+    /**
+     * The event types that should be dispatched instead of intercepted.
+     *
+     * @var array
+     */
+    protected $eventsToDispatch = [];
 
     /**
      * All of the events that have been intercepted keyed by type.
@@ -49,6 +56,22 @@ public function __construct(Dispatcher $dispatcher, $eventsToFake = [])
         $this->eventsToFake = Arr::wrap($eventsToFake);
     }
 
+    /**
+     * Specify the events that should be dispatched instead of faked.
+     *
+     * @param  array|string  $eventsToDispatch
+     * @return $this
+     */
+    public function except($eventsToDispatch)
+    {
+        $this->eventsToDispatch = array_merge(
+            $this->eventsToDispatch,
+            Arr::wrap($eventsToDispatch)
+        );
+
+        return $this;
+    }
+
     /**
      * Assert if an event has a listener attached to it.
      *
@@ -283,6 +306,10 @@ public function dispatch($event, $payload = [], $halt = false)
      */
     protected function shouldFakeEvent($eventName, $payload)
     {
+        if ($this->shouldDispatchEvent($eventName, $payload)) {
+            return false;
+        }
+
         if (empty($this->eventsToFake)) {
             return true;
         }
@@ -296,6 +323,28 @@ protected function shouldFakeEvent($eventName, $payload)
             ->isNotEmpty();
     }
 
+    /**
+     * Determine whether an event should be dispatched or not.
+     *
+     * @param  string  $eventName
+     * @param  mixed  $payload
+     * @return bool
+     */
+    protected function shouldDispatchEvent($eventName, $payload)
+    {
+        if (empty($this->eventsToDispatch)) {
+            return false;
+        }
+
+        return collect($this->eventsToDispatch)
+            ->filter(function ($event) use ($eventName, $payload) {
+                return $event instanceof Closure
+                    ? $event($eventName, $payload)
+                    : $event === $eventName;
+            })
+            ->isNotEmpty();
+    }
+
     /**
      * Remove a set of listeners from the dispatcher.
      *

src/Illuminate/Support/Testing/Fakes/QueueFake.php

@@ -24,10 +24,17 @@ class QueueFake extends QueueManager implements Queue
     /**
      * The job types that should be intercepted instead of pushed to the queue.
      *
-     * @var array
+     * @var \Illuminate\Support\Collection
      */
     protected $jobsToFake;
 
+    /**
+     * The job types that should be pushed to the queue and not intercepted.
+     *
+     * @var \Illuminate\Support\Collection
+     */
+    protected $jobsToBeQueued;
+
     /**
      * All of the jobs that have been pushed.
      *
@@ -48,9 +55,23 @@ public function __construct($app, $jobsToFake = [], $queue = null)
         parent::__construct($app);
 
         $this->jobsToFake = Collection::wrap($jobsToFake);
+        $this->jobsToBeQueued = Collection::make();
         $this->queue = $queue;
     }
 
+    /**
+     * Specify the jobs that should be queued instead of faked.
+     *
+     * @param  array|string  $jobsToBeQueued
+     * @return $this
+     */
+    public function except($jobsToBeQueued)
+    {
+        $this->jobsToBeQueued = Collection::wrap($jobsToBeQueued)->merge($this->jobsToBeQueued);
+
+        return $this;
+    }
+
     /**
      * Assert if a job was pushed based on a truth-test callback.
      *
@@ -323,6 +344,10 @@ public function push($job, $data = '', $queue = null)
      */
     public function shouldFakeJob($job)
     {
+        if ($this->shouldDispatchJob($job)) {
+            return false;
+        }
+
         if ($this->jobsToFake->isEmpty()) {
             return true;
         }
@@ -332,6 +357,23 @@ public function shouldFakeJob($job)
         );
     }
 
+    /**
+     * Determine if a job should be pushed to the queue instead of faked.
+     *
+     * @param  object  $job
+     * @return bool
+     */
+    protected function shouldDispatchJob($job)
+    {
+        if ($this->jobsToBeQueued->isEmpty()) {
+            return false;
+        }
+
+        return $this->jobsToBeQueued->contains(
+            fn ($jobToQueue) => $job instanceof ((string) $jobToQueue)
+        );
+    }
+
     /**
      * Push a raw payload onto the queue.
      *

tests/Integration/Events/EventFakeTest.php

@@ -121,6 +121,22 @@ public function testFakeExceptAllowsGivenEventsToBeDispatched()
         Event::assertNotDispatched('non-fake-event');
     }
 
+    public function testEventsListedInExceptAreProperlyDispatched()
+    {
+        Event::fake()->except('important-event');
+
+        Event::listen('test', function () {
+            return 'test';
+        });
+
+        Event::listen('important-event', function () {
+            return 'important';
+        });
+
+        $this->assertEquals(null, Event::dispatch('test'));
+        $this->assertEquals(['important'], Event::dispatch('important-event'));
+    }
+
     public function testAssertListening()
     {
         Event::fake();

tests/Support/SupportTestingQueueFakeTest.php

@@ -328,6 +328,24 @@ public function testCallUndefinedMethodErrorHandling()
             )));
         }
     }
+
+    public function testItDoesntFakeJobsPassedViaExcept()
+    {
+        $job = new JobStub;
+
+        $manager = m::mock(QueueManager::class);
+        $manager->shouldReceive('push')->once()->withArgs(function ($passedJob) use ($job) {
+            return $passedJob === $job;
+        });
+
+        $fake = (new QueueFake(new Application, [], $manager))->except(JobStub::class);
+
+        $fake->push($job);
+        $fake->push(new JobToFakeStub());
+
+        $fake->assertNotPushed(JobStub::class);
+        $fake->assertPushed(JobToFakeStub::class);
+    }
 }
 
 class JobStub