SqsIntegrationTest::stubQueueVisibilityTimeout() - Code Metrics - Inspection of "Merge pull request #39 from graze/php-55" - graze/queue - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 03ffe6...2c1c5a )

by Will

created 2017-03-24 11:15 UTC

SqsIntegrationTest::stubQueueVisibilityTimeout() A

↳ Parent: SqsIntegrationTest

Complexity

Conditions	1
Paths	1

Size

Total Lines	13
Code Lines	9

Duplication

Lines	13
Ratio	100 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
dl	13
loc	13
rs	9.4285
c	1
b	0
f	0
cc	1
eloc	9
nc	1
nop	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 Aws\ResultInterface;
use Aws\Sqs\SqsClient;
use Graze\Queue\Adapter\SqsAdapter;
use Mockery as m;
use Mockery\MockInterface;
use PHPUnit_Framework_TestCase as TestCase;

class SqsIntegrationTest extends TestCase
{
    /** @var string */
    private $queueName;
    /** @var SqsClient|MockInterface */
    private $sqsClient;
    /** @var Client */
    private $client;

    public function setUp()
    {
        $this->queueName = 'queue_foo';
        $this->sqsClient = m::mock(SqsClient::class);
        $this->client = new Client(new SqsAdapter($this->sqsClient, 'queue_foo'));
    }

    /**
     * Create a queue
     *
     * @return string
     */
    protected function stubCreateQueue()

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

        $this->sqsClient->shouldReceive('createQueue')->once()->with([
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.
}
            'QueueName'  => $this->queueName,
            'Attributes' => [],
        ])->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->sqsClient->shouldReceive('getQueueAttributes')->once()->with([
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.
}
            'QueueUrl'       => $url,
            'AttributeNames' => ['VisibilityTimeout'],
        ])->andReturn($model);

        return $timeout;
    }

    public function testReceive()

    {
        $url = $this->stubCreateQueue();
        $timeout = $this->stubQueueVisibilityTimeout($url);

        $receiveModel = m::mock(ResultInterface::class);
        $receiveModel->shouldReceive('get')->once()->with('Messages')->andReturn([
            ['Body' => 'foo', 'Attributes' => [], 'MessageAttributes' => [], 'MessageId' => 0, 'ReceiptHandle' => 'a'],
        ]);
        $this->sqsClient->shouldReceive('receiveMessage')->once()->with([
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.
}
            'QueueUrl'            => $url,
            'AttributeNames'      => ['All'],
            'MaxNumberOfMessages' => 1,
            'VisibilityTimeout'   => $timeout,
        ])->andReturn($receiveModel);

        $deleteModel = m::mock(ResultInterface::class);
        $deleteModel->shouldReceive('get')->once()->with('Failed')->andReturn([]);
        $this->sqsClient->shouldReceive('deleteMessageBatch')->once()->with([
            'QueueUrl' => $url,
            'Entries'  => [['Id' => 0, 'ReceiptHandle' => 'a']],
        ])->andReturn($deleteModel);

        $msgs = [];
        $this->client->receive(function ($msg) use (&$msgs) {
            $msgs[] = $msg;
        });

        assertThat($msgs, is(arrayWithSize(1)));
    }

    public function testReceiveWithReceiveMessageReturningLessThanMaxNumberOfMessages()
    {
        $url = $this->stubCreateQueue();
        $timeout = $this->stubQueueVisibilityTimeout($url);
$myVar = 'Value';
$higher = false;

if (rand(1, 6) > 3) {
    $higher = true;
} else {
    $higher = false;
}

        $receiveModel = m::mock(ResultInterface::class);
        $receiveModel->shouldReceive('get')->with('Messages')->andReturn(
            [
                [
                    'Body'              => 'foo',
                    'Attributes'        => [],
                    'MessageAttributes' => [],
                    'MessageId'         => 0,
                    'ReceiptHandle'     => 'a',
                ],
                [
                    'Body'              => 'foo',
                    'Attributes'        => [],
                    'MessageAttributes' => [],
                    'MessageId'         => 0,
                    'ReceiptHandle'     => 'a',
                ],
                [
                    'Body'              => 'foo',
                    'Attributes'        => [],
                    'MessageAttributes' => [],
                    'MessageId'         => 0,
                    'ReceiptHandle'     => 'a',
                ],
                [
                    'Body'              => 'foo',
                    'Attributes'        => [],
                    'MessageAttributes' => [],
                    'MessageId'         => 0,
                    'ReceiptHandle'     => 'a',
                ],
                [
                    'Body'              => 'foo',
                    'Attributes'        => [],
                    'MessageAttributes' => [],
                    'MessageId'         => 0,
                    'ReceiptHandle'     => 'a',
                ],
                [
                    'Body'              => 'foo',
                    'Attributes'        => [],
                    'MessageAttributes' => [],
                    'MessageId'         => 0,
                    'ReceiptHandle'     => 'a',
                ],
                [
                    'Body'              => 'foo',
                    'Attributes'        => [],
                    'MessageAttributes' => [],
                    'MessageId'         => 0,
                    'ReceiptHandle'     => 'a',
                ],
                [
                    'Body'              => 'foo',
                    'Attributes'        => [],
                    'MessageAttributes' => [],
                    'MessageId'         => 0,
                    'ReceiptHandle'     => 'a',
                ],
                [
                    'Body'              => 'foo',
                    'Attributes'        => [],
                    'MessageAttributes' => [],
                    'MessageId'         => 0,
                    'ReceiptHandle'     => 'a',
                ],
            ],
            [
                [
                    'Body'              => 'foo',
                    'Attributes'        => [],
                    'MessageAttributes' => [],
                    'MessageId'         => 0,
                    'ReceiptHandle'     => 'a',
                ],
                [
                    'Body'              => 'foo',
                    'Attributes'        => [],
                    'MessageAttributes' => [],
                    'MessageId'         => 0,
                    'ReceiptHandle'     => 'a',
                ],
            ],
            null
        );

        $this->sqsClient->shouldReceive('receiveMessage')->andReturn($receiveModel);
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.
}

        $deleteModel = m::mock(ResultInterface::class);
        $deleteModel->shouldReceive('get')->twice()->with('Failed')->andReturn([]);
        $this->sqsClient->shouldReceive('deleteMessageBatch')->with(m::type('array'))->andReturn($deleteModel);

        $msgs = [];
        $this->client->receive(function ($msg) use (&$msgs) {
            $msgs[] = $msg;
        }, 11);

        assertThat($msgs, is(arrayWithSize(11)));
    }

    public function testReceiveWithLimit()

    {
        $url = $this->stubCreateQueue();
        $timeout = $this->stubQueueVisibilityTimeout($url);

        $receiveModel = m::mock(ResultInterface::class);
        $receiveModel->shouldReceive('get')->once()->with('Messages')->andReturn([
            ['Body' => 'foo', 'Attributes' => [], 'MessageAttributes' => [], 'MessageId' => 0, 'ReceiptHandle' => 'a'],
        ]);
        $this->sqsClient->shouldReceive('receiveMessage')->once()->with([
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.
}
            'QueueUrl'            => $url,
            'AttributeNames'      => ['All'],
            'MaxNumberOfMessages' => SqsAdapter::BATCHSIZE_RECEIVE,
            'VisibilityTimeout'   => $timeout,
        ])->andReturn($receiveModel);

        $deleteModel = m::mock(ResultInterface::class);
        $deleteModel->shouldReceive('get')->once()->with('Failed')->andReturn([]);
        $this->sqsClient->shouldReceive('deleteMessageBatch')->once()->with([
            'QueueUrl' => $url,
            'Entries'  => [['Id' => 0, 'ReceiptHandle' => 'a']],
        ])->andReturn($deleteModel);

        $msgs = [];
        $this->client->receive(function ($msg, $done) use (&$msgs) {
            $msgs[] = $msg;
            $done();
        }, 100);

        assertThat($msgs, is(arrayWithSize(1)));
    }

    public function testReceiveWithPolling()

    {
        $url = $this->stubCreateQueue();
        $timeout = $this->stubQueueVisibilityTimeout($url);

        $receiveModel = m::mock(ResultInterface::class);
        $receiveModel->shouldReceive('get')->once()->with('Messages')->andReturn([
            ['Body' => 'foo', 'Attributes' => [], 'MessageAttributes' => [], 'MessageId' => 0, 'ReceiptHandle' => 'a'],
        ]);
        $this->sqsClient->shouldReceive('receiveMessage')->once()->with([
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.
}
            'QueueUrl'            => $url,
            'AttributeNames'      => ['All'],
            'MaxNumberOfMessages' => SqsAdapter::BATCHSIZE_RECEIVE,
            'VisibilityTimeout'   => $timeout,
        ])->andReturn($receiveModel);

        $deleteModel = m::mock(ResultInterface::class);
        $deleteModel->shouldReceive('get')->once()->with('Failed')->andReturn([]);
        $this->sqsClient->shouldReceive('deleteMessageBatch')->once()->with([
            'QueueUrl' => $url,
            'Entries'  => [['Id' => 0, 'ReceiptHandle' => 'a']],
        ])->andReturn($deleteModel);

        $msgs = [];
        $this->client->receive(function ($msg, $done) use (&$msgs) {
            $msgs[] = $msg;
            $done();
        }, null);

        assertThat($msgs, is(arrayWithSize(1)));
    }

    public function testSend()
    {
        $url = $this->stubCreateQueue();
        $model = m::mock(ResultInterface::class);
        $model->shouldReceive('get')->once()->with('Failed')->andReturn([]);

        $this->sqsClient->shouldReceive('sendMessageBatch')->once()->with([
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.
}
            'QueueUrl' => $url,
            'Entries'  => [['Id' => 0, 'MessageBody' => 'foo', 'MessageAttributes' => []]],
        ])->andReturn($model);

        $this->client->send([$this->client->create('foo')]);
    }

    public function testPurge()
    {
        $url = $this->stubCreateQueue();
        $timeout = $this->stubQueueVisibilityTimeout($url);

        $receiveModel = m::mock(ResultInterface::class);
        $receiveModel->shouldReceive('get')->once()->with('Messages')->andReturn([]);
        $this->sqsClient->shouldReceive('receiveMessage')->once()->with([
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.
}
            'QueueUrl'            => $url,
            'AttributeNames'      => ['All'],
            'MaxNumberOfMessages' => 1,
            'VisibilityTimeout'   => $timeout,
        ])->andReturn($receiveModel);

        $purgeModel = m::mock(ResultInterface::class);
        $this->sqsClient->shouldReceive('purgeQueue')->once()->with([
            'QueueUrl' => $url,
        ])->andReturn($purgeModel);

        $this->client->purge();

        $msgs = [];
        $this->client->receive(function ($msg) use (&$msgs) {
            $msgs[] = $msg;
        });

        assertThat($msgs, is(emptyArray()));
    }

    public function testDelete()
    {
        $url = $this->stubCreateQueue();

        $deleteModel = m::mock(ResultInterface::class);
        $this->sqsClient->shouldReceive('deleteQueue')->once()->with([
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.
}
            'QueueUrl' => $url,
        ])->andReturn($deleteModel);

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


Push — master ( 03ffe6...2c1c5a )

SqsIntegrationTest::stubQueueVisibilityTimeout() A

Complexity

Size

Duplication

Importance

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;
17
18			use Aws\ResultInterface;
19			use Aws\Sqs\SqsClient;
20			use Graze\Queue\Adapter\SqsAdapter;
21			use Mockery as m;
22			use Mockery\MockInterface;
23			use PHPUnit_Framework_TestCase as TestCase;
24
25			class SqsIntegrationTest extends TestCase
26			{
27			/** @var string */
28			private $queueName;
29			/** @var SqsClient\|MockInterface */
30			private $sqsClient;
31			/** @var Client */
32			private $client;
33
34			public function setUp()
35			{
36			$this->queueName = 'queue_foo';
37			$this->sqsClient = m::mock(SqsClient::class);
38			$this->client = new Client(new SqsAdapter($this->sqsClient, 'queue_foo'));
39			}
40

graze / queue

Push — master ( 03ffe6...2c1c5a )

SqsIntegrationTest::stubQueueVisibilityTimeout() A

Complexity

Size

Duplication

Importance

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