Add partial queue faking (#41425)

* add partial queue faking

* Apply fixes from StyleCI

Co-authored-by: StyleCI Bot <bot@styleci.io>

src/Illuminate/Support/Facades/Queue.php

@@ -42,11 +42,12 @@ public static function popUsing($workerName, $callback)
     /**
      * Replace the bound instance with a fake.
      *
+     * @param  array|string  $jobsToFake
      * @return \Illuminate\Support\Testing\Fakes\QueueFake
      */
-    public static function fake()
+    public static function fake($jobsToFake = [])
     {
-        static::swap($fake = new QueueFake(static::getFacadeApplication()));
+        static::swap($fake = new QueueFake(static::getFacadeApplication(), $jobsToFake, static::getFacadeRoot()));
 
         return $fake;
     }

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

@@ -6,20 +6,51 @@
 use Closure;
 use Illuminate\Contracts\Queue\Queue;
 use Illuminate\Queue\QueueManager;
+use Illuminate\Support\Collection;
 use Illuminate\Support\Traits\ReflectsClosures;
 use PHPUnit\Framework\Assert as PHPUnit;
 
 class QueueFake extends QueueManager implements Queue
 {
     use ReflectsClosures;
 
+    /**
+     * The original queue manager.
+     *
+     * @var \Illuminate\Contracts\Queue\Queue
+     */
+    protected $queue;
+
+    /**
+     * The job types that should be intercepted instead of pushed to the queue.
+     *
+     * @var array
+     */
+    protected $jobsToFake;
+
     /**
      * All of the jobs that have been pushed.
      *
      * @var array
      */
     protected $jobs = [];
 
+    /**
+     * Create a new fake queue instance.
+     *
+     * @param  \Illuminate\Contracts\Foundation\Application  $app
+     * @param  array  $jobsToFake
+     * @param  \Illuminate\Queue\QueueManager|null  $queue
+     * @return void
+     */
+    public function __construct($app, $jobsToFake = [], $queue = null)
+    {
+        parent::__construct($app);
+
+        $this->jobsToFake = Collection::wrap($jobsToFake);
+        $this->queue = $queue;
+    }
+
     /**
      * Assert if a job was pushed based on a truth-test callback.
      *
@@ -279,10 +310,33 @@ public function size($queue = null)
      */
     public function push($job, $data = '', $queue = null)
     {
-        $this->jobs[is_object($job) ? get_class($job) : $job][] = [
-            'job' => $job,
-            'queue' => $queue,
-        ];
+        if ($this->shouldFakeJob($job)) {
+            $this->jobs[is_object($job) ? get_class($job) : $job][] = [
+                'job' => $job,
+                'queue' => $queue,
+            ];
+        } else {
+            is_object($job) && isset($job->connection)
+                ? $this->queue->connection($job->connection)->push($job, $data, $queue)
+                : $this->queue->push($job, $data, $queue);
+        }
+    }
+
+    /**
+     * Determine if a job should be faked or actually dispatched.
+     *
+     * @param  object  $job
+     * @return bool
+     */
+    public function shouldFakeJob($job)
+    {
+        if ($this->jobsToFake->isEmpty()) {
+            return true;
+        }
+
+        return $this->jobsToFake->contains(function ($jobToFake) use ($job) {
+            return $job instanceof ((string) $jobToFake);
+        });
     }
 
     /**

tests/Support/SupportTestingQueueFakeTest.php

@@ -5,7 +5,9 @@
 use BadMethodCallException;
 use Illuminate\Bus\Queueable;
 use Illuminate\Foundation\Application;
+use Illuminate\Queue\QueueManager;
 use Illuminate\Support\Testing\Fakes\QueueFake;
+use Mockery as m;
 use PHPUnit\Framework\Constraint\ExceptionMessage;
 use PHPUnit\Framework\ExpectationFailedException;
 use PHPUnit\Framework\TestCase;
@@ -29,6 +31,13 @@ protected function setUp(): void
         $this->job = new JobStub;
     }
 
+    protected function tearDown(): void
+    {
+        parent::tearDown();
+
+        m::close();
+    }
+
     public function testAssertPushed()
     {
         try {
@@ -43,6 +52,24 @@ public function testAssertPushed()
         $this->fake->assertPushed(JobStub::class);
     }
 
+    public function testAssertPushedWithIgnore()
+    {
+        $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, JobToFakeStub::class, $manager);
+
+        $fake->push($job);
+        $fake->push(new JobToFakeStub());
+
+        $fake->assertNotPushed(JobStub::class);
+        $fake->assertPushed(JobToFakeStub::class);
+    }
+
     public function testAssertPushedWithClosure()
     {
         $this->fake->push($this->job);
@@ -297,6 +324,14 @@ public function handle()
     }
 }
 
+class JobToFakeStub
+{
+    public function handle()
+    {
+        //
+    }
+}
+
 class JobWithChainStub
 {
     use Queueable;