QueueTest::testUnbind() - Code Metrics - Inspection of "Removed isDeclared" - thomasvargiu/AMQPAL - Measure and Improve Code Quality continuously with Scrutinizer

Completed
Push — master ( b6f93c...d2ae44 )

by Thomas Mauro
created 2016-03-22 01:34 UTC
QueueTest::testUnbind() A

↳ Parent: QueueTest
Complexity

Conditions	1
Paths	1
Size

Total Lines	19
Code Lines	11
Duplication

Lines	0
Ratio	0 %
Importance

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

namespace AMQPAL\Adapter\PhpAmqpLib;

use PhpAmqpLib\Channel\AMQPChannel;
use PhpAmqpLib\Message\AMQPMessage;
use AMQPAL\Adapter\Message;
use AMQPAL\Options;
use Prophecy\Argument;

class QueueTest extends \PHPUnit_Framework_TestCase
{

    public function testSetOptions()
    {
        $options = $this->getDefaultOptionsProphet();

        $queue = new Queue();

        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 testGetDefaultMessageMapper()
    {
        $exchange = new Queue();

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

    public function testDeclareQueue()
    {
        /** @var \Prophecy\Prophecy\ObjectProphecy|AMQPChannel $adapterChannel */
        $adapterChannel = $this->prophesize(AMQPChannel::class);
        /** @var \Prophecy\Prophecy\ObjectProphecy|Channel $channel */
        $channel = $this->prophesize(Channel::class);
        $options = $this->getDefaultOptionsProphet();

        $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->isNoWait()->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);

        $channel->getResource()->willReturn($adapterChannel);
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.
}
        $adapterChannel->queue_declare(
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',
            true,
            true,
            true,
            true,
            true,
            ['arg1' => 'value1']
        )->shouldBeCalled();

        $queue = new Queue();
        $queue->setChannel($channel->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->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->declareQueue());
    }

    /**
     * @dataProvider deleteProvider()
     */
    public function testDelete($ifUnused, $ifEmpty, $noWait)
    {
        /** @var \Prophecy\Prophecy\ObjectProphecy|AMQPChannel $adapterChannel */
        $adapterChannel = $this->prophesize(AMQPChannel::class);
        /** @var \Prophecy\Prophecy\ObjectProphecy|Channel $channel */
        $channel = $this->prophesize(Channel::class);
        $options = $this->getDefaultOptionsProphet();

        $adapterChannel->queue_delete('queueName', $ifUnused, $ifEmpty, $noWait)->shouldBeCalled();
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.
}
        $channel->getResource()->willReturn($adapterChannel->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 = new 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.
}
        $queue->setChannel($channel->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->delete($ifUnused, $ifEmpty, $noWait));
    }

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

        /** @var \Prophecy\Prophecy\ObjectProphecy|AMQPChannel $adapterChannel */
        $adapterChannel = $this->prophesize(AMQPChannel::class);
        /** @var \Prophecy\Prophecy\ObjectProphecy|Channel $channel */
        $channel = $this->prophesize(Channel::class);
        $options = $this->getDefaultOptionsProphet();

        $adapterChannel->queue_bind('queueName', 'exchangeName', 'routingKey', false, $arguments)->shouldBeCalled();
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.
}
        $channel->getResource()->willReturn($adapterChannel->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 = new 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.
}
        $queue->setChannel($channel->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 testBindNoWaitAndNullRoutingKey()
    {
        $arguments = ['arg2' => 'value2'];

        /** @var \Prophecy\Prophecy\ObjectProphecy|AMQPChannel $adapterChannel */
        $adapterChannel = $this->prophesize(AMQPChannel::class);
        /** @var \Prophecy\Prophecy\ObjectProphecy|Channel $channel */
        $channel = $this->prophesize(Channel::class);
        $options = $this->getDefaultOptionsProphet();

        $adapterChannel->queue_bind('queueName', 'exchangeName', '', true, $arguments)->shouldBeCalled();
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.
}
        $channel->getResource()->willReturn($adapterChannel->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 = new 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.
}
        $queue->setChannel($channel->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', null, true, $arguments));
    }

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

        /** @var \Prophecy\Prophecy\ObjectProphecy|AMQPChannel $adapterChannel */
        $adapterChannel = $this->prophesize(AMQPChannel::class);
        /** @var \Prophecy\Prophecy\ObjectProphecy|Channel $channel */
        $channel = $this->prophesize(Channel::class);
        $options = $this->getDefaultOptionsProphet();

        $adapterChannel->queue_unbind('queueName', 'exchangeName', 'routingKey', $arguments)->shouldBeCalled();
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.
}
        $channel->getResource()->willReturn($adapterChannel->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 = new 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.
}
        $queue->setChannel($channel->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 testUnbindWithNullRoutingKey()
    {
        $arguments = ['arg2' => 'value2'];

        /** @var \Prophecy\Prophecy\ObjectProphecy|AMQPChannel $adapterChannel */
        $adapterChannel = $this->prophesize(AMQPChannel::class);
        /** @var \Prophecy\Prophecy\ObjectProphecy|Channel $channel */
        $channel = $this->prophesize(Channel::class);
        $options = $this->getDefaultOptionsProphet();

        $adapterChannel->queue_unbind('queueName', 'exchangeName', '', $arguments)->shouldBeCalled();
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.
}
        $channel->getResource()->willReturn($adapterChannel->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 = new 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.
}
        $queue->setChannel($channel->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', null, $arguments));
    }

    public function testAck()
    {
        /** @var \Prophecy\Prophecy\ObjectProphecy|AMQPChannel $adapterChannel */
        $adapterChannel = $this->prophesize(AMQPChannel::class);
        /** @var \Prophecy\Prophecy\ObjectProphecy|Channel $channel */
        $channel = $this->prophesize(Channel::class);
        $options = $this->getDefaultOptionsProphet();

        $adapterChannel->basic_ack('deliveryTag', false)->shouldBeCalled();
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.
}
        $channel->getResource()->willReturn($adapterChannel->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 = new 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.
}
        $queue->setChannel($channel->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()
    {
        /** @var \Prophecy\Prophecy\ObjectProphecy|AMQPChannel $adapterChannel */
        $adapterChannel = $this->prophesize(AMQPChannel::class);
        /** @var \Prophecy\Prophecy\ObjectProphecy|Channel $channel */
        $channel = $this->prophesize(Channel::class);
        $options = $this->getDefaultOptionsProphet();

        $adapterChannel->basic_ack('deliveryTag', true)->shouldBeCalled();
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.
}
        $channel->getResource()->willReturn($adapterChannel->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 = new 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.
}
        $queue->setChannel($channel->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()
    {
        /** @var \Prophecy\Prophecy\ObjectProphecy|AMQPChannel $adapterChannel */
        $adapterChannel = $this->prophesize(AMQPChannel::class);
        /** @var \Prophecy\Prophecy\ObjectProphecy|Channel $channel */
        $channel = $this->prophesize(Channel::class);
        $options = $this->getDefaultOptionsProphet();

        $adapterChannel->basic_nack('deliveryTag', false, false)->shouldBeCalled();
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.
}
        $channel->getResource()->willReturn($adapterChannel->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 = new 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.
}
        $queue->setChannel($channel->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()
    {
        /** @var \Prophecy\Prophecy\ObjectProphecy|AMQPChannel $adapterChannel */
        $adapterChannel = $this->prophesize(AMQPChannel::class);
        /** @var \Prophecy\Prophecy\ObjectProphecy|Channel $channel */
        $channel = $this->prophesize(Channel::class);
        $options = $this->getDefaultOptionsProphet();

        $adapterChannel->basic_nack('deliveryTag', false, true)->shouldBeCalled();
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.
}
        $channel->getResource()->willReturn($adapterChannel->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 = new 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.
}
        $queue->setChannel($channel->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()
    {
        /** @var \Prophecy\Prophecy\ObjectProphecy|AMQPChannel $adapterChannel */
        $adapterChannel = $this->prophesize(AMQPChannel::class);
        /** @var \Prophecy\Prophecy\ObjectProphecy|Channel $channel */
        $channel = $this->prophesize(Channel::class);
        $options = $this->getDefaultOptionsProphet();

        $adapterChannel->basic_nack('deliveryTag', true, false)->shouldBeCalled();
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.
}
        $channel->getResource()->willReturn($adapterChannel->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 = new 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.
}
        $queue->setChannel($channel->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()
    {
        /** @var \Prophecy\Prophecy\ObjectProphecy|AMQPChannel $adapterChannel */
        $adapterChannel = $this->prophesize(AMQPChannel::class);
        /** @var \Prophecy\Prophecy\ObjectProphecy|Channel $channel */
        $channel = $this->prophesize(Channel::class);
        $options = $this->getDefaultOptionsProphet();

        $adapterChannel->basic_nack('deliveryTag', true, true)->shouldBeCalled();
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.
}
        $channel->getResource()->willReturn($adapterChannel->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 = new 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.
}
        $queue->setChannel($channel->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()
    {
        /** @var \Prophecy\Prophecy\ObjectProphecy|AMQPChannel $adapterChannel */
        $adapterChannel = $this->prophesize(AMQPChannel::class);
        /** @var \Prophecy\Prophecy\ObjectProphecy|Channel $channel */
        $channel = $this->prophesize(Channel::class);
        $options = $this->getDefaultOptionsProphet();

        $adapterChannel->basic_reject('deliveryTag', false)->shouldBeCalled();
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.
}
        $channel->getResource()->willReturn($adapterChannel->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 = new 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.
}
        $queue->setChannel($channel->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()
    {
        /** @var \Prophecy\Prophecy\ObjectProphecy|AMQPChannel $adapterChannel */
        $adapterChannel = $this->prophesize(AMQPChannel::class);
        /** @var \Prophecy\Prophecy\ObjectProphecy|Channel $channel */
        $channel = $this->prophesize(Channel::class);
        $options = $this->getDefaultOptionsProphet();

        $adapterChannel->basic_reject('deliveryTag', true)->shouldBeCalled();
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.
}
        $channel->getResource()->willReturn($adapterChannel->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 = new 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.
}
        $queue->setChannel($channel->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()
    {
        /** @var \Prophecy\Prophecy\ObjectProphecy|AMQPChannel $adapterChannel */
        $adapterChannel = $this->prophesize(AMQPChannel::class);
        /** @var \Prophecy\Prophecy\ObjectProphecy|Channel $channel */
        $channel = $this->prophesize(Channel::class);
        $options = $this->getDefaultOptionsProphet();

        $adapterChannel->queue_purge('queueName')->shouldBeCalled();
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.
}
        $channel->getResource()->willReturn($adapterChannel->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 = new 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.
}
        $queue->setChannel($channel->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()
    {
        /** @var \Prophecy\Prophecy\ObjectProphecy|AMQPChannel $adapterChannel */
        $adapterChannel = $this->prophesize(AMQPChannel::class);
        /** @var \Prophecy\Prophecy\ObjectProphecy|Channel $channel */
        $channel = $this->prophesize(Channel::class);
        $options = $this->getDefaultOptionsProphet();

        $adapterChannel->basic_cancel('consumerTag')->shouldBeCalled();
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.
}
        $channel->getResource()->willReturn($adapterChannel->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 = new 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.
}
        $queue->setChannel($channel->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('consumerTag'));
    }

    public function testGetWithAutoAck()
    {
        /** @var \Prophecy\Prophecy\ObjectProphecy|AMQPChannel $adapterChannel */
        $adapterChannel = $this->prophesize(AMQPChannel::class);
        /** @var \Prophecy\Prophecy\ObjectProphecy|Channel $channel */
        $channel = $this->prophesize(Channel::class);
        $options = $this->getDefaultOptionsProphet();
        $messageMapper = $this->prophesize(MessageMapper::class);

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

        $adapterChannel->basic_get('queueName', false)
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.
}
            ->shouldBeCalled()
            ->willReturn(null);
        $channel->getResource()->willReturn($adapterChannel->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 = new 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.
}
        $queue->setChannel($channel->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()
    {
        /** @var \Prophecy\Prophecy\ObjectProphecy|AMQPChannel $adapterChannel */
        $adapterChannel = $this->prophesize(AMQPChannel::class);
        /** @var \Prophecy\Prophecy\ObjectProphecy|Channel $channel */
        $channel = $this->prophesize(Channel::class);
        $options = $this->getDefaultOptionsProphet();
        $message = $this->prophesize(Message::class);
        $libMessage = $this->prophesize(AMQPMessage::class);
        $messageMapper = $this->prophesize(MessageMapper::class);

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

        $adapterChannel->basic_get('queueName', false)
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.
}
            ->shouldBeCalled()
            ->willReturn($libMessage->reveal());
        $channel->getResource()->willReturn($adapterChannel->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 = new 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.
}
        $queue->setChannel($channel->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));
    }

    /**
     * @dataProvider consumeProvider
     */
    public function testConsume($args, $libArgs)
    {
        /** @var \Prophecy\Prophecy\ObjectProphecy|AMQPChannel $adapterChannel */
        $adapterChannel = $this->prophesize(AMQPChannel::class);
        /** @var \Prophecy\Prophecy\ObjectProphecy|Channel $channel */
        $channel = $this->prophesize(Channel::class);
        $options = $this->getDefaultOptionsProphet();
        $libMessage = $this->prophesize(AMQPMessage::class);
        $messageMapper = $this->prophesize(MessageMapper::class);

        $adapterChannel->basic_consume(
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',
            $libArgs[0],
            $libArgs[1],
            $libArgs[2],
            $libArgs[3],
            $libArgs[4],
            Argument::type(ConsumerCallback::class)
        )
            ->shouldBeCalled()
            ->willReturn($libMessage->reveal());
        $channel->getResource()->willReturn($adapterChannel->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 = new 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.
}
        $queue->setChannel($channel->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($args[0], $args[1], $args[2], $args[3], $args[4], $callback);

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

    public function consumeProvider()
    {
        return [
            [
                [null, true, true, true, true],
                ['', true, false, true, true],
            ],
            [
                ['consumerTag', true, true, true, true],
                ['consumerTag', true, false, true, true],
            ],
            [
                ['consumerTag', false, false, false, false],
                ['consumerTag', false, true, false, false],
            ],
        ];
    }

    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],
            [true, true, false],
            [true, false, true],
            [true, false, false],
            [false, true, true],
            [false, true, false],
            [false, false, true],
            [false, false, false],
        ];
    }

    /**
     * @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->isNoWait()->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;
    }
}

thomasvargiu / AMQPAL

Push — master ( b6f93c...d2ae44 )

QueueTest::testUnbind() 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

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

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
