QueueTest.php

<?php

declare(strict_types=1);

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;
use Yiisoft\Queue\MessageStatus;
use Yiisoft\Queue\Stubs\InMemoryAdapter;
use Yiisoft\Queue\Tests\TestCase;

use function extension_loaded;

// Test enum for BackedEnum testing
enum TestQueue: string
{
    case DEFAULT = 'default';
    case HIGH_PRIORITY = 'high-priority';
}

final class QueueTest extends TestCase
{
    public function testPushSuccessful(): void
    {
        $adapter = new InMemoryAdapter();
        $queue = $this->createQueue($adapter);
        $message = new GenericMessage('simple', null);
        $queue->push($message);

        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();
        $message = new GenericMessage('simple', null);

        $queue->push($message);
        $queue->push(clone $message);

        self::assertSame(2, $this->executionTimes);
    }

    public function testRunWithoutAdapterReturnsZero(): void
    {
        $queue = $this->createQueue();
        $message = new GenericMessage('simple', null);
        $queue->push($message);
        $queue->push(clone $message);

        self::assertSame(0, $queue->run());
        self::assertSame(2, $this->executionTimes);
    }

    public function testListenWithoutAdapter(): void
    {
        $queue = $this->createQueue();

        $queue->listen();

        $this->expectNotToPerformAssertions();
    }

    public function testStatusReturnsNotFoundWithoutAdapter(): void
    {
        $queue = $this->createQueue();

        self::assertSame(MessageStatus::NOT_FOUND, $queue->status('1'));
    }

    public function testRunWithAdapter(): void
    {
        $queue = $this->createQueue(new InMemoryAdapter());
        $message = new GenericMessage('simple', null);
        $queue->push($message);
        $queue->push(clone $message);

        self::assertSame(2, $queue->run());
        self::assertSame(2, $this->executionTimes);
    }

    public function testRunPartlyWithAdapter(): void
    {
        $queue = $this->createQueue(new InMemoryAdapter());
        $message = new GenericMessage('simple', null);
        $queue->push($message);
        $queue->push(clone $message);

        self::assertSame(1, $queue->run(1));
        self::assertSame(1, $this->executionTimes);
    }

    public function testListenWithAdapter(): void
    {
        $queue = $this->createQueue(new InMemoryAdapter());
        $message = new GenericMessage('simple', null);
        $queue->push($message);
        $queue->push(clone $message);

        $queue->listen();

        self::assertSame(2, $this->executionTimes);
    }

    public function testStatusWithAdapter(): void
    {
        $queue = $this->createQueue(new InMemoryAdapter());
        $envelope = $queue->push(new GenericMessage('simple', null));

        self::assertArrayHasKey(IdEnvelope::META_ID, $envelope->getMetadata());
        /** @var int|string $id */
        $id = $envelope->getMetadata()[IdEnvelope::META_ID];

        self::assertSame(MessageStatus::WAITING, $queue->status($id));

        $queue->run();
        self::assertSame(MessageStatus::DONE, $queue->status($id));
    }

    public function testRunWithSignalLoop(): void
    {
        if (!extension_loaded('pcntl')) {
            $this->markTestSkipped('This rest requires PCNTL extension');
        }

        $this->loop = new SignalLoop();
        $queue = $this->createQueue();
        $message = new GenericMessage('simple', null);
        $queue->push($message);
        $queue->push(clone $message);

        self::assertSame(0, $queue->run());
        self::assertSame(2, $this->executionTimes);
    }

    public function testGetName(): void
    {
        $queue = $this->createQueue(name: 'test-queue');

        $this->assertSame('test-queue', $queue->getName());
    }

    public function testGetNameWithBackedEnum(): void
    {
        $queue = $this->createQueue(name: TestQueue::HIGH_PRIORITY);

        $this->assertSame('high-priority', $queue->getName());
    }
}