504 lines
13 KiB
PHP
504 lines
13 KiB
PHP
<?php
|
|
|
|
namespace Illuminate\Support\Testing\Fakes;
|
|
|
|
use BadMethodCallException;
|
|
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 \Illuminate\Support\Collection
|
|
*/
|
|
protected $jobsToFake;
|
|
|
|
/**
|
|
* The job types that should be pushed to the queue and not intercepted.
|
|
*
|
|
* @var \Illuminate\Support\Collection
|
|
*/
|
|
protected $jobsToBeQueued;
|
|
|
|
/**
|
|
* 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->jobsToBeQueued = Collection::make();
|
|
$this->queue = $queue;
|
|
}
|
|
|
|
/**
|
|
* Specify the jobs that should be queued instead of faked.
|
|
*
|
|
* @param array|string $jobsToBeQueued
|
|
* @return $this
|
|
*/
|
|
public function except($jobsToBeQueued)
|
|
{
|
|
$this->jobsToBeQueued = Collection::wrap($jobsToBeQueued)->merge($this->jobsToBeQueued);
|
|
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* Assert if a job was pushed based on a truth-test callback.
|
|
*
|
|
* @param string|\Closure $job
|
|
* @param callable|int|null $callback
|
|
* @return void
|
|
*/
|
|
public function assertPushed($job, $callback = null)
|
|
{
|
|
if ($job instanceof Closure) {
|
|
[$job, $callback] = [$this->firstClosureParameterType($job), $job];
|
|
}
|
|
|
|
if (is_numeric($callback)) {
|
|
return $this->assertPushedTimes($job, $callback);
|
|
}
|
|
|
|
PHPUnit::assertTrue(
|
|
$this->pushed($job, $callback)->count() > 0,
|
|
"The expected [{$job}] job was not pushed."
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Assert if a job was pushed a number of times.
|
|
*
|
|
* @param string $job
|
|
* @param int $times
|
|
* @return void
|
|
*/
|
|
protected function assertPushedTimes($job, $times = 1)
|
|
{
|
|
$count = $this->pushed($job)->count();
|
|
|
|
PHPUnit::assertSame(
|
|
$times, $count,
|
|
"The expected [{$job}] job was pushed {$count} times instead of {$times} times."
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Assert if a job was pushed based on a truth-test callback.
|
|
*
|
|
* @param string $queue
|
|
* @param string|\Closure $job
|
|
* @param callable|null $callback
|
|
* @return void
|
|
*/
|
|
public function assertPushedOn($queue, $job, $callback = null)
|
|
{
|
|
if ($job instanceof Closure) {
|
|
[$job, $callback] = [$this->firstClosureParameterType($job), $job];
|
|
}
|
|
|
|
$this->assertPushed($job, function ($job, $pushedQueue) use ($callback, $queue) {
|
|
if ($pushedQueue !== $queue) {
|
|
return false;
|
|
}
|
|
|
|
return $callback ? $callback(...func_get_args()) : true;
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Assert if a job was pushed with chained jobs based on a truth-test callback.
|
|
*
|
|
* @param string $job
|
|
* @param array $expectedChain
|
|
* @param callable|null $callback
|
|
* @return void
|
|
*/
|
|
public function assertPushedWithChain($job, $expectedChain = [], $callback = null)
|
|
{
|
|
PHPUnit::assertTrue(
|
|
$this->pushed($job, $callback)->isNotEmpty(),
|
|
"The expected [{$job}] job was not pushed."
|
|
);
|
|
|
|
PHPUnit::assertTrue(
|
|
collect($expectedChain)->isNotEmpty(),
|
|
'The expected chain can not be empty.'
|
|
);
|
|
|
|
$this->isChainOfObjects($expectedChain)
|
|
? $this->assertPushedWithChainOfObjects($job, $expectedChain, $callback)
|
|
: $this->assertPushedWithChainOfClasses($job, $expectedChain, $callback);
|
|
}
|
|
|
|
/**
|
|
* Assert if a job was pushed with an empty chain based on a truth-test callback.
|
|
*
|
|
* @param string $job
|
|
* @param callable|null $callback
|
|
* @return void
|
|
*/
|
|
public function assertPushedWithoutChain($job, $callback = null)
|
|
{
|
|
PHPUnit::assertTrue(
|
|
$this->pushed($job, $callback)->isNotEmpty(),
|
|
"The expected [{$job}] job was not pushed."
|
|
);
|
|
|
|
$this->assertPushedWithChainOfClasses($job, [], $callback);
|
|
}
|
|
|
|
/**
|
|
* Assert if a job was pushed with chained jobs based on a truth-test callback.
|
|
*
|
|
* @param string $job
|
|
* @param array $expectedChain
|
|
* @param callable|null $callback
|
|
* @return void
|
|
*/
|
|
protected function assertPushedWithChainOfObjects($job, $expectedChain, $callback)
|
|
{
|
|
$chain = collect($expectedChain)->map(fn ($job) => serialize($job))->all();
|
|
|
|
PHPUnit::assertTrue(
|
|
$this->pushed($job, $callback)->filter(fn ($job) => $job->chained == $chain)->isNotEmpty(),
|
|
'The expected chain was not pushed.'
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Assert if a job was pushed with chained jobs based on a truth-test callback.
|
|
*
|
|
* @param string $job
|
|
* @param array $expectedChain
|
|
* @param callable|null $callback
|
|
* @return void
|
|
*/
|
|
protected function assertPushedWithChainOfClasses($job, $expectedChain, $callback)
|
|
{
|
|
$matching = $this->pushed($job, $callback)->map->chained->map(function ($chain) {
|
|
return collect($chain)->map(function ($job) {
|
|
return get_class(unserialize($job));
|
|
});
|
|
})->filter(function ($chain) use ($expectedChain) {
|
|
return $chain->all() === $expectedChain;
|
|
});
|
|
|
|
PHPUnit::assertTrue(
|
|
$matching->isNotEmpty(), 'The expected chain was not pushed.'
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Determine if the given chain is entirely composed of objects.
|
|
*
|
|
* @param array $chain
|
|
* @return bool
|
|
*/
|
|
protected function isChainOfObjects($chain)
|
|
{
|
|
return ! collect($chain)->contains(fn ($job) => ! is_object($job));
|
|
}
|
|
|
|
/**
|
|
* Determine if a job was pushed based on a truth-test callback.
|
|
*
|
|
* @param string|\Closure $job
|
|
* @param callable|null $callback
|
|
* @return void
|
|
*/
|
|
public function assertNotPushed($job, $callback = null)
|
|
{
|
|
if ($job instanceof Closure) {
|
|
[$job, $callback] = [$this->firstClosureParameterType($job), $job];
|
|
}
|
|
|
|
PHPUnit::assertCount(
|
|
0, $this->pushed($job, $callback),
|
|
"The unexpected [{$job}] job was pushed."
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Assert that no jobs were pushed.
|
|
*
|
|
* @return void
|
|
*/
|
|
public function assertNothingPushed()
|
|
{
|
|
PHPUnit::assertEmpty($this->jobs, 'Jobs were pushed unexpectedly.');
|
|
}
|
|
|
|
/**
|
|
* Get all of the jobs matching a truth-test callback.
|
|
*
|
|
* @param string $job
|
|
* @param callable|null $callback
|
|
* @return \Illuminate\Support\Collection
|
|
*/
|
|
public function pushed($job, $callback = null)
|
|
{
|
|
if (! $this->hasPushed($job)) {
|
|
return collect();
|
|
}
|
|
|
|
$callback = $callback ?: fn () => true;
|
|
|
|
return collect($this->jobs[$job])->filter(
|
|
fn ($data) => $callback($data['job'], $data['queue'], $data['data'])
|
|
)->pluck('job');
|
|
}
|
|
|
|
/**
|
|
* Determine if there are any stored jobs for a given class.
|
|
*
|
|
* @param string $job
|
|
* @return bool
|
|
*/
|
|
public function hasPushed($job)
|
|
{
|
|
return isset($this->jobs[$job]) && ! empty($this->jobs[$job]);
|
|
}
|
|
|
|
/**
|
|
* Resolve a queue connection instance.
|
|
*
|
|
* @param mixed $value
|
|
* @return \Illuminate\Contracts\Queue\Queue
|
|
*/
|
|
public function connection($value = null)
|
|
{
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* Get the size of the queue.
|
|
*
|
|
* @param string|null $queue
|
|
* @return int
|
|
*/
|
|
public function size($queue = null)
|
|
{
|
|
return collect($this->jobs)->flatten(1)->filter(
|
|
fn ($job) => $job['queue'] === $queue
|
|
)->count();
|
|
}
|
|
|
|
/**
|
|
* Push a new job onto the queue.
|
|
*
|
|
* @param string|object $job
|
|
* @param mixed $data
|
|
* @param string|null $queue
|
|
* @return mixed
|
|
*/
|
|
public function push($job, $data = '', $queue = null)
|
|
{
|
|
if ($this->shouldFakeJob($job)) {
|
|
$this->jobs[is_object($job) ? get_class($job) : $job][] = [
|
|
'job' => $job,
|
|
'queue' => $queue,
|
|
'data' => $data,
|
|
];
|
|
} 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->shouldDispatchJob($job)) {
|
|
return false;
|
|
}
|
|
|
|
if ($this->jobsToFake->isEmpty()) {
|
|
return true;
|
|
}
|
|
|
|
return $this->jobsToFake->contains(
|
|
fn ($jobToFake) => $job instanceof ((string) $jobToFake)
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Determine if a job should be pushed to the queue instead of faked.
|
|
*
|
|
* @param object $job
|
|
* @return bool
|
|
*/
|
|
protected function shouldDispatchJob($job)
|
|
{
|
|
if ($this->jobsToBeQueued->isEmpty()) {
|
|
return false;
|
|
}
|
|
|
|
return $this->jobsToBeQueued->contains(
|
|
fn ($jobToQueue) => $job instanceof ((string) $jobToQueue)
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Push a raw payload onto the queue.
|
|
*
|
|
* @param string $payload
|
|
* @param string|null $queue
|
|
* @param array $options
|
|
* @return mixed
|
|
*/
|
|
public function pushRaw($payload, $queue = null, array $options = [])
|
|
{
|
|
//
|
|
}
|
|
|
|
/**
|
|
* Push a new job onto the queue after (n) seconds.
|
|
*
|
|
* @param \DateTimeInterface|\DateInterval|int $delay
|
|
* @param string|object $job
|
|
* @param mixed $data
|
|
* @param string|null $queue
|
|
* @return mixed
|
|
*/
|
|
public function later($delay, $job, $data = '', $queue = null)
|
|
{
|
|
return $this->push($job, $data, $queue);
|
|
}
|
|
|
|
/**
|
|
* Push a new job onto the queue.
|
|
*
|
|
* @param string $queue
|
|
* @param string|object $job
|
|
* @param mixed $data
|
|
* @return mixed
|
|
*/
|
|
public function pushOn($queue, $job, $data = '')
|
|
{
|
|
return $this->push($job, $data, $queue);
|
|
}
|
|
|
|
/**
|
|
* Push a new job onto a specific queue after (n) seconds.
|
|
*
|
|
* @param string $queue
|
|
* @param \DateTimeInterface|\DateInterval|int $delay
|
|
* @param string|object $job
|
|
* @param mixed $data
|
|
* @return mixed
|
|
*/
|
|
public function laterOn($queue, $delay, $job, $data = '')
|
|
{
|
|
return $this->push($job, $data, $queue);
|
|
}
|
|
|
|
/**
|
|
* Pop the next job off of the queue.
|
|
*
|
|
* @param string|null $queue
|
|
* @return \Illuminate\Contracts\Queue\Job|null
|
|
*/
|
|
public function pop($queue = null)
|
|
{
|
|
//
|
|
}
|
|
|
|
/**
|
|
* Push an array of jobs onto the queue.
|
|
*
|
|
* @param array $jobs
|
|
* @param mixed $data
|
|
* @param string|null $queue
|
|
* @return mixed
|
|
*/
|
|
public function bulk($jobs, $data = '', $queue = null)
|
|
{
|
|
foreach ($jobs as $job) {
|
|
$this->push($job, $data, $queue);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Get the jobs that have been pushed.
|
|
*
|
|
* @return array
|
|
*/
|
|
public function pushedJobs()
|
|
{
|
|
return $this->jobs;
|
|
}
|
|
|
|
/**
|
|
* Get the connection name for the queue.
|
|
*
|
|
* @return string
|
|
*/
|
|
public function getConnectionName()
|
|
{
|
|
//
|
|
}
|
|
|
|
/**
|
|
* Set the connection name for the queue.
|
|
*
|
|
* @param string $name
|
|
* @return $this
|
|
*/
|
|
public function setConnectionName($name)
|
|
{
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* Override the QueueManager to prevent circular dependency.
|
|
*
|
|
* @param string $method
|
|
* @param array $parameters
|
|
* @return mixed
|
|
*
|
|
* @throws \BadMethodCallException
|
|
*/
|
|
public function __call($method, $parameters)
|
|
{
|
|
throw new BadMethodCallException(sprintf(
|
|
'Call to undefined method %s::%s()', static::class, $method
|
|
));
|
|
}
|
|
}
|