Behat\Contexts\FeatureContext

Complexity

Total Complexity

29

Size/Duplication

Total Lines	327
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	7

Importance

Changes	1
Bugs	0	Features	1

16 Methods

Rating	Name	Duplication	Size	Complexity
A	guzzle()	0	12	2
A	theRequestNeedsAuthentication()	0	6	1
A	theRequestUsesResponseTransformerWith()	0	5	1
A	theRequestUsesNoTransformationDataTransformer()	0	4	1
A	build()	0	9	1
A	handle()	0	9	1
A	handleWith()	0	10	1
B	theResponseIs()	0	21	5
B	theGivenPropertyGetsValue()	0	27	4
A	printLastResponse()	0	8	2
A	getJson()	0	4	1
A	getResponseDataTransformer()	0	11	2
A	getCommand()	0	4	1
A	getCommandHandler()	0	8	2
A	getModelClass()	0	8	2
A	isValidJson()	0	6	2

<?php

/*
 * This file is part of the Stack Exchange Api Client library.
 *
 * Copyright (c) 2014-2016 Beñat Espiña <benatespina@gmail.com>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Behat\Contexts;

use Behat\Behat\Context\SnippetAcceptingContext;
use BenatEspina\StackExchangeApiClient\Application\DataTransformer\ResponseDataTransformer;
use BenatEspina\StackExchangeApiClient\Application\DataTransformer\ResponseNoTransformationDataTransformer;
use BenatEspina\StackExchangeApiClient\Domain\Model\Authentication;
use BenatEspina\StackExchangeApiClient\Domain\Model\Http;
use BenatEspina\StackExchangeApiClient\Domain\Model\Model;
use BenatEspina\StackExchangeApiClient\Infrastructure\Http\Guzzle\GuzzleHttp;
use GuzzleHttp\Client;
use Psr\Http\Message\ResponseInterface;
use Sanpi\Behatch\Context\JsonContext;
use Sanpi\Behatch\Json\Json;

/**
 * Feature context base class.
 *
 * @author Beñat Espiña <benatespina@gmail.com>
 */
class FeatureContext extends JsonContext implements SnippetAcceptingContext
{
    /**
     * The authentication.
     *
     * @var Authentication
     */
    private $authentication;

    /**
     * The response data transformer.
     *
     * @var ResponseDataTransformer
     */
    private $dataTransformer;

    /**
     * The command handler.
     *
     * @var mixed
     */
    private $handler;

    /**
     * The HTTP client.
     *
     * @var Http
     */
    private $http;

    /**
     * The handler's returned data.
     *
     * @var ResponseInterface|Model
     */
    private $response;

    /**
     * Uses Guzzle as HTTP client.
     *
     * @Then the request uses Guzzle as HTTP client
     */
    public function guzzle()
    {
        if (null === $this->http) {
            $this->http = new GuzzleHttp(
                new Client([
                    'base_uri' => 'https://api.stackexchange.com/2.2',
                ])
            );
        }

        return $this->http;
    }

    /**
     * Added authentication to the requests.
     *
     * This method contains a hardcoded application key
     * and access token to test purposes.
     *
     * @Then the request needs authentication
     */
    public function theRequestNeedsAuthentication()
    {
        $this->authentication = new Authentication(
            'Suy)bfhQl6vE3YgSwFZPxA((', 'pagFVLWIE*GZPfbxH2L1sg))'
        );
    }

    /**
     * Adds response data transformer with given type class.
     *
     * @param string $resource  The resource name: e.j. "answer"
     * @param string $typeClass The fully qualified of type class
     *
     * @Then the request uses response :resource data transformer with :typeClass
     */
    public function theRequestUsesResponseTransformerWith($resource, $typeClass)
    {
        $transformerClass = $this->getResponseDataTransformer($resource);
        $this->dataTransformer = new $transformerClass($this->getModelClass($typeClass));
    }

    /**
     * Adds no transformation data transformer.
     *
     * @Then the request uses response no transformation data transformer
     */
    public function theRequestUsesNoTransformationDataTransformer()
    {
        $this->dataTransformer = new ResponseNoTransformationDataTransformer();
    }

    /**
     * Builds the command handler with given values.
     *
     * @param string $resource The resource name: e.j. "answer"
     * @param string $handler  The handler class name
     *
     * @Then builds the :resource's :handler handler
     */
    public function build($resource, $handler)
    {
        $handlerClass = $this->getCommandHandler($resource, $handler);
        $this->handler = new $handlerClass(
            $this->http,
            $this->dataTransformer,
            $this->authentication
        );
    }

    /**
     * Handles the command.
     *
     * @param string $resource The resource name: e.j. "answer"
     * @param string $command  The command class name
     * @param string $options  The additional options as query params
     *
     * @Then handles the :resource's :command with :options options
     */
    public function handle($resource, $command, $options)
    {
        parse_str($options, $options);
        $commandClass = $this->getCommand($resource, $command);

        $this->response = $this->handler->handle(
            new $commandClass($options)
        );
    }

    /**
     * Handles the command with the given arguments.
     *
     * @param string $resource  The resource name: e.j. "answer"
     * @param string $command   The command class name
     * @param string $arguments The arguments needed to build the correct request
     * @param string $options   The additional options as query params
     *
     * @Then handles the :resource's :command with :arguments and :options options
     */
    public function handleWith($resource, $command, $arguments, $options)
    {
        $arguments = explode(',', preg_replace('/\s+/', '', $arguments));
        parse_str($options, $options);
        $commandClass = $this->getCommand($resource, $command);

        $this->response = $this->handler->handle(
            new $commandClass($arguments, $options)
        );
    }

    /**
     * Checks if the returned response is a json or a given instance.
     *
     * @param string|null $instance The instance of response, it can be null
     *
     * @throws \Exception when the response is not a valid instance
     * @throws \Exception when the response is not a valid JSON
     *
     * @Then the response is a collection of :instance
     * @Then the response is an instance of :instance
     * @Then the response is a json
     */
    public function theResponseIs($instance = null)
    {
        if (null === $instance) {
            if (!$this->isValidJson($this->response->getBody())) {
                throw new \Exception('This is not a valid JSON');
            }

            return;
        }

        $instance = $this->getModelClass($instance);
        $response = $this->response;
        if (!is_array($this->response)) {
            $response = [$this->response];
        }
        array_map(function ($item) use ($instance) {
            if (!$item instanceof $instance) {
                throw new \Exception(sprintf('Expected a %s, %s given', $instance, $item));
            }
        }, $response);
    }

    /**
     * Checks if the given value of property is the same of the response value.
     *
     * @param string $property The class property
     * @param string $value    The class property value
     * @param int    $item     The index of response, by default is 1
     *
     * @throws \Exception when the response value is different of the given value
     *
     * @Then the :property gets :value
     * @Then the :property of the item :item, gets :value
     */
    public function theGivenPropertyGetsValue($property, $value, $item = 1)
    {
        $item = $item - 1;

Decrement operators should be used where possible; found "$item = $item - 1;" but expected "$item--"

        $response = $this->response;
        if (!is_array($this->response)) {
            $response = [$this->response];
        }
        $reflectionClass = new \ReflectionClass($response[$item]);
        $reflectionProperty = $reflectionClass->getProperty($property);
        $reflectionProperty->setAccessible(true);
        $responseValue = $reflectionProperty->getValue($response[$item]);

        if ($responseValue instanceof \DateTimeInterface) {
            $responseValue = $responseValue->format('Y-m-d');
        }

        if ($responseValue !== $value) {
            throw new \Exception(
                sprintf(
                    'The %s property expects %s value, %s given',
                    $property,
                    $value,
                    $responseValue
                )
            );
        }
    }

    /**
     * Prints the response content.
     *
     * @Then /^print last response$/
     */
    public function printLastResponse()
    {
        if ($this->response instanceof ResponseInterface) {
            echo $this->response->getBody();
        } else {
            dump($this->response);
        }
    }

    /**
     * {@inheritdoc}
     */
    protected function getJson()
    {
        return new Json($this->response->getBody());
    }

    /**
     * Gets the namespaced class name of given data transformer class.
     *
     * @param string $class The class name
     *
     * @return string
     */
    private function getResponseDataTransformer($class)
    {
        if (class_exists($class)) {
            return $class;
        }

        return sprintf(
            'BenatEspina\\StackExchangeApiClient\\Application\\DataTransformer\\ResponseTo%sDataTransformer',
            ucfirst($class)
        );
    }

    /**
     * Gets the namespaced class name of given command class.
     *
     * @param string $type  The resource name: e.j. "answer"
     * @param string $class The class name
     *
     * @return string
     */
    private function getCommand($type, $class)
    {
        return $this->getCommandHandler($type, $class);
    }

    /**
     * Gets the namespaced class name of given command handler class.
     *
     * @param string $type  The resource name: e.j. "answer"
     * @param string $class The class name
     *
     * @return string
     */
    private function getCommandHandler($type, $class)
    {
        if (class_exists($class)) {
            return $class;
        }

        return sprintf('BenatEspina\\StackExchangeApiClient\\Application\\Service\\%s\\%s', ucfirst($type), $class);
    }

    /**
     * Gets the namespaced class of domain model class implementation.
     *
     * @param string $class The class name
     *
     * @return string
     */
    private function getModelClass($class)
    {
        if (class_exists($class)) {
            return $class;
        }

        return sprintf('BenatEspina\\StackExchangeApiClient\\Infrastructure\\Domain\\Model\\%s', $class);
    }

    /**
     * Checks if the given JSON is valid or not.
     *
     * @param string $json The JSON
     *
     * @return bool
     */
    private function isValidJson($json)
    {
        $array = json_decode($json);

        return ($array != $json) && $array;
    }
}