NeedleProject\LaravelRabbitMq\Entity\QueueEntityTest

Complexity

Total Complexity

17

Size/Duplication

Total Lines	405
Duplicated Lines	0 %

Importance

Changes	5
Bugs	0	Features	1

16 Methods

Rating	Name	Duplication	Size	Complexity
A	testCreate()	0	10	1
A	testPublishMaxRetry()	0	26	1
A	testBind()	0	34	1
A	testPublishWithAutoCreate()	0	31	1
A	testCreateQueueByChannel()	0	39	1
A	testPublish()	0	27	1
A	testProcessorCallback()	0	27	1
A	testDeleteQueue()	0	29	1
A	testCreateQueueWithoutExceptionSuppressing()	0	21	1
A	testEmptyBind()	0	13	1
A	testCreateQueueWithExceptionSuppressing()	0	20	1
A	testPublishRetry()	0	33	2
A	testBindException()	0	22	1
A	testMessageProcessor()	0	9	1
A	testCreateWithDefaultAttributes()	0	22	1
A	testPrefetch()	0	9	1

<?php
namespace NeedleProject\LaravelRabbitMq\Entity;

use NeedleProject\LaravelRabbitMq\AMQPConnection;
use NeedleProject\LaravelRabbitMq\Processor\MessageProcessorInterface;
use PhpAmqpLib\Channel\AMQPChannel;
use PhpAmqpLib\Exception\AMQPChannelClosedException;
use PhpAmqpLib\Exception\AMQPProtocolChannelException;
use PhpAmqpLib\Message\AMQPMessage;
use PhpAmqpLib\Wire\AMQPTable;
use PHPUnit\Framework\TestCase;
use Psr\Log\LoggerInterface;
use Tests\NeedleProject\LaravelRabbitMq\Stubs\QueueEntityDetailsStub;

class QueueEntityTest extends TestCase
{
    public function testCreate()
    {
        $amqpConnection = $this->getMockBuilder(AMQPConnection::class)
            ->disableOriginalConstructor()
            ->getMock();

        $queue = QueueEntity::createQueue($amqpConnection, 'foo', []);

        $this->assertInstanceOf(QueueEntity::class, $queue);
        $this->assertEquals('foo', $queue->getAliasName());
    }

    public function testCreateWithDefaultAttributes()
    {
        $amqpConnection = $this->getMockBuilder(AMQPConnection::class)
            ->disableOriginalConstructor()
            ->getMock();

        $queue = QueueEntityDetailsStub::createQueue($amqpConnection, 'foo', []);

        $this->assertEquals(
            [
                'passive'                      => false,
                'durable'                      => false,
                'exclusive'                    => false,
                'auto_delete'                  => false,
                'nowait'                       => false,
                'arguments'                    => [],
                'auto_create'                  => false,
                'throw_exception_on_redeclare' => true,
                'throw_exception_on_bind_fail' => true,
                'ticket'                       => null
            ],
            $queue->getAttributes()
        );
    }

    public function testPrefetch()
    {
        $amqpConnection = $this->getMockBuilder(AMQPConnection::class)
            ->disableOriginalConstructor()
            ->getMock();

        $queue = QueueEntityDetailsStub::createQueue($amqpConnection, 'foo', []);
        $queue->setPrefetchCount(5);
        $this->assertEquals(5, $queue->prefetchCount());

The method prefetchCount() does not exist on Tests\NeedleProject\LaravelRabbitMq\Stubs\QueueEntityDetailsStub. Since you implemented __call, consider adding a @method annotation.

    }

    public function testMessageProcessor()
    {
        $amqpConnection = $this->getMockBuilder(AMQPConnection::class)
            ->disableOriginalConstructor()
            ->getMock();

        $queue = QueueEntityDetailsStub::createQueue($amqpConnection, 'foo', []);
        $queue->setMessageProcessor(self::class);
        $this->assertEquals(self::class, $queue->messageProcessor());

The method messageProcessor() does not exist on Tests\NeedleProject\LaravelRabbitMq\Stubs\QueueEntityDetailsStub. Since you implemented __call, consider adding a @method annotation.

    }

    public function testCreateQueueByChannel()
    {
        $amqpConnection = $this->getMockBuilder(AMQPConnection::class)
            ->disableOriginalConstructor()
            ->getMock();

        $channelMock = $this->createMock(AMQPChannel::class);

        $amqpConnection->expects($this->once())
            ->method('getChannel')
            ->willReturn($channelMock);

        $channelMock->expects($this->once())
            ->method('queue_declare')
            ->with(
                'queue.name.on.rabbit',
                'passive-value',
                'durable-value',
                'exclusive-value',
                'auto_delete-value',
                'nowait-value',
                new AMQPTable([])
            )
            ->willReturn(null);

        $queue = QueueEntity::createQueue(
            $amqpConnection,
            'foo',
            [
                'name'        => 'queue.name.on.rabbit',
                'passive'     => 'passive-value',
                'durable'     => 'durable-value',
                'exclusive'   => 'exclusive-value',
                'auto_delete' => 'auto_delete-value',
                'nowait'      => 'nowait-value',
                'arguments'   => [],
            ]
        );
        $queue->create();
    }

    public function testDeleteQueue()
    {
        $amqpConnection = $this->getMockBuilder(AMQPConnection::class)
            ->disableOriginalConstructor()
            ->getMock();

        $channelMock = $this->getMockBuilder(AMQPChannel::class)
            ->disableOriginalConstructor()
            ->getMock();

        $amqpConnection->expects($this->once())
            ->method('getChannel')
            ->willReturn($channelMock);

        $channelMock->expects($this->once())
            ->method('queue_delete')
            ->with(
                'queue.name.on.rabbit'
            )
            ->willReturn(null);

        $queue = QueueEntity::createQueue(
            $amqpConnection,
            'foo',
            [
                'name' => 'queue.name.on.rabbit'
            ]
        );
        $queue->delete();
    }

    public function testBind()
    {
        $amqpConnection = $this->createMock(AMQPConnection::class);
        $channelMock = $this->createMock(AMQPChannel::class);

        $amqpConnection->expects($this->exactly(2))
            ->method('getChannel')
            ->willReturn($channelMock);

        $matcher = $this->exactly(2);
        $matchingArgumentsOnFirstCall = ['queue.name.on.rabbit', 'first.exchange', 'a'];
        $matchingArgumentsOnSecondCall = ['queue.name.on.rabbit', 'second.exchange', 'b'];
        $channelMock->expects($matcher)
            ->method('queue_bind')
            ->willReturnCallback(
                function (string $queue, string $exchange, string $routingKey) use ($matcher, $matchingArgumentsOnFirstCall, $matchingArgumentsOnSecondCall) {
                    match ($matcher->numberOfInvocations()) {
                        1 =>  $this->assertEquals($matchingArgumentsOnFirstCall, [$queue, $exchange, $routingKey]),

Are you sure the usage of $this->assertEquals($matchingArgumentsOnFirstCall, array($queue, $exchange, $routingKey)) targeting PHPUnit\Framework\Assert::assertEquals() seems to always return null.

                        2 =>  $this->assertEquals($matchingArgumentsOnSecondCall, [$queue, $exchange, $routingKey]),

Are you sure the usage of $this->assertEquals($matchingArgumentsOnSecondCall, array($queue, $exchange, $routingKey)) targeting PHPUnit\Framework\Assert::assertEquals() seems to always return null.

                    };
                });

        $queue = QueueEntity::createQueue(
            $amqpConnection,
            'foo',
            [
                'name' => 'queue.name.on.rabbit',
                'bind' => [
                    ['exchange' => 'first.exchange', 'routing_key' => 'a'],
                    ['exchange' => 'second.exchange', 'routing_key' => 'b'],
                ]
            ]
        );
        $queue->bind();
    }

    public function testPublish()
    {
        $amqpConnection = $this->createMock(AMQPConnection::class);
        $channelMock = $this->createMock(AMQPChannel::class);

        $amqpConnection->expects($this->once())
            ->method('getChannel')
            ->willReturn($channelMock);

        $channelMock->expects($this->once())
            ->method('basic_publish')
            ->with(
                new AMQPMessage('a'),
                '',
                'queue.name.on.rabbit',
                true
            )
            ->willReturn(null);

        $queue = QueueEntity::createQueue(
            $amqpConnection,
            'foo',
            [
                'name' => 'queue.name.on.rabbit'
            ]
        );
        $queue->publish('a');
    }

    public function testCreateQueueWithExceptionSuppressing()
    {
        $amqpConnection = $this->createMock(AMQPConnection::class);
        $channelMock = $this->createMock(AMQPChannel::class);

        $amqpConnection->expects($this->once())
            ->method('getChannel')
            ->willReturn($channelMock);

        $channelMock->expects($this->once())
            ->method('queue_declare')
            ->willThrowException(
                new AMQPProtocolChannelException(406, 'Foo', [50,20])
            );

        $queue = QueueEntity::createQueue($amqpConnection, 'foo', [
            'name' => 'queue.name.on.rabbit',
            'throw_exception_on_redeclare' => false,
        ]);
        $queue->create();
    }

    public function testCreateQueueWithoutExceptionSuppressing()
    {
        $amqpConnection = $this->createMock(AMQPConnection::class);
        $channelMock = $this->createMock(AMQPChannel::class);

        $amqpConnection->expects($this->once())
            ->method('getChannel')
            ->willReturn($channelMock);

        $channelMock->expects($this->once())
            ->method('queue_declare')
            ->willThrowException(
                new AMQPProtocolChannelException(406, 'Foo', [50,20])
            );

        $queue = QueueEntity::createQueue($amqpConnection, 'foo', [
            'name' => 'queue.name.on.rabbit',
            'throw_exception_on_redeclare' => true,
        ]);
        $this->expectException(AMQPProtocolChannelException::class);
        $queue->create();
    }

    public function testBindException()
    {
        $amqpConnection = $this->createMock(AMQPConnection::class);
        $channelMock = $this->createMock(AMQPChannel::class);
        $amqpConnection->expects($this->once())
            ->method('getChannel')
            ->willReturn($channelMock);

        $channelMock->expects($this->once())
            ->method('queue_bind')
            ->willThrowException(
                new AMQPProtocolChannelException(406, 'Foo', [50,20])
            );

        $queue = QueueEntity::createQueue($amqpConnection, 'foo', [
            'name' => 'queue.name.on.rabbit',
            'bind' => [
                ['exchange' => 'foo.bar', 'routing_key' => '*']
            ]
        ]);
        $this->expectException(AMQPProtocolChannelException::class);
        $queue->bind();
    }

    public function testEmptyBind()
    {
        $amqpConnection = $this->createMock(AMQPConnection::class);

        $amqpConnection->expects($this->never())
            ->method('getChannel')
            ->willReturn(null);

        $queue = QueueEntity::createQueue($amqpConnection, 'foo', [
            'name' => 'queue.name.on.rabbit',
            'bind' => []
        ]);
        $queue->bind();
    }

    public function testPublishWithAutoCreate()
    {
        $amqpConnection = $this->createMock(AMQPConnection::class);
        $channelMock = $this->createMock(AMQPChannel::class);

        $amqpConnection->expects($this->exactly(3))
            ->method('getChannel')
            ->willReturn($channelMock);

        $channelMock->expects($this->once())
            ->method('queue_declare')
            ->willReturn(null);

        $channelMock->expects($this->once())
            ->method('queue_bind')
            ->willReturn(null);

        $channelMock->expects($this->once())
            ->method('basic_publish')
            ->willReturn(null);

        $queue = QueueEntity::createQueue(
            $amqpConnection,
            'foo',
            [
                'name' => 'queue.name.on.rabbit',
                'auto_create' => true,
                'bind' => [['exchange' => 'foo', 'routing_key' => '*']]
            ]
        );
        $queue->publish('a');
    }

    public function testProcessorCallback()
    {
        $amqpConnection = $this->createMock(AMQPConnection::class);
        $processorMock = $this->createMock(MessageProcessorInterface::class);
        $loggerMock = $this->createMock(LoggerInterface::class);

        $queue = QueueEntity::createQueue(
            $amqpConnection,
            'foo',
            [
                'name' => 'queue.name.on.rabbit',
                'auto_create' => true,
                'bind' => [['exchange' => 'foo', 'routing_key' => '*']]
            ]
        );
        $queue->setLogger($loggerMock);

        $class = new \ReflectionClass(get_class($queue));
        $property = $class->getProperty('messageProcessor');
        $property->setAccessible(true);
        $property->setValue($queue, $processorMock);

        $processorMock->expects($this->once())
            ->method('consume')
            ->willReturn(null);

        $queue->consume(new AMQPMessage('FooBar'));
    }

    public function testPublishRetry()
    {
        $amqpConnection = $this->createMock(AMQPConnection::class);
        $channelMock = $this->createMock(AMQPChannel::class);

        $amqpConnection->expects($this->atLeastOnce())
            ->method('getChannel')
            ->willReturn($channelMock);

        $amqpConnection->expects($this->atLeastOnce())
            ->method('reconnect')
            ->willReturn($channelMock);

        $retries = 0;
        $channelMock->expects($this->exactly(2))
            ->method('basic_publish')
            ->will($this->returnCallback(function ($args) use (&$retries) {

The function PHPUnit\Framework\TestCase::returnCallback() has been deprecated: Use <code>$double->willReturnCallback()</code> instead of <code>$double->will($this->returnCallback())</code>

The parameter $args is not used and could be removed.

                if (0 === $retries) {
                    $retries++;
                    throw new AMQPChannelClosedException("Channel is Closed");
                }
                return null;
            }));

        $queue = QueueEntity::createQueue(
            $amqpConnection,
            'foo',
            [
                'name' => 'queue.name.on.rabbit'
            ]
        );
        $queue->publish('a');
        $this->assertEquals(1, $retries);
    }

    public function testPublishMaxRetry()
    {
        $amqpConnection = $this->createMock(AMQPConnection::class);
        $channelMock = $this->createMock(AMQPChannel::class);

        $amqpConnection->expects($this->atLeastOnce())
            ->method('getChannel')
            ->willReturn($channelMock);

        $amqpConnection->expects($this->atLeastOnce())
            ->method('reconnect')
            ->willReturn($channelMock);

        $channelMock->expects($this->exactly(3))
            ->method('basic_publish')
            ->will($this->throwException(new AMQPChannelClosedException("Channel is Closed")));

        $queue = QueueEntity::createQueue(
            $amqpConnection,
            'foo',
            [
                'name' => 'queue.name.on.rabbit'
            ]
        );
        $this->expectException(AMQPChannelClosedException::class);
        $queue->publish('a');
    }
}