[9.x] Adds partial queue faking

src/Illuminate/Bus/BusServiceProvider.php

@@ -18,8 +18,8 @@ class BusServiceProvider extends ServiceProvider implements DeferrableProvider
     public function register()
     {
         $this->app->singleton(Dispatcher::class, function ($app) {
-            return new Dispatcher($app, function ($connection = null) use ($app) {
-                return $app[QueueFactoryContract::class]->connection($connection);
+            return new Dispatcher($app, function ($connection = null, $job = null) use ($app) {
+                return $app[QueueFactoryContract::class]->connection($connection, $job);
             });
         });
 

src/Illuminate/Bus/Dispatcher.php

@@ -216,7 +216,7 @@ public function dispatchToQueue($command)
     {
         $connection = $command->connection ?? null;
 
-        $queue = call_user_func($this->queueResolver, $connection);
+        $queue = call_user_func($this->queueResolver, $connection, $command);
 
         if (! $queue instanceof Queue) {
             throw new RuntimeException('Queue resolver did not return a Queue implementation.');

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,52 @@
 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\Queue\QueueManager|null
+     */
+    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.
      *
@@ -248,12 +280,16 @@ public function hasPushed($job)
     /**
      * Resolve a queue connection instance.
      *
-     * @param  mixed  $value
+     * @param  string|null  $name
      * @return \Illuminate\Contracts\Queue\Queue
      */
-    public function connection($value = null)
+    public function connection($name = null, $job = null)
     {
-        return $this;
+        if ($this->shouldFakeJob($job)) {
+            return $this;
+        }
+
+        return $this->queue->connection($name);
     }
 
     /**
@@ -275,7 +311,7 @@ public function size($queue = null)
      * @param  string|object  $job
      * @param  mixed  $data
      * @param  string|null  $queue
-     * @return mixed
+     * @return void
      */
     public function push($job, $data = '', $queue = null)
     {
@@ -375,6 +411,27 @@ public function pushedJobs()
         return $this->jobs;
     }
 
+    /**
+     * 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;
+        }
+
+        if (is_null($this->queue)) {
+            return true;
+        }
+
+        return $this->jobsToFake->contains(function ($jobToFake) use ($job) {
+            return get_class($job) === $jobToFake;
+        });
+    }
+
     /**
      * Get the connection name for the queue.
      *

tests/Support/SupportTestingQueueFakeTest.php

@@ -5,7 +5,11 @@
 use BadMethodCallException;
 use Illuminate\Bus\Queueable;
 use Illuminate\Foundation\Application;
+use Illuminate\Queue\DatabaseQueue;
+use Illuminate\Queue\QueueManager;
+use Illuminate\Queue\SyncQueue;
 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 +33,12 @@ protected function setUp(): void
         $this->job = new JobStub;
     }
 
+    protected function tearDown(): void
+    {
+        parent::tearDown();
+        m::close();
+    }
+
     public function testAssertPushed()
     {
         try {
@@ -52,6 +62,31 @@ public function testAssertPushedWithClosure()
         });
     }
 
+    public function testConnectionWithFakedJobs()
+    {
+        $manager = m::mock(QueueManager::class);
+        $manager->shouldReceive('connection')->once()->andReturn(new SyncQueue);
+
+        $fake = new QueueFake(new Application, JobToFakeStub::class, $manager);
+
+        $this->assertInstanceOf(SyncQueue::class, $fake->connection(null, new JobStub));
+        $this->assertInstanceOf(QueueFake::class, $fake->connection(null, new JobToFakeStub));
+    }
+
+    public function testConnectionWithFakedJobsAndCustomConnection()
+    {
+        $manager = m::mock(QueueManager::class);
+        $manager->shouldReceive('connection')
+            ->once()
+            ->with('database')
+            ->andReturn(m::mock(DatabaseQueue::class));
+
+        $fake = new QueueFake(new Application, JobToFakeStub::class, $manager);
+
+        $this->assertInstanceOf(DatabaseQueue::class, $fake->connection('database', new JobStub));
+        $this->assertInstanceOf(QueueFake::class, $fake->connection(null, new JobToFakeStub));
+    }
+
     public function testQueueSize()
     {
         $this->assertEquals(0, $this->fake->size());
@@ -297,6 +332,14 @@ public function handle()
     }
 }
 
+class JobToFakeStub
+{
+    public function handle()
+    {
+        //
+    }
+}
+
 class JobWithChainStub
 {
     use Queueable;