FeatureContext

Complexity

Total Complexity

15

Size/Duplication

Total Lines	135
Duplicated Lines	0 %

Coupling/Cohesion

Components	2
Dependencies	8

Importance

Changes

0

13 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	17	1
A	host()	0	4	1
A	vhost()	0	4	1
A	theQueueIsEmpty()	0	5	1
A	iSendTheTextMessageWithRoutingKey()	0	7	1
A	iSendTheJsonMessageWithRoutingKey()	0	10	1
A	iSendMessage()	0	6	1
A	theQueueMustContainMessage()	0	4	1
A	theMessageInQueueHasAsRoutingKeyContainsAndIsATextMessage2()	0	4	1
A	theMessageInQueueHasAsRoutingKeyContainsAndIsAJsonMessage()	0	4	1
A	theMessageInQueueHasAsRoutingKeyContains()	0	9	1
A	assertMessagesInQueue()	0	15	3
A	nbMessagesInQueue()	0	6	1

<?php

use Behat\Behat\Context\Context;
use RabbitMQ\Management\APIClient;
use Puzzle\Configuration\Memory;
use Puzzle\AMQP\Clients\Pecl;
use Puzzle\AMQP\Messages\Message;
use Puzzle\AMQP\Messages\Bodies\Json;

/**
 * Defines application features from the specific context.
 */
class FeatureContext implements Context

PSR1 recommends that each class must be in a namespace of at least one level to avoid collisions.

{
    private
        $api,

The visibility should be declared for property $api.

        $exchange,
        $client,
        $configuration;
    
    public function __construct()
    {
        
        $this->configuration = new Memory(array(
            'amqp/broker/host' => 'rabbitmq',
            'amqp/broker/login' => 'guest',
            'amqp/broker/password' => 'guest',
            'amqp/broker/vhost' => 'behat',
            'amqp/global/disallowSilentDropping' => true,
            'app/id' => 'puzzle-amqp-test',
        ));
        
        $this->exchange = 'puzzle';
        
        $this->api = APIClient::factory(['host' => $this->host()]);

Equals sign not aligned with surrounding assignments; expected 4 spaces but found 1 space

        $this->client = new Pecl($this->configuration);
    }
    
    private function host()
    {
        return $this->configuration->readRequired('amqp/broker/host');
    }
    
    private function vhost()
    {
        return $this->configuration->readRequired('amqp/broker/vhost');
    }

    /**
     * @Given The queue :queue is empty
     */
    public function theQueueIsEmpty($queue)
    {
        $this->api->purgeQueue($this->vhost(), $queue);
        $this->assertMessagesInQueue($queue, 0);
    }
    
    /**
     * @When I send the text message :bodyContent with routing key :routingKey
     */
    public function iSendTheTextMessageWithRoutingKey($bodyContent, $routingKey)
    {
        $message = new Message($routingKey);
        $message->setText($bodyContent);
     
        $this->iSendMessage($message);
    }
    
    /**
     * @When I send the json message :bodyContent with routing key :routingKey
     */
    public function iSendTheJsonMessageWithRoutingKey($bodyContent, $routingKey)
    {
        $message = new Message($routingKey);
        
        $body = new Json();
        $body->changeContentWithJson($bodyContent);
        $message->setBody($body);
     
        $this->iSendMessage($message);
    }
    
    private function iSendMessage(Message $message)
    {
        $result = $this->client->publish($this->exchange, $message);
        
        \PHPUnit_Framework_Assert::assertTrue($result);
    }
    
    /**
     * @Then The queue :queue must contain :nbMessages message
     */
    public function theQueueMustContainMessage($queue, $nbMessages)
    {
        $this->assertMessagesInQueue($queue, (int) $nbMessages);
    }
    
    /**
     * @Then The message in queue :queueName has :arg1 as routing key, contains :content and is a text message
     */
    public function theMessageInQueueHasAsRoutingKeyContainsAndIsATextMessage2($routingKey, $content, $queueName)
    {
        $this->theMessageInQueueHasAsRoutingKeyContains($routingKey, $content, $queueName, "text/plain");
    }
    
    /**
     * @Then The message in queue :queueName has :arg1 as routing key, contains :content and is a json message
     */
    public function theMessageInQueueHasAsRoutingKeyContainsAndIsAJsonMessage($routingKey, $content, $queueName)
    {
        $this->theMessageInQueueHasAsRoutingKeyContains($routingKey, $content, $queueName, "application/json");
    }
    
    private function theMessageInQueueHasAsRoutingKeyContains($routingKey, $content, $queueName, $contentType)
    {
        $messages = $this->api->getMessagesFromQueue($this->vhost(), $queueName);
        $message = $messages->first();

Equals sign not aligned with surrounding assignments; expected 2 spaces but found 1 space

        
        \PHPUnit_Framework_Assert::assertSame($routingKey, $message->routing_key);
        \PHPUnit_Framework_Assert::assertSame($content, $message->payload);
        \PHPUnit_Framework_Assert::assertSame($contentType, $message->properties['content_type']);
    }
    
    
    private function assertMessagesInQueue($queue, $expectedNbMessages, $waitingSeconds = 11)
    {
        $nbMessages = $this->nbMessagesInQueue($queue);
        $nbTries = 0;

Equals sign not aligned with surrounding assignments; expected 4 spaces but found 1 space

        
        while($nbMessages !== $expectedNbMessages && $nbTries < $waitingSeconds)
        {
            sleep(1);
            $nbTries++;
            
            $nbMessages = $this->nbMessagesInQueue($queue);
        }
        
        \PHPUnit_Framework_Assert::assertSame($expectedNbMessages, $nbMessages);
    }
    
    private function nbMessagesInQueue($queueName)
    {
        $queue = $this->api->getQueue($this->vhost(), $queueName);
        
        return (int) $queue->messages;
    }
}