Feature: Constructor-based Dependency Injection

docs/sections/custom_tasks.md

@@ -59,11 +59,59 @@ Make sure it throws an exception with a clear error message in case of failure.
 Note: You can use the provided `Queue\Model\QueueException` if you do not need to include a stack trace.
 This is usually the default inside custom tasks.
 
-## DI Container Example
+## DI Container
 
 If you use the [Dependency Injection Container](https://book.cakephp.org/5/en/development/dependency-injection.html) provided by CakePHP you can also use
 it inside your tasks.
 
+### Constructor Injection
+
+Tasks registered in the DI container can receive dependencies through their constructor, the same way CakePHP Components and Commands do.
+
+First, register the task and its dependencies in your `Application::services()`:
+
+```php
+use App\Queue\Task\MyCustomTask;
+use App\Service\MyService;
+
+public function services(ContainerInterface $container): void {
+    $container->add(MyService::class);
+    $container->add(MyCustomTask::class)
+        ->addArgument(MyService::class);
+}
+```
+
+Then declare the dependency in your task's constructor:
+
+```php
+namespace App\Queue\Task;
+
+use App\Service\MyService;
+use Queue\Queue\Task;
+
+class MyCustomTask extends Task {
+
+    public function __construct(
+        protected readonly MyService $myService,
+    ) {
+        parent::__construct();
+    }
+
+    public function run(array $data, int $jobId): void {
+        $this->myService->doWork($data);
+    }
+
+}
+```
+
+The Processor injects its own runtime `Io` and `LoggerInterface` via `setIo()` / `setLogger()` after resolving the task, so your constructor only needs to declare your own dependencies. Call `parent::__construct()` with no arguments.
+
+Tasks not registered in the container continue to work exactly as before.
+
+### ServicesTrait
+
+Alternatively, you can use the [ServicesTrait](https://github.com/dereuromark/cakephp-queue/blob/master/src/Queue/ServicesTrait.php) to pull services from the container at runtime inside `run()`:
+
 ```php
 use Queue\Queue\ServicesTrait;
 
@@ -77,7 +125,7 @@ class MyCustomTask extends Task {
 }
 ```
 
-As you see here you have to add the [ServicesTrait](https://github.com/dereuromark/cakephp-queue/blob/master/src/Queue/ServicesTrait.php) to your task which then allows you to use the `$this->getService()` method.
+Note that `getService()` cannot be called in the constructor, only inside `run()` or other methods invoked after the container has been set.
 
 ## Organize tasks in sub folders
 

src/Queue/Processor.php

@@ -661,12 +661,21 @@ protected function getConfig(array $args): array {
 	 */
 	protected function loadTask(string $taskName): TaskInterface {
 		$className = $this->getTaskClass($taskName);
-		/** @var \Queue\Queue\Task $task */
-		$task = new $className($this->io, $this->logger);
+
+		if ($this->container && $this->container->has($className)) {
+			$task = $this->container->get($className);
+		} else {
+			$task = new $className();
+		}
+
 		if (!$task instanceof TaskInterface) {
 			throw new RuntimeException('Task must implement ' . TaskInterface::class);
 		}
 
+		/** @var \Queue\Queue\Task $task */
+		$task->setIo($this->io);
+		$task->setLogger($this->logger);
+
 		return $task;
 	}
 

src/Queue/Task.php

@@ -103,6 +103,24 @@ public function __construct(?Io $io = null, ?LoggerInterface $logger = null) {
 		}
 	}
 
+	/**
+	 * @param \Queue\Console\Io $io IO
+	 *
+	 * @return void
+	 */
+	public function setIo(Io $io): void {
+		$this->io = $io;
+	}
+
+	/**
+	 * @param \Psr\Log\LoggerInterface $logger
+	 *
+	 * @return void
+	 */
+	public function setLogger(LoggerInterface $logger): void {
+		$this->logger = $logger;
+	}
+
 	/**
 	 * @throws \InvalidArgumentException
 	 *

tests/TestCase/Command/InfoCommandTest.php

@@ -38,7 +38,7 @@ public function testExecute(): void {
 		$this->exec('queue info');
 
 		$output = $this->_out->output();
-		$this->assertStringContainsString('15 tasks available:', $output);
+		$this->assertStringContainsString('16 tasks available:', $output);
 		$this->assertExitCode(0);
 	}
 

tests/TestCase/Queue/ProcessorTest.php

@@ -6,6 +6,7 @@
 use Cake\Console\CommandInterface;
 use Cake\Console\ConsoleIo;
 use Cake\Core\Configure;
+use Cake\Core\Container;
 use Cake\Datasource\ConnectionManager;
 use Cake\Event\EventList;
 use Cake\Event\EventManager;
@@ -21,6 +22,8 @@
 use RuntimeException;
 use Shim\TestSuite\ConsoleOutput;
 use Shim\TestSuite\TestTrait;
+use TestApp\Queue\Task\InjectedTask;
+use TestApp\Services\TestService;
 use const SIGTERM;
 
 class ProcessorTest extends TestCase {
@@ -442,4 +445,111 @@ public function testSetPhpTimeoutWithDeprecatedConfig() {
 		Configure::delete('Queue.workertimeout');
 	}
 
+	/**
+	 * Test that loadTask() resolves a task from the DI container when registered.
+	 *
+	 * @return void
+	 */
+	public function testLoadTaskResolvesFromContainer(): void {
+		$container = new Container();
+		$container->add(ExampleTask::class);
+
+		$out = new ConsoleOutput();
+		$processorIo = new Io(new ConsoleIo($out));
+		$processorLogger = new NullLogger();
+		$processor = new Processor($processorIo, $processorLogger, $container);
+
+		// Set taskConf so getTaskClass() can resolve the name
+		$reflection = new ReflectionClass($processor);
+		$taskConfProp = $reflection->getProperty('taskConf');
+		$taskConfProp->setValue($processor, [
+			'Queue.Example' => ['class' => ExampleTask::class],
+		]);
+
+		$task = $this->invokeMethod($processor, 'loadTask', ['Queue.Example']);
+
+		$this->assertInstanceOf(ExampleTask::class, $task);
+
+		// Verify the task received the Processor's Io and Logger, not defaults
+		$taskReflection = new ReflectionClass($task);
+		$ioProp = $taskReflection->getProperty('io');
+		$this->assertSame($processorIo, $ioProp->getValue($task), 'Task should have the Processor Io');
+
+		$loggerProp = $taskReflection->getProperty('logger');
+		$this->assertSame($processorLogger, $loggerProp->getValue($task), 'Task should have the Processor Logger');
+	}
+
+	/**
+	 * Test that loadTask() falls back to direct instantiation when the task
+	 * is not registered in the container.
+	 *
+	 * @return void
+	 */
+	public function testLoadTaskFallsBackWithoutContainerRegistration(): void {
+		$container = new Container();
+		// Intentionally do NOT register ExampleTask in the container
+
+		$out = new ConsoleOutput();
+		$processorIo = new Io(new ConsoleIo($out));
+		$processorLogger = new NullLogger();
+		$processor = new Processor($processorIo, $processorLogger, $container);
+
+		$reflection = new ReflectionClass($processor);
+		$taskConfProp = $reflection->getProperty('taskConf');
+		$taskConfProp->setValue($processor, [
+			'Queue.Example' => ['class' => ExampleTask::class],
+		]);
+
+		$task = $this->invokeMethod($processor, 'loadTask', ['Queue.Example']);
+
+		$this->assertInstanceOf(ExampleTask::class, $task);
+
+		// Verify the task still received the Processor's Io and Logger
+		$taskReflection = new ReflectionClass($task);
+		$ioProp = $taskReflection->getProperty('io');
+		$this->assertSame($processorIo, $ioProp->getValue($task), 'Fallback task should have the Processor Io');
+
+		$loggerProp = $taskReflection->getProperty('logger');
+		$this->assertSame($processorLogger, $loggerProp->getValue($task), 'Fallback task should have the Processor Logger');
+	}
+
+	/**
+	 * Test that loadTask() resolves a task with constructor-injected dependencies
+	 * from the DI container.
+	 *
+	 * @return void
+	 */
+	public function testLoadTaskWithConstructorDependencyInjection(): void {
+		$testService = new TestService();
+
+		$container = new Container();
+		$container->add(InjectedTask::class)
+			->addArgument($testService);
+
+		$out = new ConsoleOutput();
+		$processorIo = new Io(new ConsoleIo($out));
+		$processorLogger = new NullLogger();
+		$processor = new Processor($processorIo, $processorLogger, $container);
+
+		$reflection = new ReflectionClass($processor);
+		$taskConfProp = $reflection->getProperty('taskConf');
+		$taskConfProp->setValue($processor, [
+			'Injected' => ['class' => InjectedTask::class],
+		]);
+
+		/** @var \TestApp\Queue\Task\InjectedTask $task */
+		$task = $this->invokeMethod($processor, 'loadTask', ['Injected']);
+
+		$this->assertInstanceOf(InjectedTask::class, $task);
+		$this->assertSame($testService, $task->getTestService(), 'Task should have the injected TestService');
+
+		// Verify Io and Logger were set by the Processor
+		$taskReflection = new ReflectionClass($task);
+		$ioProp = $taskReflection->getProperty('io');
+		$this->assertSame($processorIo, $ioProp->getValue($task), 'DI task should have the Processor Io');
+
+		$loggerProp = $taskReflection->getProperty('logger');
+		$this->assertSame($processorLogger, $loggerProp->getValue($task), 'DI task should have the Processor Logger');
+	}
+
 }

tests/TestCase/Queue/Task/ExecuteTaskTest.php

@@ -77,7 +77,7 @@ public function testRunFailureWithRedirect() {
 		$this->assertSame('Failed with error code 127: `fooooobbbaraar -eeee 2>&1`', $exception->getMessage());
 
 		$this->assertTextContains('Error (code 127)', $this->err->output());
-		$this->assertTextContains('fooooobbbaraar: not found', $this->out->output());
+		$this->assertMatchesRegularExpression('/fooooobbbaraar.*not found/', $this->out->output());
 	}
 
 	/**
@@ -87,7 +87,7 @@ public function testRunFailureWithRedirectAndIgnoreCode() {
 		$this->Task->run(['command' => 'fooooobbbaraar -eeee', 'accepted' => []], 0);
 
 		$this->assertTextContains('Success (code 127)', $this->out->output());
-		$this->assertTextContains('fooooobbbaraar: not found', $this->out->output());
+		$this->assertMatchesRegularExpression('/fooooobbbaraar.*not found/', $this->out->output());
 	}
 
 	/**

tests/test_app/src/Queue/Task/InjectedTask.php

@@ -0,0 +1,33 @@
+<?php
+declare(strict_types=1);
+
+namespace TestApp\Queue\Task;
+
+use Queue\Queue\Task;
+use TestApp\Services\TestService;
+
+/**
+ * Test task that uses constructor-based dependency injection.
+ */
+class InjectedTask extends Task {
+
+	public ?int $timeout = 10;
+
+	public function __construct(
+		protected readonly TestService $testService,
+	) {
+		parent::__construct();
+	}
+
+	public function run(array $data, int $jobId): void {
+		$this->io->out($this->testService->output());
+	}
+
+	/**
+	 * Expose the injected service for test assertions.
+	 */
+	public function getTestService(): TestService {
+		return $this->testService;
+	}
+
+}