From c239339aaf4d0f15baae9c42699fad1c51eba2c4 Mon Sep 17 00:00:00 2001
From: romkatsu <r@tsurkanu.ru>
Date: Mon, 6 Jun 2022 19:52:28 +0300
Subject: [PATCH 1/3] Add tests for Worker

---
 tests/App/FakeHandler.php |  38 ++++++++
 tests/Unit/WorkerTest.php | 194 ++++++++++++++++++++++++++++++++++----
 2 files changed, 212 insertions(+), 20 deletions(-)
 create mode 100644 tests/App/FakeHandler.php

diff --git a/tests/App/FakeHandler.php b/tests/App/FakeHandler.php
new file mode 100644
index 00000000..12f7fcfc
--- /dev/null
+++ b/tests/App/FakeHandler.php
@@ -0,0 +1,38 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Yiisoft\Yii\Queue\Tests\App;
+
+use Yiisoft\Yii\Queue\Message\MessageInterface;
+use RuntimeException;
+
+final class FakeHandler
+{
+    public static array $processedMessages = [];
+    
+    public function __construct()
+    {
+        self::$processedMessages = [];
+    }
+
+    public function __invoke(MessageInterface $message)
+    {
+        self::$processedMessages[] = $message;
+    }
+
+    public function execute(MessageInterface $message): void
+    {
+        self::$processedMessages[] = $message;
+    }
+
+    public static function staticExecute(MessageInterface $message): void
+    {
+        self::$processedMessages[] = $message;
+    }
+
+    public function executeWithException(MessageInterface $message): void
+    {
+        throw new RuntimeException('Test exception');
+    }
+}
diff --git a/tests/Unit/WorkerTest.php b/tests/Unit/WorkerTest.php
index 44ab3eac..7b73c0a9 100644
--- a/tests/Unit/WorkerTest.php
+++ b/tests/Unit/WorkerTest.php
@@ -4,39 +4,193 @@
 
 namespace Yiisoft\Yii\Queue\Tests\Unit;
 
-use RuntimeException;
+use Psr\Container\ContainerInterface;
+use Psr\Log\LoggerInterface;
+use Psr\Log\Test\TestLogger;
+use Yiisoft\Injector\Injector;
+use Yiisoft\Test\Support\Container\SimpleContainer;
+use Yiisoft\Yii\Queue\Exception\JobFailureException;
 use Yiisoft\Yii\Queue\Message\Message;
+use Yiisoft\Yii\Queue\Message\MessageInterface;
 use Yiisoft\Yii\Queue\QueueInterface;
+use Yiisoft\Yii\Queue\Tests\App\FakeHandler;
 use Yiisoft\Yii\Queue\Tests\TestCase;
+use Yiisoft\Yii\Queue\Worker\Worker;
 
 final class WorkerTest extends TestCase
 {
-    /**
-     * Check normal job execution
-     */
-    public function testJobExecuted(): void
+    public function testJobExecutedWithCallableHandler(): void
     {
-        $this->executionTimes = 0;
-        $message = new Message('simple', '', []);
+        $handleMessage = null;
+        $message = new Message('simple', ['test-data']);
+        $logger = new TestLogger();
+        $container = new SimpleContainer();
+        $handlers = [
+            'simple' => function (MessageInterface $message) use (&$handleMessage) {
+                $handleMessage = $message;
+            },
+        ];
+
+        $queue = $this->createMock(QueueInterface::class);
+        $worker = $this->createWorkerByParams($handlers, $logger, $container);
+
+        $worker->process($message, $queue);
+        $this->assertSame($message, $handleMessage);
+
+        $this->assertTrue(
+            $logger->hasInfoThatContains("Processing message #{message}.")
+        );
+    }
+
+    public function testJobExecutedWithDefinitionHandler(): void
+    {
+        $message = new Message('simple', ['test-data']);
+        $logger = new TestLogger();
+        $handler = new FakeHandler();
+        $container = new SimpleContainer([FakeHandler::class => $handler]);
+        $handlers = ['simple' => FakeHandler::class];
+
+        $queue = $this->createMock(QueueInterface::class);
+        $worker = $this->createWorkerByParams($handlers, $logger, $container);
+
+        $worker->process($message, $queue);
+        $this->assertSame([$message], $handler::$processedMessages);
+    }
+
+    public function testJobExecutedWithDefinitionClassHandler(): void
+    {
+        $message = new Message('simple', ['test-data']);
+        $logger = new TestLogger();
+        $handler = new FakeHandler();
+        $container = new SimpleContainer([FakeHandler::class => $handler]);
+        $handlers = ['simple' => [FakeHandler::class, 'execute']];
+
+        $queue = $this->createMock(QueueInterface::class);
+        $worker = $this->createWorkerByParams($handlers, $logger, $container);
+
+        $worker->process($message, $queue);
+        $this->assertSame([$message], $handler::$processedMessages);
+    }
+
+    public function testJobFailWithDefinitionNotFoundClassBuExistInContainerHandler(): void
+    {
+        $message = new Message('simple', ['test-data']);
+        $logger = new TestLogger();
+        $handler = new FakeHandler();
+        $container = new SimpleContainer(['not-found-class-name' => $handler]);
+        $handlers = ['simple' => ['not-found-class-name', 'execute']];
+
+        $queue = $this->createMock(QueueInterface::class);
+        $worker = $this->createWorkerByParams($handlers, $logger, $container);
+
+        $worker->process($message, $queue);
+        $this->assertSame([$message], $handler::$processedMessages);
+    }
+
+    public function testJobExecutedWithStaticDefinitionHandler(): void
+    {
+        $message = new Message('simple', ['test-data']);
+        $logger = new TestLogger();
+        $handler = new FakeHandler();
+        $container = new SimpleContainer([FakeHandler::class => $handler]);
+        $handlers = ['simple' => [FakeHandler::class, 'staticExecute']];
+
         $queue = $this->createMock(QueueInterface::class);
-        $this
-            ->getWorker()
-            ->process($message, $queue);
+        $worker = $this->createWorkerByParams($handlers, $logger, $container);
 
-        self::assertEquals(1, $this->executionTimes);
+        $worker->process($message, $queue);
+        $this->assertSame([$message], $handler::$processedMessages);
     }
 
-    /**
-     * Check job throws exception
-     */
-    public function testThrowException(): void
+    public function testJobFailWithDefinitionUndefinedMethodHandler(): void
     {
-        $this->expectException(RuntimeException::class);
+        $this->expectExceptionMessage("Queue handler with name simple doesn't exist");
+
+        $message = new Message('simple', ['test-data']);
+        $logger = new TestLogger();
+        $handler = new FakeHandler();
+        $container = new SimpleContainer([FakeHandler::class => $handler]);
+        $handlers = ['simple' => [FakeHandler::class, 'undefinedMethod']];
 
-        $message = new Message('exceptional', '', []);
         $queue = $this->createMock(QueueInterface::class);
-        $this
-            ->getWorker()
-            ->process($message, $queue);
+        $worker = $this->createWorkerByParams($handlers, $logger, $container);
+
+        $worker->process($message, $queue);
+    }
+
+    public function testJobFailWithDefinitionUndefinedClassHandler(): void
+    {
+        $this->expectExceptionMessage("Queue handler with name simple doesn't exist");
+
+        $message = new Message('simple', ['test-data']);
+        $logger = new TestLogger();
+        $handler = new FakeHandler();
+        $container = new SimpleContainer([FakeHandler::class => $handler]);
+        $handlers = ['simple' => ['UndefinedClass', 'handle']];
+
+        $queue = $this->createMock(QueueInterface::class);
+        $worker = $this->createWorkerByParams($handlers, $logger, $container);
+
+        try {
+            $worker->process($message, $queue);
+        } finally {
+            $this->assertTrue(
+                $logger->hasErrorThatContains("UndefinedClass doesn't exist.")
+            );
+        }
+    }
+
+    public function testJobFailWithDefinitionClassNotFoundInContainerHandler(): void
+    {
+        $this->expectExceptionMessage("Queue handler with name simple doesn't exist");
+        $message = new Message('simple', ['test-data']);
+        $logger = new TestLogger();
+        $container = new SimpleContainer();
+        $handlers = ['simple' => [FakeHandler::class, 'execute']];
+
+        $queue = $this->createMock(QueueInterface::class);
+        $worker = $this->createWorkerByParams($handlers, $logger, $container);
+
+        $worker->process($message, $queue);
+    }
+
+    public function testJobFailWithDefinitionHandlerException(): void
+    {
+        $this->expectException(JobFailureException::class);
+        $this->expectExceptionMessage(
+            "Processing of message #null is stopped because of an exception:\nTest exception."
+        );
+
+        $message = new Message('simple', ['test-data']);
+        $logger = new TestLogger();
+        $handler = new FakeHandler();
+        $container = new SimpleContainer([FakeHandler::class => $handler]);
+        $handlers = ['simple' => [FakeHandler::class, 'executeWithException']];
+
+        $queue = $this->createMock(QueueInterface::class);
+        $worker = $this->createWorkerByParams($handlers, $logger, $container);
+
+        try {
+            $worker->process($message, $queue);
+        } finally {
+            $this->assertTrue(
+                $logger->hasErrorThatContains(
+                    "Processing of message #null is stopped because of an exception:\nTest exception."
+                )
+            );
+        }
+    }
+
+    private function createWorkerByParams(
+        array $handlers,
+        LoggerInterface $logger,
+        ContainerInterface $container
+    ): Worker {
+        return new Worker(
+            $handlers,
+            $logger,
+            new Injector($container),
+            $container
+        );
     }
 }

From 731256f32498c92bf1b4bd312ab1118020eb706d Mon Sep 17 00:00:00 2001
From: romkatsu <r@tsurkanu.ru>
Date: Mon, 6 Jun 2022 19:54:05 +0300
Subject: [PATCH 2/3] Fix test name

---
 tests/Unit/WorkerTest.php | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/Unit/WorkerTest.php b/tests/Unit/WorkerTest.php
index 7b73c0a9..893cb63f 100644
--- a/tests/Unit/WorkerTest.php
+++ b/tests/Unit/WorkerTest.php
@@ -72,7 +72,7 @@ public function testJobExecutedWithDefinitionClassHandler(): void
         $this->assertSame([$message], $handler::$processedMessages);
     }
 
-    public function testJobFailWithDefinitionNotFoundClassBuExistInContainerHandler(): void
+    public function testJobFailWithDefinitionNotFoundClassButExistInContainerHandler(): void
     {
         $message = new Message('simple', ['test-data']);
         $logger = new TestLogger();

From b9bf62cb90336e140e3e2bb24de9075cbb0e473c Mon Sep 17 00:00:00 2001
From: romkatsu <r@tsurkanu.ru>
Date: Mon, 6 Jun 2022 21:32:40 +0300
Subject: [PATCH 3/3] fix cs

---
 tests/App/FakeHandler.php | 2 +-
 tests/Unit/WorkerTest.php | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/tests/App/FakeHandler.php b/tests/App/FakeHandler.php
index 12f7fcfc..e100974e 100644
--- a/tests/App/FakeHandler.php
+++ b/tests/App/FakeHandler.php
@@ -10,7 +10,7 @@
 final class FakeHandler
 {
     public static array $processedMessages = [];
-    
+
     public function __construct()
     {
         self::$processedMessages = [];
diff --git a/tests/Unit/WorkerTest.php b/tests/Unit/WorkerTest.php
index 893cb63f..c63492ef 100644
--- a/tests/Unit/WorkerTest.php
+++ b/tests/Unit/WorkerTest.php
@@ -38,7 +38,7 @@ public function testJobExecutedWithCallableHandler(): void
         $this->assertSame($message, $handleMessage);
 
         $this->assertTrue(
-            $logger->hasInfoThatContains("Processing message #{message}.")
+            $logger->hasInfoThatContains('Processing message #{message}.')
         );
     }