SqsAdapterTest - Code Metrics - Inspection of "use new make file" - graze/queue - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#40)

by Harry

created 2017-03-20 18:15 UTC

SqsAdapterTest A

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	343
Duplicated Lines	13.99 %

Coupling/Cohesion

Components	1
Dependencies	5

Importance

Changes

Metric	Value
wmc	18
lcom	1
cbo	5
dl	48
loc	343
rs	10
c	0
b	0
f	0

14 Methods

Rating	Name	Duplication	Size	Complexity
A	setUp()	0	11	1
A	stubCreateDequeueMessage()	0	9	4
A	stubCreateQueue()	13	13	1
A	stubQueueVisibilityTimeout()	13	13	1
A	testInterface()	0	4	1
A	testAcknowledge()	0	22	1
B	testDequeue()	0	28	1
B	testDequeueInBatches()	0	37	2
B	testEnqueue()	0	34	1
B	testEnqueueWithDelaySecondsMetadata()	0	35	1
B	testEnqueueWithDelaySecondsQueueConfiguration()	0	37	1
B	testReceiveMessageWaitTimeSecondsOption()	0	31	1
A	testPurge()	11	11	1
A	testDelete()	11	11	1

How to fix Duplicated Code

<?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\Sqs\SqsClient;
use Graze\DataStructure\Container\ContainerInterface;
use Graze\Queue\Message\MessageFactoryInterface;
use Graze\Queue\Message\MessageInterface;
use Mockery as m;
use Mockery\MockInterface;
use PHPUnit_Framework_TestCase as TestCase;

class SqsAdapterTest 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 SqsClient */
    private $client;

    public function setUp()
    {
        $this->client = m::mock(SqsClient::class);
        $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];
    }

    /**
     * @param string $body
     * @param int    $id
     * @param string $handle
     */
    protected function stubCreateDequeueMessage($body, $id, $handle)
    {
        $this->factory->shouldReceive('createMessage')->once()->with($body, m::on(function ($opts) use ($id, $handle) {
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            $meta = ['Attributes' => [], 'MessageAttributes' => [], 'MessageId' => $id, 'ReceiptHandle' => $handle];
            $validator = isset($opts['validator']) && is_callable($opts['validator']);

            return isset($opts['metadata']) && $opts['metadata'] === $meta && $validator;
        }))->andReturn($this->messageA);
    }

    /**
     * @param string $name
     * @param array  $options
     *
     * @return string
     */
    protected function stubCreateQueue($name, array $options = [])

    {
        $url = 'foo://bar';
        $model = m::mock(ResultInterface::class);
        $model->shouldReceive('get')->once()->with('QueueUrl')->andReturn($url);

        $this->client->shouldReceive('createQueue')->once()->with([
            'QueueName'  => $name,
            'Attributes' => $options,
        ])->andReturn($model);

        return $url;
    }

    /**
     * @param string $url
     *
     * @return int
     */
    protected function stubQueueVisibilityTimeout($url)

    {
        $timeout = 120;
        $model = m::mock(ResultInterface::class);
        $model->shouldReceive('get')->once()->with('Attributes')->andReturn(['VisibilityTimeout' => $timeout]);

        $this->client->shouldReceive('getQueueAttributes')->once()->with([
            'QueueUrl'       => $url,
            'AttributeNames' => ['VisibilityTimeout'],
        ])->andReturn($model);

        return $timeout;
    }

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

    public function testAcknowledge()
    {
        $adapter = new SqsAdapter($this->client, 'foo');
        $url = $this->stubCreateQueue('foo');

        $this->messageA->shouldReceive('getMetadata->get')->once()->with('ReceiptHandle')->andReturn('foo');
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
        $this->messageB->shouldReceive('getMetadata->get')->once()->with('ReceiptHandle')->andReturn('bar');
        $this->messageC->shouldReceive('getMetadata->get')->once()->with('ReceiptHandle')->andReturn('baz');

        $this->model->shouldReceive('get')->once()->with('Failed')->andReturn([]);
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}

        $this->client->shouldReceive('deleteMessageBatch')->once()->with([
            'QueueUrl' => $url,
            'Entries'  => [
                ['Id' => 0, 'ReceiptHandle' => 'foo'],
                ['Id' => 1, 'ReceiptHandle' => 'bar'],
                ['Id' => 2, 'ReceiptHandle' => 'baz'],
            ],
        ])->andReturn($this->model);

        $adapter->acknowledge($this->messages);
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
    }

    public function testDequeue()
    {
        $adapter = new SqsAdapter($this->client, 'foo');
        $url = $this->stubCreateQueue('foo');
        $timeout = $this->stubQueueVisibilityTimeout($url);

        $this->stubCreateDequeueMessage('foo', 0, 'a');
        $this->stubCreateDequeueMessage('bar', 1, 'b');
        $this->stubCreateDequeueMessage('baz', 2, 'c');

        $this->model->shouldReceive('get')->once()->with('Messages')->andReturn([
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ['Body' => 'foo', 'Attributes' => [], 'MessageAttributes' => [], 'MessageId' => 0, 'ReceiptHandle' => 'a'],
            ['Body' => 'bar', 'Attributes' => [], 'MessageAttributes' => [], 'MessageId' => 1, 'ReceiptHandle' => 'b'],
            ['Body' => 'baz', 'Attributes' => [], 'MessageAttributes' => [], 'MessageId' => 2, 'ReceiptHandle' => 'c'],
        ]);

        $this->client->shouldReceive('receiveMessage')->once()->with([
            'QueueUrl'            => $url,
            'AttributeNames'      => ['All'],
            'MaxNumberOfMessages' => 3,
            'VisibilityTimeout'   => $timeout,
        ])->andReturn($this->model);

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

        assertThat($iterator, is(anInstanceOf('Generator')));
        assertThat(iterator_to_array($iterator), is(equalTo($this->messages)));
    }

    public function testDequeueInBatches()
    {
        $adapter = new SqsAdapter($this->client, 'foo');
        $url = $this->stubCreateQueue('foo');
        $timeout = $this->stubQueueVisibilityTimeout($url);

        $limit = SqsAdapter::BATCHSIZE_RECEIVE;

        $return = [];
        $messages = [];

        for ($i = 0; $i < $limit; $i++) {
            $this->stubCreateDequeueMessage('tmp' . $i, $i, 'h' . $i);
            $return[] = [
                'Body'              => 'tmp' . $i,
                'Attributes'        => [],
                'MessageAttributes' => [],
                'MessageId'         => $i,
                'ReceiptHandle'     => 'h' . $i,
            ];
            $messages[] = $this->messageA;
        }

        $this->model->shouldReceive('get')->once()->with('Messages')->andReturn($return);
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}

        $this->client->shouldReceive('receiveMessage')->once()->with([
            'QueueUrl'            => $url,
            'AttributeNames'      => ['All'],
            'MaxNumberOfMessages' => $limit,
            'VisibilityTimeout'   => $timeout,
        ])->andReturn($this->model);

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

        assertThat($iterator, is(anInstanceOf('Generator')));
        assertThat(iterator_to_array($iterator), is(equalTo($messages)));
    }

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

        $metadata = m::mock(ContainerInterface::class);
        $metadata->shouldReceive('get')
                 ->with('MessageAttributes')
                 ->times(3)
                 ->andReturn(null);
        $metadata->shouldReceive('get')
                 ->with('DelaySeconds')
                 ->andReturn(null);

        $this->messageA->shouldReceive('getBody')->once()->withNoArgs()->andReturn('foo');
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
        $this->messageB->shouldReceive('getBody')->once()->withNoArgs()->andReturn('bar');
        $this->messageC->shouldReceive('getBody')->once()->withNoArgs()->andReturn('baz');
        $this->messageA->shouldReceive('getMetadata')->andReturn($metadata);
        $this->messageB->shouldReceive('getMetadata')->andReturn($metadata);
        $this->messageC->shouldReceive('getMetadata')->andReturn($metadata);

        $this->model->shouldReceive('get')->once()->with('Failed')->andReturn([]);
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}

        $this->client->shouldReceive('sendMessageBatch')->once()->with([
            'QueueUrl' => $url,
            'Entries'  => [
                ['Id' => 0, 'MessageBody' => 'foo', 'MessageAttributes' => []],
                ['Id' => 1, 'MessageBody' => 'bar', 'MessageAttributes' => []],
                ['Id' => 2, 'MessageBody' => 'baz', 'MessageAttributes' => []],
            ],
        ])->andReturn($this->model);

        $adapter->enqueue($this->messages);
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
    }

    public function testEnqueueWithDelaySecondsMetadata()
    {
        $adapter = new SqsAdapter($this->client, 'foo');
        $url = $this->stubCreateQueue('foo');

        $metadataA = m::mock(ContainerInterface::class);
        $metadataA->shouldReceive('get')->with('MessageAttributes')->once()->andReturn(null);
        $metadataA->shouldReceive('get')->with('DelaySeconds')->andReturn(1);
        $metadataB = m::mock(ContainerInterface::class);
        $metadataB->shouldReceive('get')->with('MessageAttributes')->once()->andReturn(null);
        $metadataB->shouldReceive('get')->with('DelaySeconds')->andReturn(2);
        $metadataC = m::mock(ContainerInterface::class);
        $metadataC->shouldReceive('get')->with('MessageAttributes')->once()->andReturn(null);
        $metadataC->shouldReceive('get')->with('DelaySeconds')->andReturn(3);

        $this->messageA->shouldReceive('getBody')->once()->withNoArgs()->andReturn('foo');
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
        $this->messageB->shouldReceive('getBody')->once()->withNoArgs()->andReturn('bar');
        $this->messageC->shouldReceive('getBody')->once()->withNoArgs()->andReturn('baz');
        $this->messageA->shouldReceive('getMetadata')->andReturn($metadataA);
        $this->messageB->shouldReceive('getMetadata')->andReturn($metadataB);
        $this->messageC->shouldReceive('getMetadata')->andReturn($metadataC);

        $this->model->shouldReceive('get')->once()->with('Failed')->andReturn([]);
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}

        $this->client->shouldReceive('sendMessageBatch')->once()->with([
            'QueueUrl' => $url,
            'Entries'  => [
                ['Id' => 0, 'MessageBody' => 'foo', 'MessageAttributes' => [], 'DelaySeconds' => 1],
                ['Id' => 1, 'MessageBody' => 'bar', 'MessageAttributes' => [], 'DelaySeconds' => 2],
                ['Id' => 2, 'MessageBody' => 'baz', 'MessageAttributes' => [], 'DelaySeconds' => 3],
            ],
        ])->andReturn($this->model);

        $adapter->enqueue($this->messages);
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
    }

    public function testEnqueueWithDelaySecondsQueueConfiguration()
    {
        $options = ['DelaySeconds' => 10];

        $adapter = new SqsAdapter($this->client, 'foo', $options);
        $url = $this->stubCreateQueue('foo', $options);

        $metadataA = m::mock(ContainerInterface::class);
        $metadataA->shouldReceive('get')->with('MessageAttributes')->once()->andReturn(null);
        $metadataA->shouldReceive('get')->with('DelaySeconds')->andReturn(null);
        $metadataB = m::mock(ContainerInterface::class);
        $metadataB->shouldReceive('get')->with('MessageAttributes')->once()->andReturn(null);
        $metadataB->shouldReceive('get')->with('DelaySeconds')->andReturn(0);
        $metadataC = m::mock(ContainerInterface::class);
        $metadataC->shouldReceive('get')->with('MessageAttributes')->once()->andReturn(null);
        $metadataC->shouldReceive('get')->with('DelaySeconds')->andReturn(2);

        $this->messageA->shouldReceive('getBody')->once()->withNoArgs()->andReturn('foo');
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
        $this->messageB->shouldReceive('getBody')->once()->withNoArgs()->andReturn('bar');
        $this->messageC->shouldReceive('getBody')->once()->withNoArgs()->andReturn('baz');
        $this->messageA->shouldReceive('getMetadata')->andReturn($metadataA);
        $this->messageB->shouldReceive('getMetadata')->andReturn($metadataB);
        $this->messageC->shouldReceive('getMetadata')->andReturn($metadataC);

        $this->model->shouldReceive('get')->once()->with('Failed')->andReturn([]);
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}

        $this->client->shouldReceive('sendMessageBatch')->once()->with([
            'QueueUrl' => $url,
            'Entries'  => [
                ['Id' => 0, 'MessageBody' => 'foo', 'MessageAttributes' => []],
                ['Id' => 1, 'MessageBody' => 'bar', 'MessageAttributes' => [], 'DelaySeconds' => 0],
                ['Id' => 2, 'MessageBody' => 'baz', 'MessageAttributes' => [], 'DelaySeconds' => 2],
            ],
        ])->andReturn($this->model);

        $adapter->enqueue($this->messages);
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
    }

    public function testReceiveMessageWaitTimeSecondsOption()
    {
        $options = ['ReceiveMessageWaitTimeSeconds' => 20];

        $adapter = new SqsAdapter($this->client, 'foo', $options);
        $url = $this->stubCreateQueue('foo', $options);
        $timeout = $this->stubQueueVisibilityTimeout($url);

        $this->stubCreateDequeueMessage('foo', 0, 'a');
        $this->stubCreateDequeueMessage('bar', 1, 'b');
        $this->stubCreateDequeueMessage('baz', 2, 'c');

        $this->model->shouldReceive('get')->once()->with('Messages')->andReturn([
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ['Body' => 'foo', 'Attributes' => [], 'MessageAttributes' => [], 'MessageId' => 0, 'ReceiptHandle' => 'a'],
            ['Body' => 'bar', 'Attributes' => [], 'MessageAttributes' => [], 'MessageId' => 1, 'ReceiptHandle' => 'b'],
            ['Body' => 'baz', 'Attributes' => [], 'MessageAttributes' => [], 'MessageId' => 2, 'ReceiptHandle' => 'c'],
        ]);

        $this->client->shouldReceive('receiveMessage')->once()->with([
            'QueueUrl'            => $url,
            'AttributeNames'      => ['All'],
            'MaxNumberOfMessages' => 3,
            'VisibilityTimeout'   => $timeout,
            'WaitTimeSeconds'     => 20,
        ])->andReturn($this->model);

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

        assertThat($iterator, is(anInstanceOf('Generator')));
        assertThat(iterator_to_array($iterator), is(equalTo($this->messages)));
    }

    public function testPurge()

    {
        $adapter = new SqsAdapter($this->client, 'foo');
        $url = $this->stubCreateQueue('foo');

        $this->client->shouldReceive('purgeQueue')->once()->with([
            'QueueUrl' => $url,
        ])->andReturn($this->model);

        assertThat($adapter->purge(), is(nullValue()));
    }

    public function testDelete()

    {
        $adapter = new SqsAdapter($this->client, 'foo');
        $url = $this->stubCreateQueue('foo');

        $this->client->shouldReceive('deleteQueue')->once()->with([
            'QueueUrl' => $url,
        ])->andReturn($this->model);

        assertThat($adapter->delete(), is(nullValue()));
    }
}


Pull Request — master (#40)

SqsAdapterTest A

Complexity

Size/Duplication

Coupling/Cohesion

Importance

14 Methods

How to fix Duplicated Code

Duplicated Code

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

1			<?php
2
3			/**
4			* This file is part of graze/queue.
5			*
6			* Copyright (c) 2015 Nature Delivered Ltd. <https://www.graze.com>
7			*
8			* For the full copyright and license information, please view the LICENSE
9			* file that was distributed with this source code.
10			*
11			* @license https://github.com/graze/queue/blob/master/LICENSE MIT
12			*
13			* @link https://github.com/graze/queue
14			*/
15
16			namespace Graze\Queue\Adapter;
17
18			use Aws\ResultInterface;
19			use Aws\Sqs\SqsClient;
20			use Graze\DataStructure\Container\ContainerInterface;
21			use Graze\Queue\Message\MessageFactoryInterface;
22			use Graze\Queue\Message\MessageInterface;
23			use Mockery as m;
24			use Mockery\MockInterface;
25			use PHPUnit_Framework_TestCase as TestCase;
26
27			class SqsAdapterTest extends TestCase
28			{
29			/** @var MessageInterface\|MockInterface */
30			private $messageA;
31			/** @var MessageInterface\|MockInterface */
32			private $messageB;
33			/** @var MessageInterface\|MockInterface */
34			private $messageC;
35			/** @var MessageInterface[]\|MockInterface[] */
36			private $messages;
37			/** @var ResultInterface\|MockInterface */
38			private $model;
39			/** @var MessageFactoryInterface\|MockInterface */
40			private $factory;

graze / queue

Pull Request — master (#40)

SqsAdapterTest A

Complexity

Size/Duplication

Coupling/Cohesion

Importance

14 Methods

How to fix Duplicated Code

Duplicated Code

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Duplication Side-by-Side

Filter issues like