Skip to content

Commit 106562b

Browse files
josbeirjosbeir
committed
test: add tests with code coverage bump in mind
1 parent 8d7a9ec commit 106562b

File tree

2 files changed

+293
-0
lines changed

2 files changed

+293
-0
lines changed

‎tests/TestCase/Command/SubprocessJobRunnerCommandTest.php‎

Lines changed: 177 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -19,11 +19,15 @@
1919

2020
use Cake\Console\Arguments;
2121
use Cake\Console\ConsoleIo;
22+
use Cake\Core\ContainerInterface;
2223
use Cake\Queue\Command\SubprocessJobRunnerCommand;
2324
use Cake\TestSuite\TestCase;
2425
use Enqueue\Null\NullMessage;
2526
use Interop\Queue\Processor;
27+
use Psr\Log\LoggerInterface;
2628
use ReflectionClass;
29+
use RuntimeException;
30+
use stdClass;
2731
use TestApp\Job\MultilineLogJob;
2832
use TestApp\TestProcessor;
2933

@@ -316,4 +320,177 @@ public function testLogsRedirectedToStderr(): void
316320
$this->assertStringContainsString('Processing step 3 completed', $stderr);
317321
$this->assertStringContainsString('Job execution finished', $stderr);
318322
}
323+
324+
/**
325+
* Test defaultName method
326+
*/
327+
public function testDefaultName(): void
328+
{
329+
$this->assertSame('queue subprocess-runner', SubprocessJobRunnerCommand::defaultName());
330+
}
331+
332+
/**
333+
* Test executeJob with invalid message class (non-existent)
334+
*/
335+
public function testExecuteJobWithInvalidMessageClass(): void
336+
{
337+
$jobData = [
338+
'messageClass' => 'NonExistentClass',
339+
'body' => [
340+
'class' => [TestProcessor::class, 'processReturnAck'],
341+
'args' => [],
342+
],
343+
'properties' => [],
344+
];
345+
346+
$command = new SubprocessJobRunnerCommand();
347+
$reflection = new ReflectionClass($command);
348+
$method = $reflection->getMethod('executeJob');
349+
350+
$this->expectException(RuntimeException::class);
351+
$this->expectExceptionMessage('Invalid message class');
352+
353+
$method->invoke($command, $jobData);
354+
}
355+
356+
/**
357+
* Test executeJob with non-QueueMessage class
358+
*/
359+
public function testExecuteJobWithNonQueueMessageClass(): void
360+
{
361+
$jobData = [
362+
'messageClass' => stdClass::class,
363+
'body' => [
364+
'class' => [TestProcessor::class, 'processReturnAck'],
365+
'args' => [],
366+
],
367+
'properties' => [],
368+
];
369+
370+
$command = new SubprocessJobRunnerCommand();
371+
$reflection = new ReflectionClass($command);
372+
$method = $reflection->getMethod('executeJob');
373+
374+
$this->expectException(RuntimeException::class);
375+
$this->expectExceptionMessage('Invalid message class');
376+
377+
$method->invoke($command, $jobData);
378+
}
379+
380+
/**
381+
* Test configureLogging with fallback to NullLogger
382+
*/
383+
public function testConfigureLoggingConfiguresStderrLogger(): void
384+
{
385+
$jobData = ['logger' => 'stderr'];
386+
387+
$command = new SubprocessJobRunnerCommand();
388+
$reflection = new ReflectionClass($command);
389+
$method = $reflection->getMethod('configureLogging');
390+
391+
$logger = $method->invoke($command, $jobData);
392+
393+
$this->assertInstanceOf(LoggerInterface::class, $logger);
394+
}
395+
396+
/**
397+
* Test outputResult with valid JSON
398+
*/
399+
public function testOutputResultWithValidData(): void
400+
{
401+
$command = new SubprocessJobRunnerCommand();
402+
$reflection = new ReflectionClass($command);
403+
$method = $reflection->getMethod('outputResult');
404+
405+
$io = $this->createMock(ConsoleIo::class);
406+
$io->expects($this->once())
407+
->method('out')
408+
->with('{"success":true,"result":"ack"}');
409+
410+
$method->invoke($command, $io, ['success' => true, 'result' => 'ack']);
411+
}
412+
413+
/**
414+
* Test outputResult with data that cannot be JSON encoded
415+
*/
416+
public function testOutputResultWithInvalidJsonData(): void
417+
{
418+
$command = new SubprocessJobRunnerCommand();
419+
$reflection = new ReflectionClass($command);
420+
$method = $reflection->getMethod('outputResult');
421+
422+
$io = $this->createMock(ConsoleIo::class);
423+
$io->expects($this->never())
424+
->method('out');
425+
426+
// Create data with a resource which cannot be JSON encoded
427+
$resource = fopen('php://memory', 'r');
428+
$this->assertIsResource($resource);
429+
$method->invoke($command, $io, ['resource' => $resource]);
430+
if (is_resource($resource)) {
431+
fclose($resource);
432+
}
433+
}
434+
435+
/**
436+
* Test readInput with multiple chunks
437+
*/
438+
public function testReadInputWithLargeData(): void
439+
{
440+
// We can't easily mock STDIN, so we'll verify the method exists and is protected
441+
// Large data reading is already covered by the integration test (testLogsRedirectedToStderr)
442+
$reflection = new ReflectionClass(SubprocessJobRunnerCommand::class);
443+
$this->assertTrue($reflection->hasMethod('readInput'));
444+
445+
$method = $reflection->getMethod('readInput');
446+
$this->assertTrue($method->isProtected());
447+
}
448+
449+
/**
450+
* Test constructor with container
451+
*/
452+
public function testConstructorWithContainer(): void
453+
{
454+
$container = $this->createStub(ContainerInterface::class);
455+
$command = new SubprocessJobRunnerCommand($container);
456+
457+
$this->assertInstanceOf(SubprocessJobRunnerCommand::class, $command);
458+
}
459+
460+
/**
461+
* Test constructor without container
462+
*/
463+
public function testConstructorWithoutContainer(): void
464+
{
465+
$command = new SubprocessJobRunnerCommand();
466+
467+
$this->assertInstanceOf(SubprocessJobRunnerCommand::class, $command);
468+
}
469+
470+
/**
471+
* Test executeJob when message body json_encode fails
472+
*/
473+
public function testExecuteJobWithJsonEncodeFailure(): void
474+
{
475+
// PHP's json_encode can fail with certain data (like invalid UTF-8)
476+
// However, in this code path json_encode is called on $data['body'] which is already decoded
477+
// So this edge case is hard to trigger. We'll test normal flow is covered.
478+
$jobData = [
479+
'messageClass' => NullMessage::class,
480+
'body' => [
481+
'class' => [TestProcessor::class, 'processReturnAck'],
482+
'args' => [],
483+
],
484+
'properties' => [],
485+
];
486+
487+
$command = new SubprocessJobRunnerCommand();
488+
$reflection = new ReflectionClass($command);
489+
$method = $reflection->getMethod('executeJob');
490+
491+
$result = $method->invoke($command, $jobData);
492+
493+
// Verify it successfully encodes and processes
494+
$this->assertIsString($result);
495+
}
319496
}

‎tests/TestCase/Queue/SubprocessProcessorTest.php‎

Lines changed: 116 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -502,4 +502,120 @@ public function testProcessJobInSubprocessWithException(): void
502502
/** @phpstan-ignore cast.string */
503503
$this->assertStringContainsString('requeue', (string)$result);
504504
}
505+
506+
/**
507+
* Test subprocess with maxOutputSize limit exceeded
508+
*/
509+
public function testSubprocessMaxOutputSizeExceeded(): void
510+
{
511+
$logger = new ArrayLog();
512+
$config = [
513+
'command' => 'php -r "echo str_repeat(\'a\', 10000);"',
514+
'maxOutputSize' => 100, // Very small limit
515+
'timeout' => 5,
516+
];
517+
$processor = new SubprocessProcessor($logger, $config);
518+
519+
$reflection = new ReflectionClass($processor);
520+
$method = $reflection->getMethod('executeInSubprocess');
521+
522+
$jobData = [
523+
'messageClass' => NullMessage::class,
524+
'body' => ['class' => [TestProcessor::class, 'processReturnAck'], 'args' => []],
525+
'properties' => [],
526+
];
527+
528+
$result = $method->invoke($processor, $jobData);
529+
530+
$this->assertFalse($result['success']);
531+
$this->assertArrayHasKey('error', $result);
532+
$this->assertStringContainsString('output exceeded maximum size', $result['error']);
533+
}
534+
535+
/**
536+
* Test subprocess with maxOutputSize limit on stderr
537+
*/
538+
public function testSubprocessMaxErrorOutputSizeExceeded(): void
539+
{
540+
$logger = new ArrayLog();
541+
$config = [
542+
'command' => 'php -r "fwrite(STDERR, str_repeat(\'e\', 10000));"',
543+
'maxOutputSize' => 100, // Very small limit
544+
'timeout' => 5,
545+
];
546+
$processor = new SubprocessProcessor($logger, $config);
547+
548+
$reflection = new ReflectionClass($processor);
549+
$method = $reflection->getMethod('executeInSubprocess');
550+
551+
$jobData = [
552+
'messageClass' => NullMessage::class,
553+
'body' => ['class' => [TestProcessor::class, 'processReturnAck'], 'args' => []],
554+
'properties' => [],
555+
];
556+
557+
$result = $method->invoke($processor, $jobData);
558+
559+
$this->assertFalse($result['success']);
560+
$this->assertArrayHasKey('error', $result);
561+
$this->assertStringContainsString('error output exceeded maximum size', $result['error']);
562+
}
563+
564+
/**
565+
* Test subprocess handles normal sized output correctly
566+
*/
567+
public function testSubprocessWithNormalOutputSize(): void
568+
{
569+
$messageBody = [
570+
'class' => [TestProcessor::class, 'processReturnAck'],
571+
'args' => [],
572+
];
573+
$queueMessage = new NullMessage(json_encode($messageBody) ?: '');
574+
575+
$logger = new ArrayLog();
576+
$config = [
577+
'command' => 'php ' . ROOT . 'bin/cake.php queue subprocess-runner',
578+
'maxOutputSize' => 1048576, // 1MB - normal size
579+
'timeout' => 30,
580+
];
581+
$processor = new SubprocessProcessor($logger, $config);
582+
583+
$reflection = new ReflectionClass($processor);
584+
$method = $reflection->getMethod('executeInSubprocess');
585+
$prepareMethod = $reflection->getMethod('prepareJobData');
586+
587+
$jobData = $prepareMethod->invoke($processor, $queueMessage);
588+
$result = $method->invoke($processor, $jobData);
589+
590+
$this->assertTrue($result['success']);
591+
$this->assertSame(InteropProcessor::ACK, $result['result']);
592+
}
593+
594+
/**
595+
* Test executeInSubprocess with very short timeout
596+
*/
597+
public function testSubprocessWithVeryShortTimeout(): void
598+
{
599+
$logger = new ArrayLog();
600+
$config = [
601+
'command' => 'php -r "sleep(5);"',
602+
'timeout' => 1, // 1 second timeout
603+
];
604+
$processor = new SubprocessProcessor($logger, $config);
605+
606+
$reflection = new ReflectionClass($processor);
607+
$method = $reflection->getMethod('executeInSubprocess');
608+
609+
$jobData = [
610+
'messageClass' => NullMessage::class,
611+
'body' => ['class' => [TestProcessor::class, 'processReturnAck'], 'args' => []],
612+
'properties' => [],
613+
];
614+
615+
$result = $method->invoke($processor, $jobData);
616+
617+
$this->assertFalse($result['success']);
618+
$this->assertArrayHasKey('error', $result);
619+
$this->assertStringContainsString('timeout', $result['error']);
620+
}
505621
}

0 commit comments

Comments
 (0)