QueueTest::testSetOptionsWithArray() - Code Metrics - Inspection of "v0.2.0" - thomasvargiu/AMQPAL - Measure and Improve Code Quality continuously with Scrutinizer

Completed
Push — master ( 4cd93a...e8f4ec )

by Thomas Mauro
created 2016-03-26 14:18 UTC
QueueTest::testSetOptionsWithArray() A

↳ Parent: QueueTest
Complexity

Conditions	1
Paths	1
Size

Total Lines	18
Code Lines	13
Duplication

Lines	0
Ratio	0 %
Importance

Changes	1
Bugs	1	Features	0
Metric	Value
c	1
b	1
f	0
dl	0
loc	18
rs	9.4285
cc	1
eloc	13
nc	1
nop	0
<?php

namespace AMQPAL\Adapter\AMQP;

use AMQPAL\Adapter\Message;
use AMQPAL\Options;
use Prophecy\Argument;

class QueueTest extends \PHPUnit_Framework_TestCase
{

    public function testSetResource()
    {
        $resource = $this->prophesize(\AMQPQueue::class);

        $exchange = new Queue();
        $exchange->setResource($resource->reveal());

        static::assertSame($resource->reveal(), $exchange->getResource());
    }

    public function testGetDefaultMessageMapper()
    {
        $exchange = new Queue();

        static::assertInstanceOf(MessageMapper::class, $exchange->getMessageMapper());
    }

    public function testSetOptions()
    {
        $options = $this->getDefaultOptionsProphet();
        $resource = $this->prophesize(\AMQPQueue::class);

        $resource->setFlags(AMQP_NOPARAM | AMQP_DURABLE | AMQP_PASSIVE | AMQP_AUTODELETE | AMQP_EXCLUSIVE)
            ->shouldBeCalled();
        $resource->setName('queueName')->shouldBeCalled();
        $resource->setArguments(['arg1' => 'value1'])->shouldBeCalled();

        $queue = new Queue();
        $queue->setResource($resource->reveal());

        static::assertSame($queue, $queue->setOptions($options->reveal()));
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.
}
        static::assertSame($options->reveal(), $queue->getOptions());
    }

    public function testSetOptionsWithArray()
    {
        $options = ['name' => 'queueName'];
        $resource = $this->prophesize(\AMQPQueue::class);

        $resource->setFlags(Argument::any())
            ->shouldBeCalled();
        $resource->setName('queueName')->shouldBeCalled();
        $resource->setArguments([])->shouldBeCalled();

        $queue = new Queue();
        $queue->setResource($resource->reveal());

        static::assertSame($queue, $queue->setOptions($options));
        $queueOptions = $queue->getOptions();
        static::assertInstanceOf(Options\QueueOptions::class, $queueOptions);
        static::assertEquals('queueName', $queueOptions->getName());
    }

    public function testDeclareQueue()
    {
        $options = $this->getDefaultOptionsProphet();
        $resource = $this->prophesize(\AMQPQueue::class);

        $resource->setFlags(AMQP_NOPARAM | AMQP_DURABLE | AMQP_PASSIVE | AMQP_AUTODELETE | AMQP_EXCLUSIVE)
            ->shouldBeCalled();
        $resource->setName('queueName')->shouldBeCalled();
        $resource->setArguments(['arg1' => 'value1'])->shouldBeCalled();

        $resource->declareQueue()->shouldBeCalled();

        $exchange = new Queue();
        $exchange->setResource($resource->reveal());
        $exchange->setOptions($options->reveal());
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.
}

        static::assertSame($exchange, $exchange->declareQueue());
    }

    /**
     * @dataProvider deleteProvider()
     */
    public function testDelete($ifUnused, $ifEmpty, $noWait, $flags)
    {
        $options = $this->getDefaultOptionsProphet();
        $resource = $this->prophesize(\AMQPQueue::class);

        $resource->setFlags(AMQP_NOPARAM | AMQP_DURABLE | AMQP_PASSIVE | AMQP_AUTODELETE | AMQP_EXCLUSIVE)
            ->shouldBeCalled();
        $resource->setName('queueName')->shouldBeCalled();
        $resource->setArguments(['arg1' => 'value1'])->shouldBeCalled();

        $resource->delete($flags)->shouldBeCalled();

        $exchange = new Queue();
        $exchange->setResource($resource->reveal());
        $exchange->setOptions($options->reveal());
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.
}

        static::assertSame($exchange, $exchange->delete($ifUnused, $ifEmpty, $noWait));
    }

    public function testBind()
    {
        $arguments = ['arg2' => 'value2'];

        $options = $this->getDefaultOptionsProphet();
        $resource = $this->prophesize(\AMQPQueue::class);

        $resource->setFlags(AMQP_NOPARAM | AMQP_DURABLE | AMQP_PASSIVE | AMQP_AUTODELETE | AMQP_EXCLUSIVE)
            ->shouldBeCalled();
        $resource->setName('queueName')->shouldBeCalled();
        $resource->setArguments(['arg1' => 'value1'])->shouldBeCalled();

        $resource->bind('exchangeName', 'routingKey', $arguments)->shouldBeCalled();

        $queue = new Queue();
        $queue->setResource($resource->reveal());
        $queue->setOptions($options->reveal());
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.
}

        static::assertSame($queue, $queue->bind('exchangeName', 'routingKey', false, $arguments));
    }

    public function testUnbind()
    {
        $arguments = ['arg2' => 'value2'];

        $options = $this->getDefaultOptionsProphet();
        $resource = $this->prophesize(\AMQPQueue::class);

        $resource->setFlags(AMQP_NOPARAM | AMQP_DURABLE | AMQP_PASSIVE | AMQP_AUTODELETE | AMQP_EXCLUSIVE)
            ->shouldBeCalled();
        $resource->setName('queueName')->shouldBeCalled();
        $resource->setArguments(['arg1' => 'value1'])->shouldBeCalled();

        $resource->unbind('exchangeName', 'routingKey', $arguments)->shouldBeCalled();

        $queue = new Queue();
        $queue->setResource($resource->reveal());
        $queue->setOptions($options->reveal());
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.
}

        static::assertSame($queue, $queue->unbind('exchangeName', 'routingKey', $arguments));
    }

    public function testAck()
    {
        $options = $this->getDefaultOptionsProphet();
        $resource = $this->prophesize(\AMQPQueue::class);

        $resource->setFlags(AMQP_NOPARAM | AMQP_DURABLE | AMQP_PASSIVE | AMQP_AUTODELETE | AMQP_EXCLUSIVE)
            ->shouldBeCalled();
        $resource->setName('queueName')->shouldBeCalled();
        $resource->setArguments(['arg1' => 'value1'])->shouldBeCalled();

        $resource->ack('deliveryTag', AMQP_NOPARAM)->shouldBeCalled();

        $queue = new Queue();
        $queue->setResource($resource->reveal());
        $queue->setOptions($options->reveal());
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.
}

        static::assertSame($queue, $queue->ack('deliveryTag'));
    }

    public function testAckMultiple()
    {
        $options = $this->getDefaultOptionsProphet();
        $resource = $this->prophesize(\AMQPQueue::class);

        $resource->setFlags(AMQP_NOPARAM | AMQP_DURABLE | AMQP_PASSIVE | AMQP_AUTODELETE | AMQP_EXCLUSIVE)
            ->shouldBeCalled();
        $resource->setName('queueName')->shouldBeCalled();
        $resource->setArguments(['arg1' => 'value1'])->shouldBeCalled();

        $resource->ack('deliveryTag', AMQP_MULTIPLE)->shouldBeCalled();

        $queue = new Queue();
        $queue->setResource($resource->reveal());
        $queue->setOptions($options->reveal());
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.
}

        static::assertSame($queue, $queue->ack('deliveryTag', true));
    }

    public function testNack()
    {
        $options = $this->getDefaultOptionsProphet();
        $resource = $this->prophesize(\AMQPQueue::class);

        $resource->setFlags(AMQP_NOPARAM | AMQP_DURABLE | AMQP_PASSIVE | AMQP_AUTODELETE | AMQP_EXCLUSIVE)
            ->shouldBeCalled();
        $resource->setName('queueName')->shouldBeCalled();
        $resource->setArguments(['arg1' => 'value1'])->shouldBeCalled();

        $resource->nack('deliveryTag', AMQP_NOPARAM)->shouldBeCalled();

        $queue = new Queue();
        $queue->setResource($resource->reveal());
        $queue->setOptions($options->reveal());
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.
}

        static::assertSame($queue, $queue->nack('deliveryTag'));
    }

    public function testNackRequeue()
    {
        $options = $this->getDefaultOptionsProphet();
        $resource = $this->prophesize(\AMQPQueue::class);

        $resource->setFlags(AMQP_NOPARAM | AMQP_DURABLE | AMQP_PASSIVE | AMQP_AUTODELETE | AMQP_EXCLUSIVE)
            ->shouldBeCalled();
        $resource->setName('queueName')->shouldBeCalled();
        $resource->setArguments(['arg1' => 'value1'])->shouldBeCalled();

        $resource->nack('deliveryTag', AMQP_REQUEUE)->shouldBeCalled();

        $queue = new Queue();
        $queue->setResource($resource->reveal());
        $queue->setOptions($options->reveal());
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.
}

        static::assertSame($queue, $queue->nack('deliveryTag', true));
    }

    public function testNackMultiple()
    {
        $options = $this->getDefaultOptionsProphet();
        $resource = $this->prophesize(\AMQPQueue::class);

        $resource->setFlags(AMQP_NOPARAM | AMQP_DURABLE | AMQP_PASSIVE | AMQP_AUTODELETE | AMQP_EXCLUSIVE)
            ->shouldBeCalled();
        $resource->setName('queueName')->shouldBeCalled();
        $resource->setArguments(['arg1' => 'value1'])->shouldBeCalled();

        $resource->nack('deliveryTag', AMQP_MULTIPLE)->shouldBeCalled();

        $queue = new Queue();
        $queue->setResource($resource->reveal());
        $queue->setOptions($options->reveal());
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.
}

        static::assertSame($queue, $queue->nack('deliveryTag', false, true));
    }

    public function testNackRequeueMultiple()
    {
        $options = $this->getDefaultOptionsProphet();
        $resource = $this->prophesize(\AMQPQueue::class);

        $resource->setFlags(AMQP_NOPARAM | AMQP_DURABLE | AMQP_PASSIVE | AMQP_AUTODELETE | AMQP_EXCLUSIVE)
            ->shouldBeCalled();
        $resource->setName('queueName')->shouldBeCalled();
        $resource->setArguments(['arg1' => 'value1'])->shouldBeCalled();

        $resource->nack('deliveryTag', AMQP_REQUEUE | AMQP_MULTIPLE)->shouldBeCalled();

        $queue = new Queue();
        $queue->setResource($resource->reveal());
        $queue->setOptions($options->reveal());
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.
}

        static::assertSame($queue, $queue->nack('deliveryTag', true, true));
    }

    public function testReject()
    {
        $options = $this->getDefaultOptionsProphet();
        $resource = $this->prophesize(\AMQPQueue::class);

        $resource->setFlags(AMQP_NOPARAM | AMQP_DURABLE | AMQP_PASSIVE | AMQP_AUTODELETE | AMQP_EXCLUSIVE)
            ->shouldBeCalled();
        $resource->setName('queueName')->shouldBeCalled();
        $resource->setArguments(['arg1' => 'value1'])->shouldBeCalled();

        $resource->reject('deliveryTag', AMQP_NOPARAM)->shouldBeCalled();

        $queue = new Queue();
        $queue->setResource($resource->reveal());
        $queue->setOptions($options->reveal());
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.
}

        static::assertSame($queue, $queue->reject('deliveryTag'));
    }

    public function testRejectRequeue()
    {
        $options = $this->getDefaultOptionsProphet();
        $resource = $this->prophesize(\AMQPQueue::class);

        $resource->setFlags(AMQP_NOPARAM | AMQP_DURABLE | AMQP_PASSIVE | AMQP_AUTODELETE | AMQP_EXCLUSIVE)
            ->shouldBeCalled();
        $resource->setName('queueName')->shouldBeCalled();
        $resource->setArguments(['arg1' => 'value1'])->shouldBeCalled();

        $resource->reject('deliveryTag', AMQP_REQUEUE)->shouldBeCalled();

        $queue = new Queue();
        $queue->setResource($resource->reveal());
        $queue->setOptions($options->reveal());
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.
}

        static::assertSame($queue, $queue->reject('deliveryTag', true));
    }

    public function testPurge()
    {
        $options = $this->getDefaultOptionsProphet();
        $resource = $this->prophesize(\AMQPQueue::class);

        $resource->setFlags(AMQP_NOPARAM | AMQP_DURABLE | AMQP_PASSIVE | AMQP_AUTODELETE | AMQP_EXCLUSIVE)
            ->shouldBeCalled();
        $resource->setName('queueName')->shouldBeCalled();
        $resource->setArguments(['arg1' => 'value1'])->shouldBeCalled();

        $resource->purge()->shouldBeCalled();

        $queue = new Queue();
        $queue->setResource($resource->reveal());
        $queue->setOptions($options->reveal());
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.
}

        static::assertSame($queue, $queue->purge());
    }

    public function testCancel()
    {
        $options = $this->getDefaultOptionsProphet();
        $resource = $this->prophesize(\AMQPQueue::class);

        $resource->setFlags(AMQP_NOPARAM | AMQP_DURABLE | AMQP_PASSIVE | AMQP_AUTODELETE | AMQP_EXCLUSIVE)
            ->shouldBeCalled();
        $resource->setName('queueName')->shouldBeCalled();
        $resource->setArguments(['arg1' => 'value1'])->shouldBeCalled();

        $resource->cancel('')->shouldBeCalled();

        $queue = new Queue();
        $queue->setResource($resource->reveal());
        $queue->setOptions($options->reveal());
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.
}

        static::assertSame($queue, $queue->cancel(null));
    }

    public function testGet()
    {
        $options = $this->getDefaultOptionsProphet();
        $resource = $this->prophesize(\AMQPQueue::class);
        $messageMapper = $this->prophesize(MessageMapper::class);

        $resource->setFlags(AMQP_NOPARAM | AMQP_DURABLE | AMQP_PASSIVE | AMQP_AUTODELETE | AMQP_EXCLUSIVE)
            ->shouldBeCalled();
        $resource->setName('queueName')->shouldBeCalled();
        $resource->setArguments(['arg1' => 'value1'])->shouldBeCalled();

        $resource->get(AMQP_NOPARAM)->shouldBeCalled();

        $queue = new Queue();
        $queue->setResource($resource->reveal());
        $queue->setOptions($options->reveal());
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.
}
        $queue->setMessageMapper($messageMapper->reveal());

        static::assertNull($queue->get());
    }

    public function testGetWithAutoAck()
    {
        $options = $this->getDefaultOptionsProphet();
        $resource = $this->prophesize(\AMQPQueue::class);
        $messageMapper = $this->prophesize(MessageMapper::class);

        $messageMapper->toMessage(Argument::any())->shouldNotBeCalled();

        $resource->setFlags(AMQP_NOPARAM | AMQP_DURABLE | AMQP_PASSIVE | AMQP_AUTODELETE | AMQP_EXCLUSIVE)
            ->shouldBeCalled();
        $resource->setName('queueName')->shouldBeCalled();
        $resource->setArguments(['arg1' => 'value1'])->shouldBeCalled();

        $resource->get(AMQP_AUTOACK)->shouldBeCalled();

        $queue = new Queue();
        $queue->setResource($resource->reveal());
        $queue->setOptions($options->reveal());
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.
}
        $queue->setMessageMapper($messageMapper->reveal());

        static::assertNull($queue->get(true));
    }

    public function testGetWithAutoAckAndMessage()
    {
        $options = $this->getDefaultOptionsProphet();
        $resource = $this->prophesize(\AMQPQueue::class);
        $message = $this->prophesize(Message::class);
        $libMessage = $this->prophesize(\AMQPEnvelope::class);
        $messageMapper = $this->prophesize(MessageMapper::class);

        $messageMapper->toMessage($libMessage->reveal())->shouldBeCalled()->willReturn($message->reveal());

        $resource->setFlags(AMQP_NOPARAM | AMQP_DURABLE | AMQP_PASSIVE | AMQP_AUTODELETE | AMQP_EXCLUSIVE)
            ->shouldBeCalled();
        $resource->setName('queueName')->shouldBeCalled();
        $resource->setArguments(['arg1' => 'value1'])->shouldBeCalled();

        $resource->get(AMQP_AUTOACK)
            ->shouldBeCalled()
            ->willReturn($libMessage->reveal());

        $queue = new Queue();
        $queue->setResource($resource->reveal());
        $queue->setOptions($options->reveal());
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.
}
        $queue->setMessageMapper($messageMapper->reveal());

        static::assertSame($message->reveal(), $queue->get(true));
    }

    public function testConsume()
    {
        $options = $this->getDefaultOptionsProphet();
        $resource = $this->prophesize(\AMQPQueue::class);
        $libMessage = $this->prophesize(\AMQPEnvelope::class);
        $messageMapper = $this->prophesize(MessageMapper::class);

        $resource->setFlags(AMQP_NOPARAM | AMQP_DURABLE | AMQP_PASSIVE | AMQP_AUTODELETE | AMQP_EXCLUSIVE)
            ->shouldBeCalled();
        $resource->setName('queueName')->shouldBeCalled();
        $resource->setArguments(['arg1' => 'value1'])->shouldBeCalled();

        $resource->consume(Argument::type(ConsumerCallback::class), AMQP_NOPARAM, 'consumerTag')
            ->shouldBeCalled()
            ->willReturn($libMessage->reveal());

        $queue = new Queue();
        $queue->setResource($resource->reveal());
        $queue->setOptions($options->reveal());
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.
}
        $queue->setMessageMapper($messageMapper->reveal());

        $callback = function () {
            
        };

        $ret = $queue->consume($callback, false, false, false, 'consumerTag');

        static::assertSame($queue, $ret);
    }

    /**
     * @dataProvider consumeProviderWithFlags
     */
    public function testConsumeWithFlags(array $consumeArgs, $flags, $consumerTag)
    {
        $options = $this->getDefaultOptionsProphet();
        $resource = $this->prophesize(\AMQPQueue::class);
        $libMessage = $this->prophesize(\AMQPEnvelope::class);
        $messageMapper = $this->prophesize(MessageMapper::class);

        $resource->setFlags(AMQP_NOPARAM | AMQP_DURABLE | AMQP_PASSIVE | AMQP_AUTODELETE | AMQP_EXCLUSIVE)
            ->shouldBeCalled();
        $resource->setName('queueName')->shouldBeCalled();
        $resource->setArguments(['arg1' => 'value1'])->shouldBeCalled();

        $resource->consume(null, $flags, $consumerTag)
            ->shouldBeCalled()
            ->willReturn($libMessage->reveal());

        $queue = new Queue();
        $queue->setResource($resource->reveal());
        $queue->setOptions($options->reveal());
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.
}
        $queue->setMessageMapper($messageMapper->reveal());

        $ret = call_user_func_array([$queue, 'consume'], $consumeArgs);
        static::assertSame($queue, $ret);
    }

    public function consumeProviderWithFlags()
    {
        return [
            [
                [null, false, false, false, null],
                AMQP_NOPARAM, null
            ],
            [
                [null, true, false, false, null],
                AMQP_NOLOCAL, null
            ],
            [
                [null, false, true, false, null],
                AMQP_AUTOACK, null
            ],
            [
                [null, false, false, true, null],
                AMQP_EXCLUSIVE, null
            ],
            [
                [null, true, true, true, null],
                AMQP_NOLOCAL | AMQP_AUTOACK | AMQP_EXCLUSIVE, null
            ]
        ];
    }

    public function testSetAndGetChannel()
    {
        $channel = $this->prophesize(Channel::class);

        $exchange = new Queue();
        static::assertSame($exchange, $exchange->setChannel($channel->reveal()));
        static::assertSame($channel->reveal(), $exchange->getChannel());
    }

    public function testGetConnection()
    {
        $channel = $this->prophesize(Channel::class);
        $connection = $this->prophesize(Connection::class);

        $channel->getConnection()->willReturn($connection);

        $exchange = new Queue();
        static::assertSame($exchange, $exchange->setChannel($channel->reveal()));
        static::assertSame($connection->reveal(), $exchange->getConnection());
    }

    public function deleteProvider()
    {
        return [
            [true, true, true, AMQP_NOPARAM | AMQP_IFUNUSED | AMQP_IFEMPTY | AMQP_NOWAIT],
            [true, true, false, AMQP_NOPARAM | AMQP_IFUNUSED | AMQP_IFEMPTY],
            [true, false, true, AMQP_NOPARAM | AMQP_IFUNUSED | AMQP_NOWAIT],
            [true, false, false, AMQP_NOPARAM | AMQP_IFUNUSED],
            [false, true, true, AMQP_NOPARAM | AMQP_IFEMPTY | AMQP_NOWAIT],
            [false, true, false, AMQP_NOPARAM | AMQP_IFEMPTY],
            [false, false, true, AMQP_NOPARAM | AMQP_NOWAIT],
            [false, false, false, AMQP_NOPARAM],
        ];
    }

    /**
     * @return Options\QueueOptions|\Prophecy\Prophecy\ObjectProphecy
     */
    protected function getDefaultOptionsProphet()
    {
        /** @var Options\QueueOptions|\Prophecy\Prophecy\ObjectProphecy $options */
        $options = $this->prophesize(Options\QueueOptions::class);

        $options->isDurable()->willReturn(true);
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.
}
        $options->isPassive()->willReturn(true);
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.
}
        $options->isAutoDelete()->willReturn(true);
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.
}
        $options->isExclusive()->willReturn(true);
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.
}
        $options->getName()->willReturn('queueName');
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.
}
        $options->getArguments()->willReturn(['arg1' => 'value1']);
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.
}
        $options->isExclusive()->willReturn(true);

        return $options;
    }
}

Push — master ( 4cd93a...e8f4ec )

QueueTest::testSetOptionsWithArray() A

Complexity

Size

Duplication

Importance

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

thomasvargiu / AMQPAL

Push — master ( 4cd93a...e8f4ec )

QueueTest::testSetOptionsWithArray() A

Complexity

Size

Duplication

Importance

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

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
