Graze\Queue\Adapter\ArrayAdapterTest

Complexity

Total Complexity

14

Size/Duplication

Total Lines	146
Duplicated Lines	0 %

Importance

Changes

0

14 Methods

Rating	Name	Duplication	Size	Complexity
A	testRejectOne()	0	7	1
A	testDequeueWithLimit()	0	5	1
A	testEnqueue()	0	13	1
A	testAcknowledge()	0	7	1
A	setUp()	0	10	1
A	testPurge()	0	11	1
A	testDequeueWithNoMessages()	0	7	1
A	testReject()	0	7	1
A	testInterface()	0	3	1
A	testAcknowledgeOne()	0	7	1
A	testDequeueWithLimitAndNoMessages()	0	7	1
A	testDequeueWithPollingLimit()	0	5	1
A	testDelete()	0	11	1
A	testDequeue()	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\Adapter;

use Graze\Queue\Message\MessageFactoryInterface;
use Graze\Queue\Message\MessageInterface;
use Mockery as m;
use Mockery\MockInterface;
use Graze\Queue\Test\TestCase;

class ArrayAdapterTest extends TestCase
{
    /** @var MessageFactoryInterface|MockInterface */
    private $factory;
    /** @var MessageInterface|MockInterface */
    private $messageA;
    /** @var MessageInterface|MockInterface */
    private $messageB;
    /** @var MessageInterface|MockInterface */
    private $messageC;
    /** @var MessageInterface[]|MockInterface[] */
    private $messages;
    /** @var ArrayAdapter */
    private $adapter;

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

        $this->messageA = $a = m::mock(MessageInterface::class);
        $this->messageB = $b = m::mock(MessageInterface::class);
        $this->messageC = $c = m::mock(MessageInterface::class);
        $this->messages = [$a, $b, $c];

        $this->adapter = new ArrayAdapter($this->messages);
    }

    public function testInterface()
    {
        assertThat($this->adapter, is(anInstanceOf(AdapterInterface::class)));
    }

    public function testAcknowledge()
    {
        $this->adapter->acknowledge($this->messages);

        $iterator = $this->adapter->dequeue($this->factory, 10);

It seems like $this->factory can also be of type Mockery\MockInterface; however, parameter $factory of Graze\Queue\Adapter\ArrayAdapter::dequeue() does only seem to accept Graze\Queue\Message\MessageFactoryInterface, maybe add an additional type check?

        assertThat(iterator_to_array($iterator), is(identicalTo([])));
    }

    public function testAcknowledgeOne()
    {
        $this->adapter->acknowledge([$this->messageB]);

        $iterator = $this->adapter->dequeue($this->factory, 10);

It seems like $this->factory can also be of type Mockery\MockInterface; however, parameter $factory of Graze\Queue\Adapter\ArrayAdapter::dequeue() does only seem to accept Graze\Queue\Message\MessageFactoryInterface, maybe add an additional type check?

        assertThat(iterator_to_array($iterator), is(identicalTo([$this->messageA, $this->messageC])));
    }

    public function testReject()
    {
        $this->adapter->reject($this->messages);

        $iterator = $this->adapter->dequeue($this->factory, 10);

It seems like $this->factory can also be of type Mockery\MockInterface; however, parameter $factory of Graze\Queue\Adapter\ArrayAdapter::dequeue() does only seem to accept Graze\Queue\Message\MessageFactoryInterface, maybe add an additional type check?

        assertThat(iterator_to_array($iterator), is(identicalTo($this->messages)));
    }

    public function testRejectOne()
    {
        $this->adapter->reject([$this->messageA]);

        $iterator = $this->adapter->dequeue($this->factory, 10);

It seems like $this->factory can also be of type Mockery\MockInterface; however, parameter $factory of Graze\Queue\Adapter\ArrayAdapter::dequeue() does only seem to accept Graze\Queue\Message\MessageFactoryInterface, maybe add an additional type check?

        assertThat(iterator_to_array($iterator), is(identicalTo($this->messages)));
    }

    public function testDequeue()
    {
        $iterator = $this->adapter->dequeue($this->factory, 10);

It seems like $this->factory can also be of type Mockery\MockInterface; however, parameter $factory of Graze\Queue\Adapter\ArrayAdapter::dequeue() does only seem to accept Graze\Queue\Message\MessageFactoryInterface, maybe add an additional type check?

        assertThat(iterator_to_array($iterator), is(identicalTo($this->messages)));
    }

    public function testDequeueWithLimit()
    {
        $iterator = $this->adapter->dequeue($this->factory, 1);

It seems like $this->factory can also be of type Mockery\MockInterface; however, parameter $factory of Graze\Queue\Adapter\ArrayAdapter::dequeue() does only seem to accept Graze\Queue\Message\MessageFactoryInterface, maybe add an additional type check?

        assertThat(iterator_to_array($iterator), is(identicalTo([$this->messageA])));
    }

    public function testDequeueWithPollingLimit()
    {
        $iterator = $this->adapter->dequeue($this->factory, null);

It seems like $this->factory can also be of type Mockery\MockInterface; however, parameter $factory of Graze\Queue\Adapter\ArrayAdapter::dequeue() does only seem to accept Graze\Queue\Message\MessageFactoryInterface, maybe add an additional type check?

        assertThat(iterator_to_array($iterator), is(identicalTo($this->messages)));
    }

    public function testDequeueWithNoMessages()
    {
        $adapter = new ArrayAdapter();

        $iterator = $adapter->dequeue($this->factory, null);

It seems like $this->factory can also be of type Mockery\MockInterface; however, parameter $factory of Graze\Queue\Adapter\ArrayAdapter::dequeue() does only seem to accept Graze\Queue\Message\MessageFactoryInterface, maybe add an additional type check?

        assertThat(iterator_to_array($iterator), is(emptyArray()));
    }

    public function testDequeueWithLimitAndNoMessages()
    {
        $adapter = new ArrayAdapter();

        $iterator = $adapter->dequeue($this->factory, 10);

It seems like $this->factory can also be of type Mockery\MockInterface; however, parameter $factory of Graze\Queue\Adapter\ArrayAdapter::dequeue() does only seem to accept Graze\Queue\Message\MessageFactoryInterface, maybe add an additional type check?

        assertThat(iterator_to_array($iterator), is(emptyArray()));
    }

    public function testEnqueue()
    {
        $messageA = m::mock(MessageInterface::class);
        $messageB = m::mock(MessageInterface::class);
        $messageC = m::mock(MessageInterface::class);
        $messages = [$messageA, $messageB, $messageC];
        $merged = array_merge($this->messages, $messages);

        $this->adapter->enqueue($messages);

        $iterator = $this->adapter->dequeue($this->factory, 10);

It seems like $this->factory can also be of type Mockery\MockInterface; however, parameter $factory of Graze\Queue\Adapter\ArrayAdapter::dequeue() does only seem to accept Graze\Queue\Message\MessageFactoryInterface, maybe add an additional type check?

        assertThat(iterator_to_array($iterator), is(identicalTo($merged)));
    }

    public function testPurge()
    {
        $iterator = $this->adapter->dequeue($this->factory, 10);

It seems like $this->factory can also be of type Mockery\MockInterface; however, parameter $factory of Graze\Queue\Adapter\ArrayAdapter::dequeue() does only seem to accept Graze\Queue\Message\MessageFactoryInterface, maybe add an additional type check?

        assertThat(iterator_to_array($iterator), is(nonEmptyArray()));

        $this->adapter->purge();

        $iterator = $this->adapter->dequeue($this->factory, 10);

        assertThat(iterator_to_array($iterator), is(emptyArray()));
    }

    public function testDelete()
    {
        $iterator = $this->adapter->dequeue($this->factory, 10);

It seems like $this->factory can also be of type Mockery\MockInterface; however, parameter $factory of Graze\Queue\Adapter\ArrayAdapter::dequeue() does only seem to accept Graze\Queue\Message\MessageFactoryInterface, maybe add an additional type check?

        assertThat(iterator_to_array($iterator), is(nonEmptyArray()));

        $this->adapter->delete();

        $iterator = $this->adapter->dequeue($this->factory, 10);

        assertThat(iterator_to_array($iterator), is(emptyArray()));
    }
}