How do I test if some job is dispatched on "AfterImport"

[ozanhazer]

I have this import:

class SubscribersImport implements ShouldQueue, OnEachRow, WithChunkReading, WithEvents
{
    use Importable, RegistersEventListeners;

    ...

    public static function afterImport(AfterImport $event)
    {
        $import = $event->getConcernable()->import;
        UpdateSubscriberStats::dispatch($import->list);
    }
}

and I want to test that the UpdateSubscriberStats is dispatched after the import is completed.
I cannot do that since Queue::fake() also prevents SubscribersImport from dispatching, so any ideas on how to do that?

[patrickbrouwers]

You could make a test excel file and just call the entire import. Then assert that UpdateSubscriberStats is dispatched.

[ozanhazer]

I already do that but when I use Queue::fake() it doesn't matter if the queue driver is sync or not, because, you know, we fake it :)
And faking is the only way to test the queues as far as I know.

The test case I'm talking about is something like this:

    /**
     * @test
     */
    public function subscriber_stats_are_updated_on_import()
    {
        Queue::fake();

        $path = '/some/path/here';
        copy(base_path('/tests/stubs/import/comma.csv'), $path);
        // It would work if there were a way to skip the queue here
        (new SubscribersImport())->import($path);

        Queue::assertPushed(UpdateSubscriberStats::class);
    }

I think I'll have to check the behavior of the UpdateSubscriberStats, not the ideal solution but better than leaving it untested...

[patrickbrouwers]

I misread your initial message, I thought you meant Excel::fake()

Like this should work I think:

Queue::fake([
   UpdateSubscriberStats::class
]);

Rest should be executed in sync

[ozanhazer]

Hmm, strangely enough, I also remembered the exact same thing and that was the first thing I tried but it's not working either. See the source code for Queue::fake(), no arguments there. Maybe it was removed 🤷🏻‍♂️

    /**
     * Replace the bound instance with a fake.
     *
     * @return \Illuminate\Support\Testing\Fakes\QueueFake
     */
    public static function fake()
    {
        static::swap($fake = new QueueFake(static::getFacadeApplication()));

        return $fake;
    }

by the way, for the records I just found a way:

    /**
     * @test
     */
    public function subscriber_stats_are_updated_on_import()
    {
        // We cannot use `Queue::fake()` because the `UpdateSubscriberStats` job is queued
        // inside the event listener on the `SubscribersImport` class and the event
        // won't be dispatched if the queue is faked. So we'll collect all the jobs
        // processed and use that list to assert that the job we want is dispatched.
        $processedJobs = [];
        Queue::before(function (JobProcessing $event) use (&$processedJobs) {
            $processedJobs[] = $event->job->payload()['displayName'];
        });

        $path = '/some/path/here';
        copy(base_path('/tests/stubs/import/comma.csv'), $path);
        (new SubscribersImport())->import($path);

        $this->assertContains(UpdateSubscriberStats::class, $processedJobs);
    }

[patrickbrouwers]

Hm weird indeed, maybe it was another fake that had that functionality, but I have a vague memory of using it.

An alternative could be that you test that the subscriber stats are actually updated (db assertions?)

[ozanhazer]

Yeah could be and actually that's what I did before coming up with this, the problem with that is there are a lot of stats with some logic there so I just checked the most obvious stat... Since the other job is well tested it should be fairly enough. It's nice to have a test that asserts the correct job is dispatched anyways...