{

public $events;

public $exceptionHandler;

public $maintenanceFlags;

protected function setUp(): void

{

$this->events = new EventFake(new EventsDispatcher);

Container::setInstance($container = new Container);

$this->exceptionHandler = new ExceptionHandlerFake(new Handler($container));

$container->instance(Dispatcher::class, $this->events);

$container->instance(ExceptionHandler::class, $this->exceptionHandler);

}

protected function tearDown(): void

{

Container::setInstance();

}

public function testJobCanBeFired()

{

$worker = $this->getWorker('default', ['queue' => [$job = new WorkerFakeJob]]);

$worker->runNextJob('default', 'queue', new WorkerOptions);

$this->assertTrue($job->fired);

$this->events->assertDispatchedOnce(JobPopping::class);

$this->events->assertDispatchedOnce(JobPopped::class);

$this->events->assertDispatchedOnce(JobProcessing::class);

$this->events->assertDispatchedOnce(JobProcessed::class);

$this->events->assertDispatched(fn (JobProcessed $event) => is_float($event->duration));

}

public function testJobPoppingEvent()

{

$worker = $this->getWorker('default', ['queue' => [$job = new WorkerFakeJob]]);

$worker->runNextJob('default', 'queue', new WorkerOptions);

$this->assertTrue($job->fired);

$this->events->assertDispatchedOnce(JobPopping::class);

$this->events->assertDispatched(JobPopping::class, function ($event) {

return $event->connectionName === 'default'

&& $event->queue === 'queue';

});

}

public function testWorkerCanWorkUntilQueueIsEmpty()

{

$workerOptions = new WorkerOptions;

$workerOptions->stopWhenEmpty = true;

$worker = $this->getWorker('default', ['queue' => [

$firstJob = new WorkerFakeJob,

$secondJob = new WorkerFakeJob,

]]);

$status = $worker->daemon('default', 'queue', $workerOptions);

$this->assertTrue($secondJob->fired);

$this->assertSame(0, $status);

$this->events->assertDispatchedTimes(JobProcessing::class, 2);

$this->events->assertDispatchedTimes(JobProcessed::class, 2);

}

public function testWorkerStopsWhenQueueIsEmptyForConfiguredSeconds()

{

$workerOptions = new WorkerOptions();

$workerOptions->stopWhenEmptyFor = 5;

$worker = $this->getWorker('default', ['queue' => []]);

$worker->currentTime = 0;

$status = $worker->daemon('default', 'queue', $workerOptions);

$this->assertSame(0, $status);

$this->events->assertDispatchedTimes(WorkerIdle::class, 2);

$this->events->assertDispatched(WorkerStopping::class, function ($event) use ($workerOptions) {

return $event->status === 0

&& $event->workerOptions === $workerOptions

&& $event->reason === WorkerStopReason::QueueEmptyFor;

});

}

public function testWorkerResetsQueueEmptyTimerAfterProcessingJob()

{

$workerOptions = new WorkerOptions();

$workerOptions->stopWhenEmptyFor = 5;

$worker = $this->getWorker('default', ['queue' => [

$job = new WorkerFakeJob(function () use (&$worker) {

$worker->currentTime = 10;

}),

]]);

$worker->currentTime = 0;

$status = $worker->daemon('default', 'queue', $workerOptions);

$this->assertTrue($job->fired);

$this->assertSame(0, $status);

$this->assertSame(16, $worker->currentTime);

$this->events->assertDispatchedTimes(WorkerIdle::class, 2);

$this->events->assertDispatched(WorkerStopping::class, function ($event) use ($workerOptions) {

return $event->status === 0

&& $event->workerOptions === $workerOptions

&& $event->reason === WorkerStopReason::QueueEmptyFor;

});

}

public function testWorkerStopsWhenMemoryExceeded()

{

$workerOptions = new WorkerOptions;

$worker = $this->getWorker('default', ['queue' => [

$firstJob = new WorkerFakeJob,

$secondJob = new WorkerFakeJob,

]]);

$worker->stopOnMemoryExceeded = true;

$status = $worker->daemon('default', 'queue', $workerOptions);

$this->assertTrue($firstJob->fired);

$this->assertFalse($secondJob->fired);

$this->assertSame(12, $status);

$this->events->assertDispatchedOnce(JobProcessing::class);

$this->events->assertDispatchedOnce(JobProcessed::class);

}

public function testWorkerMemoryExceededWhenMemoryIsZero()

{

$worker = new Worker(...$this->workerDependencies());

$this->assertFalse($worker->memoryExceeded(0));

}

public function testWorkerMemoryExceededWhenMemoryGreaterThanZero()

{

$worker = new Worker(...$this->workerDependencies());

$this->assertTrue($worker->memoryExceeded(1));

}

public function testWorkerMemoryExceededWhenMemoryIsNegative()

{

$worker = new Worker(...$this->workerDependencies());

$this->assertFalse($worker->memoryExceeded(-1));

}

public function testWorkerMemoryExceededWhenMemoryIsAPercentage()

{

$worker = new class(...$this->workerDependencies()) extends Worker

{

protected function currentMemoryUsage()

{

return 512;

}

};

$original = ini_set('memory_limit', '1G');

try {

$this->assertTrue($worker->memoryExceeded('50%'));

$this->assertFalse($worker->memoryExceeded('51%'));

} finally {

ini_set('memory_limit', $original);

}

}

public function testJobCanBeFiredBasedOnPriority()

{

$worker = $this->getWorker('default', [

'high' => [$highJob = new WorkerFakeJob, $secondHighJob = new WorkerFakeJob], 'low' => [$lowJob = new WorkerFakeJob],

]);

$worker->runNextJob('default', 'high,low', new WorkerOptions);

$this->assertTrue($highJob->fired);

$this->assertFalse($secondHighJob->fired);

$this->assertFalse($lowJob->fired);

$worker->runNextJob('default', 'high,low', new WorkerOptions);

$this->assertTrue($secondHighJob->fired);

$this->assertFalse($lowJob->fired);

$worker->runNextJob('default', 'high,low', new WorkerOptions);

$this->assertTrue($lowJob->fired);

}

public function testExceptionIsReportedIfConnectionThrowsExceptionOnJobPop()

{

$worker = new InsomniacWorker(

new WorkerFakeManager('default', new BrokenQueueConnection('default', $e = new RuntimeException)),

$this->events,

$this->exceptionHandler,

function () {

return false;

}

);

$worker->runNextJob('default', 'queue', $this->workerOptions());

$this->exceptionHandler->assertReported(fn (RuntimeException $reported) => $reported === $e);

}

public function testWorkerSleepsWhenQueueIsEmpty()

{

$worker = $this->getWorker('default', ['queue' => []]);

$worker->runNextJob('default', 'queue', $this->workerOptions(['sleep' => 5]));

$this->assertEquals(5, $worker->sleptFor);

}

public function testJobIsReleasedOnException()

{

$e = new RuntimeException;

$job = new WorkerFakeJob(function () use ($e) {

throw $e;

});

$worker = $this->getWorker('default', ['queue' => [$job]]);

$worker->runNextJob('default', 'queue', $this->workerOptions(['backoff' => 10]));

$this->assertEquals(10, $job->releaseAfter);

$this->assertFalse($job->deleted);

$this->exceptionHandler->assertReported(fn (RuntimeException $reported) => $reported === $e);

$this->events->assertDispatchedOnce(JobExceptionOccurred::class);

$this->events->assertNotDispatched(JobProcessed::class);

}

public function testJobAttemptedEventIsDispatched()

{

$e = new RuntimeException;

$job = new WorkerFakeJob(function () use ($e) {

throw $e;

});

$worker = $this->getWorker('default', ['queue' => [$job]]);

$worker->runNextJob('default', 'queue', $this->workerOptions());

$this->events->assertDispatchedOnce(JobAttempted::class);

$this->events->assertDispatched(JobAttempted::class, function ($event) use ($job, $e) {

return $event->connectionName === 'default'

&& $event->job === $job

&& $event->exception === $e

&& ! $event->successful()

&& is_float($event->duration);

});

}

public function testJobIsFailedIfExceptionHandlerSaysItShouldntRetry()

{

$e = new RuntimeException;

$job = new WorkerFakeJob(function () use ($e) {

throw $e;

});

$worker = new InsomniacWorker(

new WorkerFakeManager('default', new WorkerFakeConnection('default', ['queue' => [$job]])),

$this->events,

new ShouldntRetryExceptionHandler,

function () {

return false;

},

);

$worker->runNextJob('default', 'queue', $this->workerOptions(['backoff' => 10]));

$this->assertNull($job->releaseAfter);

$this->assertTrue($job->deleted);

$this->assertEquals($e, $job->failedWith);

$this->events->assertNotDispatched(JobReleasedAfterException::class);

}

public function testExceptionIsNotReportedIfReportJobExceptionsIsDisabled()

{

$e = new RuntimeException;

$job = new WorkerFakeJob(function () use ($e) {

throw $e;

});

Worker::$reportJobExceptions = false;

try {

$worker = $this->getWorker('default', ['queue' => [$job]]);

$worker->runNextJob('default', 'queue', $this->workerOptions(['backoff' => 10]));

$this->exceptionHandler->assertNothingReported();

$this->events->assertDispatchedOnce(JobExceptionOccurred::class);

} finally {

Worker::$reportJobExceptions = true;

}

}

public function testJobIsNotReleasedIfItHasExceededMaxAttempts()

{

$e = new RuntimeException;

$job = new WorkerFakeJob(function ($job) use ($e) {

// In normal use this would be incremented by being popped off the queue

$job->attempts++;

throw $e;

});

$job->attempts = 1;

$worker = $this->getWorker('default', ['queue' => [$job]]);

$worker->runNextJob('default', 'queue', $this->workerOptions(['maxTries' => 1]));

$this->assertNull($job->releaseAfter);

$this->assertTrue($job->deleted);

$this->assertEquals($e, $job->failedWith);

$this->exceptionHandler->assertReported(fn (RuntimeException $reported) => $reported === $e);

$this->events->assertDispatchedOnce(JobExceptionOccurred::class);

$this->events->assertNotDispatched(JobProcessed::class);

}

public function testJobIsNotReleasedIfItHasExpired()

{

Carbon::setTestNow($now = Carbon::create(2026, 1, 1, 0, 0, 0));

$e = new RuntimeException;

$job = new WorkerFakeJob(function ($job) use ($e) {

// In normal use this would be incremented by being popped off the queue

$job->attempts++;

throw $e;

});

$job->retryUntil = $now->copy()->addSecond()->getTimestamp();

$job->attempts = 0;

Carbon::setTestNow($now->copy()->addSecond());

$worker = $this->getWorker('default', ['queue' => [$job]]);

$worker->runNextJob('default', 'queue', $this->workerOptions());

$this->assertNull($job->releaseAfter);

$this->assertTrue($job->deleted);

$this->assertEquals($e, $job->failedWith);

$this->exceptionHandler->assertReported(fn (RuntimeException $reported) => $reported === $e);

$this->events->assertDispatchedOnce(JobExceptionOccurred::class);

$this->events->assertNotDispatched(JobProcessed::class);

}

public function testJobIsFailedIfItHasAlreadyExceededMaxAttempts()

{

$job = new WorkerFakeJob(function ($job) {

$job->attempts++;

});

$job->attempts = 2;

$worker = $this->getWorker('default', ['queue' => [$job]]);

$worker->runNextJob('default', 'queue', $this->workerOptions(['maxTries' => 1]));

$this->assertNull($job->releaseAfter);

$this->assertTrue($job->deleted);

$this->assertInstanceOf(MaxAttemptsExceededException::class, $job->failedWith);

$this->exceptionHandler->assertReported(MaxAttemptsExceededException::class);

$this->events->assertDispatchedOnce(JobExceptionOccurred::class);

$this->events->assertNotDispatched(JobProcessed::class);

}

public function testCrashesAreNotCountedUnlessTheJobCountsCrashesAsExceptions()

{

$worker = $this->getWorker();

$worker->setCache($cache = new Repository(new ArrayStore));

$job = new WorkerFakeJob;

$job->uuid = 'uuid';

$job->maxExceptions = 1;

$cache->put('job-processing:uuid', true);

$worker->process('default', $job, $this->workerOptions());

$this->assertTrue($job->fired);

$this->assertFalse($job->hasFailed());

$this->assertNull($cache->get('job-exceptions:uuid'));

}

public function testJobIsFailedIfTheWorkerDiedWhileProcessingItAndItHasExceededMaxExceptions()

{

$worker = $this->getWorker();

$worker->setCache($cache = new Repository(new ArrayStore));

$first = new WorkerFakeJob;

$second = new WorkerFakeJob;

$first->uuid = $second->uuid = 'uuid';

$first->maxExceptions = $second->maxExceptions = 2;

$first->payload = $second->payload = ['countCrashesAsExceptions' => true];

// Simulate the worker dying during the previous attempt by leaving its marker behind...

$cache->put('job-processing:uuid', true);

$worker->process('default', $first, $this->workerOptions());

$this->assertTrue($first->fired);

$this->assertFalse($first->hasFailed());

$this->assertSame(1, $cache->get('job-exceptions:uuid'));

$cache->put('job-processing:uuid', true);

try {

$worker->process('default', $second, $this->workerOptions());

} catch (MaxAttemptsExceededException) {

//

}

$this->assertFalse($second->fired);

$this->assertInstanceOf(MaxAttemptsExceededException::class, $second->failedWith);

$this->assertNull($cache->get('job-processing:uuid'));

}

public function testAttemptsThatFinishDoNotLeaveTheirMarkerBehind()

{

$worker = $this->getWorker();

$worker->setCache($cache = new Repository(new ArrayStore));

$released = new WorkerFakeJob(fn ($job) => $job->release());

$thrown = new WorkerFakeJob(fn () => throw new RuntimeException);

$released->uuid = $thrown->uuid = 'uuid';

$released->maxExceptions = $thrown->maxExceptions = 2;

$released->payload = $thrown->payload = ['countCrashesAsExceptions' => true];

$worker->process('default', $released, $this->workerOptions());

$this->assertNull($cache->get('job-exceptions:uuid'));

$this->assertNull($cache->get('job-processing:uuid'));

try {

$worker->process('default', $thrown, $this->workerOptions());

} catch (RuntimeException) {

//

}

$this->assertFalse($thrown->hasFailed());

$this->assertSame(1, $cache->get('job-exceptions:uuid'));

$this->assertNull($cache->get('job-processing:uuid'));

}

public function testJobIsFailedIfItHasAlreadyExpired()

{

$job = new WorkerFakeJob(function ($job) {

$job->attempts++;

});

$job->retryUntil = Carbon::now()->addSeconds(2)->getTimestamp();

$job->attempts = 1;

Carbon::setTestNow(

Carbon::now()->addSeconds(3)

);

$worker = $this->getWorker('default', ['queue' => [$job]]);

$worker->runNextJob('default', 'queue', $this->workerOptions());

$this->assertNull($job->releaseAfter);

$this->assertTrue($job->deleted);

$this->assertInstanceOf(MaxAttemptsExceededException::class, $job->failedWith);

$this->exceptionHandler->assertReported(MaxAttemptsExceededException::class);

$this->events->assertDispatchedOnce(JobExceptionOccurred::class);

$this->events->assertNotDispatched(JobProcessed::class);

}

public function testJobBasedMaxRetries()

{

$job = new WorkerFakeJob(function ($job) {

$job->attempts++;

});

$job->attempts = 2;

$job->maxTries = 10;

$worker = $this->getWorker('default', ['queue' => [$job]]);

$worker->runNextJob('default', 'queue', $this->workerOptions(['maxTries' => 1]));

$this->assertFalse($job->deleted);

$this->assertNull($job->failedWith);

}

public function testJobBasedFailedDelay()

{

$job = new WorkerFakeJob(function ($job) {

throw new Exception('Something went wrong.');

});

$job->attempts = 1;

$job->backoff = 10;

$worker = $this->getWorker('default', ['queue' => [$job]]);

$worker->runNextJob('default', 'queue', $this->workerOptions(['backoff' => 3, 'maxTries' => 0]));

$this->assertEquals(10, $job->releaseAfter);

}

public function testJobRunsIfAppIsNotInMaintenanceMode()

{

$firstJob = new WorkerFakeJob(function ($job) {

$job->attempts++;

});

$secondJob = new WorkerFakeJob(function ($job) {

$job->attempts++;

});

$this->maintenanceFlags = [false, true];

$maintenanceModeChecker = function () {

if ($this->maintenanceFlags) {

return array_shift($this->maintenanceFlags);

}

throw new LoopBreakerException;

};

$worker = $this->getWorker('default', ['queue' => [$firstJob, $secondJob]], $maintenanceModeChecker);

try {

$worker->daemon('default', 'queue', $this->workerOptions());

$this->fail('Expected LoopBreakerException to be thrown');

} catch (LoopBreakerException) {

$this->assertSame(1, $firstJob->attempts);

$this->assertSame(0, $secondJob->attempts);

}

}

public function testJobDoesNotFireIfDeleted()

{

$job = new WorkerFakeJob(function () {

return true;

});

$worker = $this->getWorker('default', ['queue' => [$job]]);

$job->delete();

$worker->runNextJob('default', 'queue', $this->workerOptions());

$this->events->assertDispatchedOnce(JobProcessed::class);

$this->assertFalse($job->hasFailed());

$this->assertFalse($job->isReleased());

$this->assertTrue($job->isDeleted());

}

public function testJobReleasedEventIsRaisedWhenJobReleasesItself()

{

$job = new WorkerFakeJob(function ($job) {

$job->release(10);

});

$worker = $this->getWorker('default', ['queue' => [$job]]);

$worker->runNextJob('default', 'queue', $this->workerOptions());

$this->assertTrue($job->isReleased());

$this->assertFalse($job->isDeleted());

$this->events->assertDispatchedOnce(JobReleased::class);

}

public function testWorkerPicksJobUsingCustomCallbacks()

{

$worker = $this->getWorker('default', [

'default' => [$defaultJob = new WorkerFakeJob], 'custom' => [$customJob = new WorkerFakeJob],

]);

$worker->runNextJob('default', 'default', new WorkerOptions);

$worker->runNextJob('default', 'default', new WorkerOptions);

$this->assertTrue($defaultJob->fired);

$this->assertFalse($customJob->fired);

$worker2 = $this->getWorker('default', [

'default' => [$defaultJob = new WorkerFakeJob], 'custom' => [$customJob = new WorkerFakeJob],

]);

$worker2->setName('myworker');

Worker::popUsing('myworker', function ($pop) {

return $pop('custom');

});

$worker2->runNextJob('default', 'default', new WorkerOptions);

$worker2->runNextJob('default', 'default', new WorkerOptions);

$this->assertFalse($defaultJob->fired);

$this->assertTrue($customJob->fired);

Worker::popUsing('myworker', null);

}

public function testWorkerCanBeKilledUsingCustomCallback()

{

Worker::killUsing(function ($status) {

throw new RuntimeException("Killed with status [{$status}].");

});

$this->expectException(RuntimeException::class);

$this->expectExceptionMessage('Killed with status [124].');

try {

$this->getWorker('default', ['queue' => []])->kill(124, new WorkerOptions, WorkerStopReason::TimedOut);

} finally {

Worker::killUsing(null);

$this->events->assertDispatchedOnce(WorkerStopping::class);

$this->events->assertDispatched(WorkerStopping::class, function ($event) {

return $event->status === 124

&& $event->reason === WorkerStopReason::TimedOut;

});

}

}

public function testWorkerStartingIsDispatched()

{

$workerOptions = new WorkerOptions();

$workerOptions->stopWhenEmpty = true;

$worker = $this->getWorker('default', ['queue' => [

$firstJob = new WorkerFakeJob(),

$secondJob = new WorkerFakeJob(),

]]);

$worker->daemon('default', 'queue', $workerOptions);

$this->assertTrue($firstJob->fired);

$this->assertTrue($secondJob->fired);

$this->events->assertDispatchedOnce(WorkerStarting::class);

}

public function testWorkerIdleIsDispatched()

{

$workerOptions = new WorkerOptions();

$workerOptions->stopWhenEmpty = true;

$worker = $this->getWorker('default', ['queue' => []]);

$worker->daemon('default', 'queue', $workerOptions);

$this->events->assertDispatchedOnce(WorkerIdle::class);

$this->events->assertDispatched(WorkerIdle::class, function ($event) use ($workerOptions) {

return $event->connectionName === 'default'

&& $event->queue === 'queue'

&& $event->workerOptions === $workerOptions;

});

}

public function testWorkerStoppingIsDispatched()

{

$workerOptions = new WorkerOptions();

$workerOptions->stopWhenEmpty = true;

$worker = $this->getWorker('default', ['queue' => [

$firstJob = new WorkerFakeJob(),

$secondJob = new WorkerFakeJob(),

]]);

$worker->daemon('default', 'queue', $workerOptions);

$this->assertTrue($firstJob->fired);

$this->assertTrue($secondJob->fired);

$this->events->assertDispatched(WorkerStopping::class, function ($event) use ($workerOptions) {

return $event->status === 0

&& $event->workerOptions === $workerOptions

&& $event->reason === WorkerStopReason::QueueEmpty

&& $event->jobsProcessed === 2

&& $event->lastJobProcessedAt !== null

&& $event->memoryUsage > 0

&& $event->connectionName === 'default'

&& $event->queue === 'queue';

});

}

public function testWorkerStopsWithLostConnectionReason()

{

$workerOptions = new WorkerOptions();

$workerOptions->stopWhenEmpty = true;

$worker = $this->getWorker('default', ['queue' => [

$job = new WorkerFakeJob(function () {

throw new RuntimeException('server has gone away');

}),

]]);

$worker->daemon('default', 'queue', $workerOptions);

$this->assertTrue($job->fired);

$this->events->assertDispatched(WorkerStopping::class, function ($event) use ($workerOptions) {

return $event->status === 0

&& $event->workerOptions === $workerOptions

&& $event->reason === WorkerStopReason::LostConnection;

});

}

public function testWorkerDoesNotStopOnLostConnectionWhenDisabled()

{

$workerOptions = new WorkerOptions();

$workerOptions->stopWhenEmpty = true;

$worker = $this->getWorker('default', ['queue' => [

$job = new WorkerFakeJob(function () {

throw new RuntimeException('server has gone away');

}),

]]);

Worker::$stopOnLostConnection = false;

try {

$worker->daemon('default', 'queue', $workerOptions);

} finally {

Worker::$stopOnLostConnection = true;

}

$this->assertTrue($job->fired);

$this->events->assertDispatched(WorkerStopping::class, function ($event) use ($workerOptions) {

return $event->status === 0

&& $event->workerOptions === $workerOptions

&& $event->reason === WorkerStopReason::QueueEmpty;

});

}

public function testJobReleasedEvent()

{

$e = new RuntimeException;

$job = new WorkerFakeJob(function () use ($e) {

throw $e;

});

$worker = $this->getWorker('default', ['queue' => [$job]]);

$worker->runNextJob('default', 'queue', $this->workerOptions(['backoff' => 10]));

$this->events->assertDispatchedOnce(JobReleasedAfterException::class);

$this->events->assertDispatched(JobReleasedAfterException::class, function ($event) use ($job, $e) {

return $event->connectionName === 'default'

&& $event->job === $job

&& $event->backoff === 10

&& $event->exception === $e;

});

}

public function testInterruptibleJobIsNotifiedOnSignal()

{

$interruptible = new class implements Interruptible

{

public ?int $receivedSignal = null;

public function interrupted(int $signal): void

{

$this->receivedSignal = $signal;

}

};

$handler = Mockery::mock(CallQueuedHandler::class);

$handler->expects('getRunningCommand')->andReturn($interruptible);

$worker = $this->getWorker('default', ['queue' => []]);

$job = new WorkerFakeJob;

$job->resolvedJob = $handler;

$worker->currentJob = $job;

$worker->notifyJobOfSignal(15);

$this->assertSame(15, $interruptible->receivedSignal);

}

public function testJobInterruptedEventIsDispatchedForInterruptibleJobs()

{

$interruptible = new class implements Interruptible

{

public function interrupted(int $signal): void

{

//

}

};

$handler = Mockery::mock(CallQueuedHandler::class);

$handler->expects('getRunningCommand')->andReturn($interruptible);

$worker = $this->getWorker('default', ['queue' => []]);

$job = new WorkerFakeJob;

$job->connectionName = 'default';

$job->resolvedJob = $handler;

$worker->currentJob = $job;

$worker->notifyJobOfSignal(15);

$this->events->assertDispatchedOnce(JobInterrupted::class);

$this->events->assertDispatched(JobInterrupted::class, function ($event) use ($job) {

return $event->connectionName === 'default'

&& $event->job === $job

&& $event->signal === 15;

});

}

#[RequiresPhpExtension('pcntl')]

public function testInterruptibleJobIsNotifiedWhenTheJobTimesOut()

{

$interruptible = new class implements Interruptible

{

public ?int $receivedSignal = null;

public function interrupted(int $signal): void

{

$this->receivedSignal = $signal;

}

};

$handler = Mockery::mock(CallQueuedHandler::class);

$handler->expects('getRunningCommand')->andReturn($interruptible);

$worker = $this->getWorker('default', ['queue' => []]);

$job = new WorkerFakeJob;

$job->resolvedJob = $handler;

$worker->currentJob = $job;

$this->timeOutJob($worker, $job);

$this->assertSame(SIGALRM, $interruptible->receivedSignal);

}

#[RequiresPhpExtension('pcntl')]

public function testTimeoutIsStillHandledWhenNotifyingTheJobFails()

{

$interruptible = new class implements Interruptible

{

public function interrupted(int $signal): void

{

throw new Exception('Failed to interrupt.');

}

};

$handler = Mockery::mock(CallQueuedHandler::class);

$handler->expects('getRunningCommand')->andReturn($interruptible);

$worker = $this->getWorker('default', ['queue' => []]);

$job = new WorkerFakeJob;

$job->resolvedJob = $handler;

$worker->currentJob = $job;

$this->timeOutJob($worker, $job);

$this->exceptionHandler->assertReported(fn (Exception $reported) => $reported->getMessage() === 'Failed to interrupt.');

$this->events->assertDispatchedOnce(JobTimedOut::class);

}

/**

private function getWorker($connectionName = 'default', $jobs = [], ?callable $isInMaintenanceMode = null)

{

return new InsomniacWorker(

...$this->workerDependencies($connectionName, $jobs, $isInMaintenanceMode)

);

}

private function workerDependencies($connectionName = 'default', $jobs = [], ?callable $isInMaintenanceMode = null)

{

return [

new WorkerFakeManager($connectionName, new WorkerFakeConnection($connectionName, $jobs)),

$this->events,

$this->exceptionHandler,

$isInMaintenanceMode ?? function () {

return false;

},

];

}

private function workerOptions(array $overrides = [])

{

$options = new WorkerOptions;

foreach ($overrides as $key => $value) {

$options->{$key} = $value;

}

return $options;

}

private function timeOutJob(InsomniacWorker $worker, $job)

{

Worker::killUsing(fn () => throw new RuntimeException('Killed.'));

try {

$worker->registerTimeoutHandler('default', 'queue', $job, $this->workerOptions(['timeout' => 0]));

pcntl_signal_get_handler(SIGALRM)(SIGALRM);

} catch (RuntimeException) {

//

} finally {

Worker::killUsing(null);

pcntl_signal(SIGALRM, SIG_DFL);

}

}

{

public $sleptFor;

public $stopOnMemoryExceeded = false;

public $currentTime;

public function sleep($seconds)

{

$this->sleptFor = $seconds;

if (! is_null($this->currentTime)) {

$this->currentTime += $seconds;

}

}

protected function currentTime()

{

return $this->currentTime ?? parent::currentTime();

}

public function notifyJobOfSignal(int $signal): void

{

parent::notifyJobOfSignal($signal);

}

public function registerTimeoutHandler($connectionName, $queue, $job, WorkerOptions $options)

{

parent::registerTimeoutHandler($connectionName, $queue, $job, $options);

}

public function stop($status = 0, $options = null, $reason = null, $connectionName = null, $queue = null)

{

return parent::stop($status, $options, $reason, $connectionName, $queue);

}

public function daemonShouldRun(WorkerOptions $options, $connectionName, $queue)