Graze\Queue\Adapter\FirehoseAdapterTest

Complexity

Total Complexity

7

Size/Duplication

Total Lines	90
Duplicated Lines	0 %

Importance

Changes

0

7 Methods

Rating	Name	Duplication	Size	Complexity
A	setUp()	0	10	1
A	testInterface()	0	3	1
A	testDelete()	0	4	1
A	testAcknowledge()	0	4	1
A	testPurge()	0	4	1
A	testDequeue()	0	4	1
A	testEnqueue()	0	20	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 Aws\ResultInterface;
use Aws\Firehose\FirehoseClient;
use Graze\Queue\Adapter\Exception\MethodNotSupportedException;
use Graze\Queue\Message\MessageFactoryInterface;
use Graze\Queue\Message\MessageInterface;
use Mockery as m;
use Mockery\MockInterface;
use Graze\Queue\Test\TestCase;

class FirehoseAdapterTest extends TestCase
{
    /** @var MessageInterface|MockInterface */
    private $messageA;
    /** @var MessageInterface|MockInterface */
    private $messageB;
    /** @var MessageInterface|MockInterface */
    private $messageC;
    /** @var MessageInterface[]|MockInterface[] */
    private $messages;
    /** @var ResultInterface|MockInterface */
    private $model;
    /** @var MessageFactoryInterface|MockInterface */
    private $factory;
    /** @var FirehoseClient */
    private $client;

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

It seems like Mockery::mock(Aws\Firehose\FirehoseClient::class) of type Mockery\MockInterface is incompatible with the declared type Aws\Firehose\FirehoseClient of property $client.

        $this->model = m::mock(ResultInterface::class);
        $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];
    }

    public function testInterface()
    {
        assertThat(new FirehoseAdapter($this->client, 'foo'), is(anInstanceOf('Graze\Queue\Adapter\AdapterInterface')));
    }

    public function testEnqueue()
    {
        $adapter = new FirehoseAdapter($this->client, 'foo');

        $this->messageA->shouldReceive('getBody')->once()->withNoArgs()->andReturn('foo');

The method shouldReceive() does not exist on Graze\Queue\Message\MessageInterface.

        $this->messageB->shouldReceive('getBody')->once()->withNoArgs()->andReturn('bar');
        $this->messageC->shouldReceive('getBody')->once()->withNoArgs()->andReturn('baz');

        $this->model->shouldReceive('get')->once()->with('RequestResponses')->andReturn([]);

The method shouldReceive() does not exist on Aws\ResultInterface.

        $this->client->shouldReceive('putRecordBatch')->once()->with([
            'DeliveryStreamName' => 'foo',
            'Records' => [
                ['Data' => 'foo'],
                ['Data' => 'bar'],
                ['Data' => 'baz'],
            ],
        ])->andReturn($this->model);

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

    /**
     * @expectedException \Graze\Queue\Adapter\Exception\MethodNotSupportedException
     */
    public function testAcknowledge()
    {
        $adapter = new FirehoseAdapter($this->client, 'foo');
        $adapter->acknowledge($this->messages);
    }

    /**
     * @expectedException \Graze\Queue\Adapter\Exception\MethodNotSupportedException
     */
    public function testDequeue()
    {
        $adapter = new FirehoseAdapter($this->client, 'foo');
        $adapter->dequeue($this->factory, 10);

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

    }

    /**
     * @expectedException \Graze\Queue\Adapter\Exception\MethodNotSupportedException
     */
    public function testPurge()
    {
        $adapter = new FirehoseAdapter($this->client, 'foo');
        $adapter->purge();
    }

    /**
     * @expectedException \Graze\Queue\Adapter\Exception\MethodNotSupportedException
     */
    public function testDelete()
    {
        $adapter = new FirehoseAdapter($this->client, 'foo');
        $adapter->delete();
    }
}