Graze\Queue\ClientTest

Complexity

Total Complexity

7

Size/Duplication

Total Lines	83
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	3

Importance

Changes	1
Bugs	0	Features	0

7 Methods

Rating	Name	Duplication	Size	Complexity
A	setUp()	0	16	1
A	testInterface()	0	7	1
A	testCreate()	0	6	1
A	testSend()	0	6	1
A	testReceive()	0	12	1
A	testPurge()	0	5	1
A	testDelete()	0	5	1

<?php

/**
 * This file is part of graze/queue.
 *
 * Copyright (c) 2015 Nature Delivered Ltd. <https://www.graze.com>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 *
 * @license https://github.com/graze/queue/blob/master/LICENSE MIT
 *
 * @link    https://github.com/graze/queue
 */

namespace Graze\Queue;

use ArrayIterator;
use Graze\Queue\Adapter\AdapterInterface;
use Graze\Queue\Handler\AbstractAcknowledgementHandler;
use Graze\Queue\Message\MessageFactoryInterface;
use Graze\Queue\Message\MessageInterface;
use Mockery as m;
use Mockery\MockInterface;
use PHPUnit_Framework_TestCase as TestCase;

class ClientTest extends TestCase
{
    /** @var AdapterInterface|MockInterface */
    private $adapter;
    /** @var MessageFactoryInterface|MockInterface */
    private $factory;
    /** @var AbstractAcknowledgementHandler|MockInterface */
    private $handler;
    /** @var MessageInterface|MockInterface */
    private $messageA;
    /** @var MessageInterface|MockInterface */
    private $messageB;
    /** @var MessageInterface|MockInterface */
    private $messageC;
    /** @var MessageInterface[]|MockInterface[] */
    private $messages;
    /** @var Client */
    private $client;

    public function setUp()
    {
        $this->adapter = m::mock(AdapterInterface::class);
        $this->factory = m::mock(MessageFactoryInterface::class);
        $this->handler = m::mock(AbstractAcknowledgementHandler::class);

        $this->messageA = $a = m::mock(MessageInterface::class);

Avoid variables with short names like $a. Configured minimum length is 2.

        $this->messageB = $b = m::mock(MessageInterface::class);

Avoid variables with short names like $b. Configured minimum length is 2.

        $this->messageC = $c = m::mock(MessageInterface::class);

Avoid variables with short names like $c. Configured minimum length is 2.

        $this->messages = [$a, $b, $c];

        $this->client = new Client($this->adapter, [
            'handler'         => $this->handler,
            'message_factory' => $this->factory,
        ]);
    }

    public function testInterface()
    {
        assertThat($this->client, is(anInstanceOf(ConsumerInterface::class)));
        assertThat($this->client, is(anInstanceOf(DeleterInterface::class)));
        assertThat($this->client, is(anInstanceOf(ProducerInterface::class)));
        assertThat($this->client, is(anInstanceOf(PurgerInterface::class)));
    }

    public function testCreate()
    {
        $this->factory->shouldReceive('createMessage')->once()->with('foo', ['bar'])->andReturn($this->messageA);

The method shouldReceive does only exist in Mockery\MockInterface, but not in Graze\Queue\Message\MessageFactoryInterface.

        assertThat($this->client->create('foo', ['bar']), is(identicalTo($this->messageA)));
    }

    public function testSend()
    {
        $this->adapter->shouldReceive('enqueue')->once()->with($this->messages);

The method shouldReceive does only exist in Mockery\MockInterface, but not in Graze\Queue\Adapter\AdapterInterface.

        $this->client->send($this->messages);

$this->messages is of type array<integer,object<Mockery\MockInterface>>, but the function expects a array<integer,object<Graze\Queue\Message\MessageInterface>>.

    }

    public function testReceive()
    {
        $worker = function () {
        };

        $messages = new ArrayIterator($this->messages);

        $this->adapter->shouldReceive('dequeue')->once()->with($this->factory, 1)->andReturn($messages);

The method shouldReceive does only exist in Mockery\MockInterface, but not in Graze\Queue\Adapter\AdapterInterface.

        $this->handler->shouldReceive('__invoke')->once()->with($messages, $this->adapter, $worker);

The method shouldReceive does only exist in Mockery\MockInterface, but not in Graze\Queue\Handler\AbstractAcknowledgementHandler.

        $this->client->receive($worker);
    }

    public function testPurge()
    {
        $this->adapter->shouldReceive('purge')->once();

The method shouldReceive does only exist in Mockery\MockInterface, but not in Graze\Queue\Adapter\AdapterInterface.

        $this->client->purge();
    }

    public function testDelete()
    {
        $this->adapter->shouldReceive('delete')->once();

The method shouldReceive does only exist in Mockery\MockInterface, but not in Graze\Queue\Adapter\AdapterInterface.

        $this->client->delete();
    }
}