QueueTest - Code Metrics - thomasvargiu/AMQPAL - Measure and Improve Code Quality continuously with Scrutinizer

QueueTest A
last analyzed 2016-05-01 17:18 UTC

↳ Parent: Project
Complexity

Total Complexity
Size/Duplication

Total Lines	516
Duplicated Lines	0 %
Coupling/Cohesion

Components	1
Dependencies	5
Importance

Changes	3
Bugs	1	Features	0
Metric	Value
wmc	27
c	3
b	1
f	0
lcom	1
cbo	5
dl	0
loc	516
rs	10
27 Methods

Rating	Name	Size	Complexity
A	testSetOptions()	9	1
A	testSetOptionsWithArray()	11	1
A	testGetDefaultMessageMapper()	6	1
B	testDeclareQueue()	33	1
A	testDelete()	17	1
A	testBind()	19	1
A	testBindNoWaitAndNullRoutingKey()	19	1
A	testUnbind()	19	1
A	testUnbindWithNullRoutingKey()	19	1
A	testAck()	17	1
A	testAckMultiple()	17	1
A	testNack()	17	1
A	testNackRequeue()	17	1
A	testNackMultiple()	17	1
A	testNackRequeueMultiple()	17	1
A	testReject()	17	1
A	testRejectRequeue()	17	1
A	testPurge()	17	1
A	testCancel()	17	1
A	testGetWithAutoAck()	23	1
B	testGetWithAutoAckAndMessage()	25	1
B	testConsume()	43	1
A	consumeProvider()	17	1
A	testSetAndGetChannel()	8	1
A	testGetConnection()	11	1
A	deleteProvider()	13	1
A	getDefaultOptionsProphet()	15	1
<?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 testSetOptionsWithArray()
    {
        $options = ['name' => 'queueName'];

        $queue = new Queue();

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

    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->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,
            false,
            ['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', 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.
}
            ->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', 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.
}
            ->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)
    {
        $adapterChannel = $this->prophesize(AMQPChannel::class);
        $channel = $this->prophesize(Channel::class);
        $options = $this->getDefaultOptionsProphet();
        $libMessage = $this->prophesize(AMQPMessage::class);
        $messageMapper = $this->prophesize(MessageMapper::class);

        $adapterChannel->basic_consume(
            'queueName',
            $libArgs[3],
            $libArgs[0],
            $libArgs[1],
            $libArgs[2],
            false,
            Argument::type(ConsumerCallback::class)
        )
            ->shouldBeCalled()
            ->willReturn($libMessage->reveal());

        $adapterChannel->callbacks = ['foo', 'bar'];
        $adapterChannel->wait()->shouldBeCalledTimes(count($adapterChannel->callbacks))
            ->will(function () use ($adapterChannel) {
                $callbacks = $adapterChannel->callbacks;
                array_shift($callbacks);
                $adapterChannel->callbacks = $callbacks;
            });

        $channel->getResource()->willReturn($adapterChannel->reveal());

        $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());
        $queue->setMessageMapper($messageMapper->reveal());

        $callback = function () {
            
        };

        $ret = $queue->consume($callback, $args[0], $args[1], $args[2], $args[3]);

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

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

    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->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

QueueTest A last analyzed 2016-05-01 17:18 UTC

Complexity

Size/Duplication

Coupling/Cohesion

Importance

27 Methods

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

QueueTest A
last analyzed 2016-05-01 17:18 UTC
