<?php

namespace Illuminate\Tests\Support;

use Illuminate\Contracts\Bus\Dispatcher;

use Illuminate\Support\Testing\Fakes\BusFake;

use Mockery as m;

use PHPUnit\Framework\Constraint\ExceptionMessage;

use PHPUnit\Framework\ExpectationFailedException;

use PHPUnit\Framework\TestCase;

class SupportTestingBusFakeTest extends TestCase

{

/** @var \Illuminate\Support\Testing\Fakes\BusFake */

protected $fake;

protected function setUp(): void

{

parent::setUp();

$this->fake = new BusFake(m::mock(Dispatcher::class));

}

protected function tearDown(): void

{

parent::tearDown();

m::close();

}

public function testAssertDispatched()

{

try {

$this->fake->assertDispatched(BusJobStub::class);

$this->fail();

} catch (ExpectationFailedException $e) {

$this->assertThat($e, new ExceptionMessage('The expected [Illuminate\Tests\Support\BusJobStub] job was not dispatched.'));

}

$this->fake->dispatch(new BusJobStub);

$this->fake->assertDispatched(BusJobStub::class);

}

public function testAssertDispatchedNow()

{

$this->fake->dispatchNow(new BusJobStub);

$this->fake->assertDispatched(BusJobStub::class);

}

public function testAssertDispatchedWithCallbackInt()

{

$this->fake->dispatch(new BusJobStub);

$this->fake->dispatchNow(new BusJobStub);

try {

$this->fake->assertDispatched(BusJobStub::class, 1);

$this->fail();

} catch (ExpectationFailedException $e) {

$this->assertThat($e, new ExceptionMessage('The expected [Illuminate\Tests\Support\BusJobStub] job was pushed 2 times instead of 1 times.'));

}

$this->fake->assertDispatched(BusJobStub::class, 2);

}

public function testAssertDispatchedWithCallbackFunction()

{

$this->fake->dispatch(new OtherBusJobStub);

$this->fake->dispatchNow(new OtherBusJobStub(1));

try {

$this->fake->assertDispatched(OtherBusJobStub::class, function ($job) {

return $job->id === 0;

});

$this->fail();

} catch (ExpectationFailedException $e) {

$this->assertThat($e, new ExceptionMessage('The expected [Illuminate\Tests\Support\OtherBusJobStub] job was not dispatched.'));

}

$this->fake->assertDispatched(OtherBusJobStub::class, function ($job) {

return $job->id === null;

});

$this->fake->assertDispatched(OtherBusJobStub::class, function ($job) {

return $job->id === 1;

});

}

public function testAssertDispatchedTimes()

{

$this->fake->dispatch(new BusJobStub);

$this->fake->dispatchNow(new BusJobStub);

try {

$this->fake->assertDispatchedTimes(BusJobStub::class, 1);

$this->fail();

} catch (ExpectationFailedException $e) {

$this->assertThat($e, new ExceptionMessage('The expected [Illuminate\Tests\Support\BusJobStub] job was pushed 2 times instead of 1 times.'));

}

$this->fake->assertDispatchedTimes(BusJobStub::class, 2);

}

public function testAssertNotDispatched()

{

$this->fake->assertNotDispatched(BusJobStub::class);

$this->fake->dispatch(new BusJobStub);

$this->fake->dispatchNow(new BusJobStub);

try {

$this->fake->assertNotDispatched(BusJobStub::class);

$this->fail();

} catch (ExpectationFailedException $e) {

$this->assertThat($e, new ExceptionMessage('The unexpected [Illuminate\Tests\Support\BusJobStub] job was dispatched.'));

}

}

public function testAssertDispatchedWithIgnoreClass()

{

$dispatcher = m::mock(Dispatcher::class);

$job = new BusJobStub;

$dispatcher->shouldReceive('dispatch')->once()->with($job);

$dispatcher->shouldReceive('dispatchNow')->once()->with($job, null);

$otherJob = new OtherBusJobStub;

$dispatcher->shouldReceive('dispatch')->never()->with($otherJob);

$dispatcher->shouldReceive('dispatchNow')->never()->with($otherJob, null);

$fake = new BusFake($dispatcher, OtherBusJobStub::class);

$fake->dispatch($job);

$fake->dispatchNow($job);

$fake->dispatch($otherJob);

$fake->dispatchNow($otherJob);

$fake->assertNotDispatched(BusJobStub::class);

$fake->assertDispatchedTimes(OtherBusJobStub::class, 2);

}

public function testAssertDispatchedWithIgnoreCallback()

{

$dispatcher = m::mock(Dispatcher::class);

$job = new BusJobStub;

$dispatcher->shouldReceive('dispatch')->once()->with($job);

$dispatcher->shouldReceive('dispatchNow')->once()->with($job, null);

$otherJob = new OtherBusJobStub;

$dispatcher->shouldReceive('dispatch')->once()->with($otherJob);

$dispatcher->shouldReceive('dispatchNow')->once()->with($otherJob, null);

$anotherJob = new OtherBusJobStub(1);

$dispatcher->shouldReceive('dispatch')->never()->with($anotherJob);

$dispatcher->shouldReceive('dispatchNow')->never()->with($anotherJob, null);

$fake = new BusFake($dispatcher, [

function ($command) {

return $command instanceof OtherBusJobStub && $command->id === 1;

},

]);

$fake->dispatch($job);

$fake->dispatchNow($job);

$fake->dispatch($otherJob);

$fake->dispatchNow($otherJob);

$fake->dispatch($anotherJob);

$fake->dispatchNow($anotherJob);

$fake->assertNotDispatched(BusJobStub::class);

$fake->assertDispatchedTimes(OtherBusJobStub::class, 2);

$fake->assertNotDispatched(OtherBusJobStub::class, function ($job) {

return $job->id === null;

});

$fake->assertDispatched(OtherBusJobStub::class, function ($job) {

return $job->id === 1;

});

}

}

class BusJobStub

{

//

}

class OtherBusJobStub

{

public $id;

public function __construct($id = null)

{

$this->id = $id;

}

}