[12.x] Add fakeFor and fakeExceptFor methods to Queue facade (#56149)

* feat: add fakeExcept and fakeFor methods to Queue facade

* feat: add QueueFakeTest with tests for fakeFor and fakeExcept methods

* feat: add SupportFacadesQueueTest with tests for Queue::fakeFor and Queue::fakeExcept methods

* refactor: simplify mock usage in QueueFakeTest and SupportFacadesQueueTest

* refactor: clean up spacing in SupportFacadesQueueTest

* refactor: move defineEnvironment method to QueueFakeTest class

Author: MrPunyapal

src/Illuminate/Support/Facades/Queue.php

@@ -96,6 +96,53 @@ public static function fake($jobsToFake = [])
         });
     }
 
+    /**
+     * Replace the bound instance with a fake that fakes all jobs except the given jobs.
+     *
+     * @param  string[]|string  $jobsToAllow
+     * @return \Illuminate\Support\Testing\Fakes\QueueFake
+     */
+    public static function fakeExcept($jobsToAllow)
+    {
+        return static::fake()->except($jobsToAllow);
+    }
+
+    /**
+     * Replace the bound instance with a fake during the given callable's execution.
+     *
+     * @param  callable  $callable
+     * @param  array  $jobsToFake
+     * @return mixed
+     */
+    public static function fakeFor(callable $callable, array $jobsToFake = [])
+    {
+        $originalQueueManager = static::getFacadeRoot();
+
+        static::fake($jobsToFake);
+
+        return tap($callable(), function () use ($originalQueueManager) {
+            static::swap($originalQueueManager);
+        });
+    }
+
+    /**
+     * Replace the bound instance with a fake during the given callable's execution.
+     *
+     * @param  callable  $callable
+     * @param  array  $jobsToAllow
+     * @return mixed
+     */
+    public static function fakeExceptFor(callable $callable, array $jobsToAllow = [])
+    {
+        $originalQueueManager = static::getFacadeRoot();
+
+        static::fakeExcept($jobsToAllow);
+
+        return tap($callable(), function () use ($originalQueueManager) {
+            static::swap($originalQueueManager);
+        });
+    }
+
     /**
      * Get the registered name of the component.
      *

tests/Integration/Queue/QueueFakeTest.php

@@ -0,0 +1,80 @@
+<?php
+
+namespace Illuminate\Tests\Integration\Queue;
+
+use Illuminate\Bus\Queueable;
+use Illuminate\Support\Facades\Queue;
+use Illuminate\Support\Testing\Fakes\QueueFake;
+use Orchestra\Testbench\TestCase;
+
+class QueueFakeTest extends TestCase
+{
+    protected function defineEnvironment($app)
+    {
+        $app['config']->set('queue.default', 'sync');
+    }
+
+    public function testFakeFor()
+    {
+        Queue::fakeFor(function () {
+            Queue::push(new TestJob);
+            Queue::assertPushed(TestJob::class);
+        });
+    }
+
+    public function testFakeExceptFor()
+    {
+        Queue::fakeExceptFor(function () {
+            Queue::push(new TestJob);
+            Queue::push(new OtherTestJob);
+
+            Queue::assertNotPushed(TestJob::class);
+            Queue::assertPushed(OtherTestJob::class);
+        }, [TestJob::class]);
+    }
+
+    public function testFakeExcept()
+    {
+        $fake = Queue::fakeExcept([TestJob::class]);
+
+        $this->assertInstanceOf(QueueFake::class, $fake);
+    }
+
+    public function testFakeForReturnValue()
+    {
+        $result = Queue::fakeFor(function () {
+            return 'test-value';
+        });
+
+        $this->assertEquals('test-value', $result);
+    }
+
+    public function testFakeExceptForReturnValue()
+    {
+        $result = Queue::fakeExceptFor(function () {
+            return 'test-value';
+        }, []);
+
+        $this->assertEquals('test-value', $result);
+    }
+}
+
+class TestJob
+{
+    use Queueable;
+
+    public function handle()
+    {
+        //
+    }
+}
+
+class OtherTestJob
+{
+    use Queueable;
+
+    public function handle()
+    {
+        //
+    }
+}

tests/Support/SupportFacadesQueueTest.php

@@ -0,0 +1,122 @@
+<?php
+
+namespace Illuminate\Tests\Support;
+
+use Illuminate\Bus\Queueable;
+use Illuminate\Container\Container;
+use Illuminate\Contracts\Queue\Factory as QueueContract;
+use Illuminate\Support\Facades\Facade;
+use Illuminate\Support\Facades\Queue;
+use Illuminate\Support\Testing\Fakes\QueueFake;
+use Mockery as m;
+use PHPUnit\Framework\TestCase;
+
+class SupportFacadesQueueTest extends TestCase
+{
+    private $queueManager;
+
+    protected function setUp(): void
+    {
+        parent::setUp();
+
+        $this->queueManager = m::mock(Factory::class);
+
+        $container = new Container;
+        $container->instance('queue', $this->queueManager);
+        $container->alias('queue', QueueContract::class);
+
+        Facade::setFacadeApplication($container);
+    }
+
+    protected function tearDown(): void
+    {
+        Queue::clearResolvedInstances();
+        Queue::setFacadeApplication(null);
+
+        m::close();
+    }
+
+    public function testFakeFor()
+    {
+        Queue::fakeFor(function () {
+            (new QueueForStub)->pushJob();
+
+            Queue::assertPushed(QueueJobStub::class);
+        });
+
+        $this->queueManager->shouldReceive('push')->once();
+
+        (new QueueForStub)->pushJob();
+    }
+
+    public function testFakeForSwapsQueueManager()
+    {
+        Queue::fakeFor(function () {
+            $this->assertInstanceOf(QueueFake::class, Queue::getFacadeRoot());
+        });
+
+        $this->assertSame($this->queueManager, Queue::getFacadeRoot());
+    }
+
+    public function testFakeExcept()
+    {
+        $fake = Queue::fakeExcept(QueueJobStub::class);
+
+        $this->assertInstanceOf(QueueFake::class, $fake);
+        $this->assertSame($fake, Queue::getFacadeRoot());
+    }
+
+    public function testFakeExceptFor()
+    {
+        Queue::fakeExceptFor(function () {
+            $this->assertInstanceOf(QueueFake::class, Queue::getFacadeRoot());
+        }, [QueueJobStub::class]);
+
+        $this->assertSame($this->queueManager, Queue::getFacadeRoot());
+    }
+
+    public function testFakeExceptForSwapsQueueManager()
+    {
+        Queue::fakeExceptFor(function () {
+            $this->assertInstanceOf(QueueFake::class, Queue::getFacadeRoot());
+        }, []);
+
+        $this->assertSame($this->queueManager, Queue::getFacadeRoot());
+    }
+
+    public function testFakeExceptForReturnValue()
+    {
+        $result = Queue::fakeExceptFor(function () {
+            return 'test-result';
+        });
+
+        $this->assertSame('test-result', $result);
+    }
+
+    public function testFakeForReturnValue()
+    {
+        $result = Queue::fakeFor(function () {
+            return 'test-result';
+        });
+
+        $this->assertSame('test-result', $result);
+    }
+}
+
+class QueueJobStub
+{
+    use Queueable;
+}
+
+class OtherQueueJobStub
+{
+    use Queueable;
+}
+
+class QueueForStub
+{
+    public function pushJob()
+    {
+        Queue::push(new QueueJobStub);
+    }
+}