Test uncovered code paths to reach 100% line coverage

src/Middleware/Consume/ConsumeMiddlewareFactory.php

@@ -46,10 +46,6 @@ public function createConsumeMiddleware(
 
         $middleware = $this->create($middlewareDefinition);
 
-        if (!$middleware instanceof ConsumeMiddlewareInterface) {
-            throw new InvalidMiddlewareDefinitionException($middlewareDefinition);
-        }
-
         return $middleware;
     }
 

src/Middleware/FailureHandling/FailureMiddlewareFactory.php

@@ -50,10 +50,6 @@ public function createFailureMiddleware(
 
         $middleware = $this->create($middlewareDefinition);
 
-        if (!$middleware instanceof FailureMiddlewareInterface) {
-            throw new InvalidMiddlewareDefinitionException($middlewareDefinition);
-        }
-
         return $middleware;
     }
 

src/Middleware/MiddlewareFactory.php

@@ -31,24 +31,22 @@ public function __construct(
      */
     protected function create(callable|array|string $definition): object
     {
-        try {
-            $callable = $this->callableFactory->create($definition);
-
-            return $this->wrapMiddleware($callable);
-        } catch (InvalidCallableConfigurationException) {
-            // Not a callable, try internal checks
-        }
+        if (is_string($definition) || is_array($definition)) {
+            try {
+                return $this->wrapMiddleware($this->callableFactory->create($definition));
+            } catch (InvalidCallableConfigurationException) {
+                // Not a callable, try internal checks
+            }
 
-        if (is_string($definition)) {
-            return $this->getFromContainer($definition);
-        }
+            if (is_string($definition)) {
+                return $this->getFromContainer($definition);
+            }
 
-        if (is_array($definition)) {
             return $this->tryGetFromArrayDefinition($definition)
                 ?? throw new InvalidMiddlewareDefinitionException($definition);
         }
 
-        throw new InvalidMiddlewareDefinitionException($definition);
+        return $this->wrapMiddleware($this->callableFactory->create($definition));
     }
 
     /**

src/Middleware/Push/PushMiddlewareFactory.php

@@ -54,10 +54,6 @@ public function createPushMiddleware(mixed $middlewareDefinition): PushMiddlewar
 
         $middleware = $this->create($middlewareDefinition);
 
-        if (!$middleware instanceof PushMiddlewareInterface) {
-            throw new InvalidMiddlewareDefinitionException($middlewareDefinition);
-        }
-
         return $middleware;
     }
 

tests/Unit/Command/ListenAllCommandTest.php

@@ -39,4 +39,26 @@ public function testExecute(): void
 
         $this->assertEquals(0, $exitCode);
     }
+
+    public function testRunsWithNegativePause(): void
+    {
+        $queue = $this->createMock(QueueInterface::class);
+        $queue->method('run')->willReturn(1);
+
+        $queueProvider = new PredefinedQueueProvider([
+            'queue1' => $queue,
+        ]);
+
+        $loop = $this->createMock(LoopInterface::class);
+        $loop->method('canContinue')->willReturn(true, false);
+
+        $command = new ListenAllCommand(
+            $queueProvider,
+            $loop,
+        );
+        $input = new ArrayInput(['--pause' => -1], $command->getNativeDefinition());
+        $exitCode = $command->run($input, $this->createMock(OutputInterface::class));
+
+        $this->assertSame(0, $exitCode);
+    }
 }

tests/Unit/Debug/QueueDecoratorTest.php

@@ -124,4 +124,48 @@ public function testGetName(): void
 
         $this->assertEquals('hello', $decorator->getName());
     }
+
+    public function testWithMiddlewares(): void
+    {
+        $newQueue = $this->createMock(QueueInterface::class);
+        $newQueue->method('getName')->willReturn('new');
+        $queue = $this->createMock(QueueInterface::class);
+        $queue->expects($this->once())
+            ->method('withMiddlewares')
+            ->with('m1', 'm2')
+            ->willReturn($newQueue);
+        $collector = new QueueCollector();
+        $decorator = new QueueDecorator(
+            $queue,
+            $collector,
+        );
+
+        $result = $decorator->withMiddlewares('m1', 'm2');
+
+        $this->assertInstanceOf(QueueDecorator::class, $result);
+        $this->assertNotSame($decorator, $result);
+        $this->assertSame('new', $result->getName());
+    }
+
+    public function testWithMiddlewaresAdded(): void
+    {
+        $newQueue = $this->createMock(QueueInterface::class);
+        $newQueue->method('getName')->willReturn('new');
+        $queue = $this->createMock(QueueInterface::class);
+        $queue->expects($this->once())
+            ->method('withMiddlewaresAdded')
+            ->with('m1', 'm2')
+            ->willReturn($newQueue);
+        $collector = new QueueCollector();
+        $decorator = new QueueDecorator(
+            $queue,
+            $collector,
+        );
+
+        $result = $decorator->withMiddlewaresAdded('m1', 'm2');
+
+        $this->assertInstanceOf(QueueDecorator::class, $result);
+        $this->assertNotSame($decorator, $result);
+        $this->assertSame('new', $result->getName());
+    }
 }

tests/Unit/Message/EnvelopeTest.php

@@ -6,6 +6,7 @@
 
 use LogicException;
 use PHPUnit\Framework\TestCase;
+use Yiisoft\Queue\Message\GenericMessage;
 use Yiisoft\Queue\Stubs\DummyEnvelope;
 
 final class EnvelopeTest extends TestCase
@@ -18,4 +19,14 @@ public function testFromData(): void
         );
         DummyEnvelope::fromData('test', []);
     }
+
+    public function testWithMetadata(): void
+    {
+        $envelope = DummyEnvelope::fromMessage(new GenericMessage('test', 'data'));
+
+        $result = $envelope->withMetadata(['key' => 'value']);
+
+        $this->assertInstanceOf(DummyEnvelope::class, $result);
+        $this->assertSame(['key' => 'value'], $result->getMetadata());
+    }
 }

tests/Unit/Middleware/FailureHandling/FailureEnvelopeTest.php

@@ -23,6 +23,16 @@ public function testConstructor(): void
         $this->assertSame($metadata, $envelope->getMetadata()[FailureEnvelope::META_FAILURE]);
     }
 
+    public function testGetFailureMetadata(): void
+    {
+        $message = $this->createMessage();
+        $metadata = ['attempt' => 1, 'error' => 'Test error'];
+
+        $envelope = new FailureEnvelope($message, $metadata);
+
+        $this->assertSame($metadata, $envelope->getFailureMetadata());
+    }
+
     public function testFromMessageWithExistingMetadata(): void
     {
         $existingMetadata = ['attempt' => 1];

tests/Unit/Middleware/FailureHandling/Implementation/SendAgainMiddlewareTest.php

@@ -5,6 +5,7 @@
 namespace Yiisoft\Queue\Tests\Unit\Middleware\FailureHandling\Implementation;
 
 use Exception;
+use InvalidArgumentException;
 use PHPUnit\Framework\Assert;
 use PHPUnit\Framework\Attributes\DataProvider;
 use RuntimeException;
@@ -167,6 +168,22 @@ public function testQueueSendingStrategies(
         self::assertInstanceOf(FailureHandlingRequest::class, $result);
     }
 
+    public static function nonPositiveMaxAttemptsProvider(): array
+    {
+        return [
+            [0, 'maxAttempts parameter must be a positive integer, 0 given.'],
+            [-5, 'maxAttempts parameter must be a positive integer, -5 given.'],
+        ];
+    }
+
+    #[DataProvider('nonPositiveMaxAttemptsProvider')]
+    public function testThrowsOnNonPositiveMaxAttempts(int $maxAttempts, string $expectedMessage): void
+    {
+        $this->expectException(InvalidArgumentException::class);
+        $this->expectExceptionMessage($expectedMessage);
+        new SendAgainMiddleware('', $maxAttempts);
+    }
+
     private function getStrategy(string $strategyName, QueueInterface $queue): FailureMiddlewareInterface
     {
         return match ($strategyName) {

tests/Unit/Middleware/Push/MiddlewareFactoryTest.php

@@ -147,6 +147,7 @@ public static function invalidMiddlewareDefinitionProvider(): array
             'wrong array with int items' => [[7, 42]],
             'array with wrong method name' => [[TestCallableMiddleware::class, 'notExists']],
             'array wrong class' => [['class' => TestCallableMiddleware::class]],
+            'non-callable scalar' => [42],
         ];
     }
 

tests/Unit/Provider/QueueFactoryProviderTest.php

@@ -99,6 +99,20 @@ public function testInvalidQueueConfigOnGet(): void
         $provider->get('queue1');
     }
 
+    public function testInvalidQueueConfigThrownOnCreate(): void
+    {
+        $provider = new QueueFactoryProvider(
+            [
+                'queue1' => 42,
+            ],
+            validate: false,
+        );
+
+        $this->expectException(InvalidQueueConfigException::class);
+        $this->expectExceptionMessage('Invalid definition: 42');
+        $provider->get('queue1');
+    }
+
     public function testGetHasByStringEnum(): void
     {
         $provider = new QueueFactoryProvider(

tests/Unit/QueueTest.php

@@ -4,6 +4,7 @@
 
 namespace Yiisoft\Queue\Tests\Unit;
 
+use Yiisoft\Queue\Adapter\AdapterInterface;
 use Yiisoft\Queue\Cli\SignalLoop;
 use Yiisoft\Queue\Message\IdEnvelope;
 use Yiisoft\Queue\Message\GenericMessage;
@@ -32,6 +33,18 @@ public function testPushSuccessful(): void
         self::assertSame([$message], $adapter->getMessagesList());
     }
 
+    public function testPushLogsWhenIdNotAssigned(): void
+    {
+        $message = new GenericMessage('simple', null);
+        $adapter = $this->createMock(AdapterInterface::class);
+        $adapter->method('push')->willReturn($message);
+        $queue = $this->createQueue($adapter);
+
+        $result = $queue->push($message);
+
+        self::assertNull(IdEnvelope::fromMessage($result)->getId());
+    }
+
     public function testPushSynchronouslyProcessesMessage(): void
     {
         $queue = $this->createQueue();

tests/Unit/WorkerTest.php

@@ -14,6 +14,7 @@
 use Yiisoft\Test\Support\Log\SimpleLogger;
 use Yiisoft\Queue\Exception\MessageFailureException;
 use Yiisoft\Queue\Message\GenericMessage;
+use Yiisoft\Queue\Message\IdEnvelope;
 use Yiisoft\Queue\Message\MessageInterface;
 use Yiisoft\Queue\Middleware\Consume\ConsumeMiddlewareDispatcher;
 use Yiisoft\Queue\Middleware\Consume\ConsumeMiddlewareFactoryInterface;
@@ -86,6 +87,39 @@ function (MessageInterface $message) {
         ];
     }
 
+    public function testProcessLogsMessageId(): void
+    {
+        $message = new IdEnvelope(new GenericMessage('simple', ['test-data']), 'message-id-123');
+        $logger = new SimpleLogger();
+        $container = new SimpleContainer([FakeHandler::class => new FakeHandler()]);
+        $handlers = ['simple' => FakeHandler::class];
+
+        /** @var MockObject&QueueInterface $queue */
+        $queue = $this->createMock(QueueInterface::class);
+        $worker = $this->createWorkerByParams($handlers, $container, $logger);
+
+        $worker->process($message, $queue);
+        FakeHandler::$processedMessages = [];
+
+        $messages = $logger->getMessages();
+        $this->assertSame('Processing message #message-id-123.', $messages[0]['message']);
+    }
+
+    public function testProcessFailsForEmptyMessageType(): void
+    {
+        $message = new GenericMessage('', ['test-data']);
+        $container = new SimpleContainer();
+        $handlers = [];
+
+        /** @var MockObject&QueueInterface $queue */
+        $queue = $this->createMock(QueueInterface::class);
+        $worker = $this->createWorkerByParams($handlers, $container);
+
+        $this->expectException(RuntimeException::class);
+        $this->expectExceptionMessage('Queue handler for message type "" does not exist.');
+        $worker->process($message, $queue);
+    }
+
     public function testMessageFailWithDefinitionUndefinedMethodHandler(): void
     {
         $this->expectExceptionMessage('Queue handler for message type "simple" does not exist');