GetQueuedMessagesCommandTest.php

<?php

declare(strict_types=1);

namespace QueueTest\Swoole\Command;

use PHPUnit\Framework\MockObject\Exception;
use PHPUnit\Framework\MockObject\MockObject;
use PHPUnit\Framework\TestCase;
use Queue\App\Message\Message;
use Queue\Swoole\Command\GetQueuedMessagesCommand;
use Redis;
use RedisException;
use Symfony\Component\Console\Command\Command;
use Symfony\Component\Console\Exception\ExceptionInterface;
use Symfony\Component\Console\Input\ArrayInput;
use Symfony\Component\Console\Output\BufferedOutput;
use Symfony\Component\Messenger\Envelope;
use Symfony\Component\Messenger\Stamp\RedeliveryStamp;

use function addslashes;
use function array_keys;
use function count;
use function json_encode;
use function serialize;

class GetQueuedMessagesCommandTest extends TestCase
{
    private Redis|MockObject $redisMock;

    /**
     * @throws Exception
     */
    protected function setUp(): void
    {
        $this->redisMock = $this->createMock(Redis::class);
    }

    /**
     * @throws ExceptionInterface
     */
    public function testExecuteWithNoMessages(): void
    {
        $this->redisMock
            ->expects($this->once())
            ->method('xRange')
            ->with('messages', '-', '+')
            ->willReturn([]);

        $command = new GetQueuedMessagesCommand($this->redisMock);
        $input   = new ArrayInput(['--stream' => 'messages']);
        $output  = new BufferedOutput();

        $exitCode   = $command->run($input, $output);
        $outputText = $output->fetch();

        $this->assertEquals(Command::SUCCESS, $exitCode);
        $this->assertStringContainsString('No messages queued found', $outputText);
    }

    /**
     * @throws ExceptionInterface
     */
    public function testExecuteWithSimpleMessages(): void
    {
        $fakeMessages = [
            '1691000000000-0' => ['type' => 'testEmail', 'payload' => '{"to":"test@example.com"}'],
            '1691000000001-0' => ['type' => 'testEmail2', 'payload' => '{"to":"test@example2.com"}'],
        ];

        $this->redisMock
            ->expects($this->once())
            ->method('xRange')
            ->with('messages', '-', '+')
            ->willReturn($fakeMessages);

        $command = new GetQueuedMessagesCommand($this->redisMock);
        $input   = new ArrayInput(['--stream' => 'messages']);
        $output  = new BufferedOutput();

        $exitCode   = $command->run($input, $output);
        $outputText = $output->fetch();

        $this->assertEquals(Command::SUCCESS, $exitCode);

        foreach (array_keys($fakeMessages) as $id) {
            $this->assertStringContainsString('Message ID:', $outputText);
            $this->assertStringContainsString($id, $outputText);
        }

        $this->assertStringContainsString('Total queued messages in stream', $outputText);
        $this->assertStringContainsString((string) count($fakeMessages), $outputText);
    }

    /**
     * @throws ExceptionInterface
     */
    public function testRedisThrowsException(): void
    {
        $this->redisMock
            ->expects($this->once())
            ->method('xRange')
            ->willThrowException(new RedisException('Redis unavailable'));

        $command = new GetQueuedMessagesCommand($this->redisMock);
        $input   = new ArrayInput(['--stream' => 'messages']);
        $output  = new BufferedOutput();

        $this->expectException(RedisException::class);
        $command->run($input, $output);
    }

    public function testExecuteWithInvalidBody(): void
    {
        $invalidBodyJson = json_encode(['body' => 'not-a-serialized-envelope']);

        $this->redisMock
            ->expects($this->once())
            ->method('xRange')
            ->willReturn([
                '2-0' => ['body' => $invalidBodyJson],
            ]);

        $command = new GetQueuedMessagesCommand($this->redisMock);
        $input   = new ArrayInput(['--stream' => 'messages']);
        $output  = new BufferedOutput();

        $exitCode   = $command->run($input, $output);
        $outputText = $output->fetch();

        $this->assertEquals(Command::SUCCESS, $exitCode);
        $this->assertStringContainsString('failed to unserialize envelope', $outputText);
    }

    public function testExecuteWithValidEnvelope(): void
    {
        $message            = new Message(['foo' => 'bar']);
        $envelope           = new Envelope($message, [new RedeliveryStamp(1)]);
        $serializedEnvelope = serialize($envelope);
        $jsonBody           = json_encode(['body' => addslashes($serializedEnvelope)]);

        $this->redisMock
            ->expects($this->once())
            ->method('xRange')
            ->willReturn([
                '100-0' => ['body' => $jsonBody],
            ]);

        $command = new GetQueuedMessagesCommand($this->redisMock);
        $input   = new ArrayInput(['--stream' => 'messages']);
        $output  = new BufferedOutput();

        $exitCode   = $command->run($input, $output);
        $outputText = $output->fetch();

        $this->assertEquals(Command::SUCCESS, $exitCode);
        $this->assertStringContainsString('Message Class', $outputText);
        $this->assertStringContainsString('Payload', $outputText);
        $this->assertStringContainsString('Timestamps', $outputText);
    }
}