SmartGamma\Behat\PactExtension\Context\PactContext

Complexity

Total Complexity

25

Size/Duplication

Total Lines	288
Duplicated Lines	20.83 %

Coupling/Cohesion

Components	1
Dependencies	17

Test Coverage

Coverage

93.98%

Importance

Changes

0

19 Methods

Rating	Name	Duplication	Size	Complexity
A	initialize()	0	7	1
A	setupBehatTags()	0	5	1
A	setupBehatStepName()	0	6	2
A	setupBehatScenarioName()	0	4	1
A	registerInteraction()	14	14	1
A	registerInteractionWithBody()	15	15	1
A	registerInteractionWithQuery()	15	15	1
A	registerInteractionWithQueryAndBody()	16	16	1
A	requestToWithParameters()	0	14	1
A	theProviderRequestShouldReturnResponseWithAndBody()	0	17	2
A	hasFollowStructureInTheResponseAbove()	0	13	2
A	mockedApiProviderIsAvailable()	0	4	1
A	onTheProvider()	0	6	1
A	onTheProviderWithDescription()	0	6	1
A	providerPlainTextState()	0	5	1
A	theConsumerAuthorizedAsOn()	0	4	1
A	verifyInteractions()	0	6	2
A	teardown()	0	10	2
A	getHeaders()	0	4	2

<?php

namespace SmartGamma\Behat\PactExtension\Context;

use Behat\Behat\Hook\Scope\StepScope;
use Behat\Behat\Hook\Scope\ScenarioScope;
use Behat\Gherkin\Node\PyStringNode;
use Behat\Gherkin\Node\TableNode;
use Behat\Testwork\Hook\Scope\AfterTestScope;
use SmartGamma\Behat\PactExtension\Exception\InvalidResponseObjectNameFormat;
use SmartGamma\Behat\PactExtension\Exception\NoConsumerRequestDefined;
use SmartGamma\Behat\PactExtension\Infrastructure\ProviderState\InjectorStateDTO;
use SmartGamma\Behat\PactExtension\Infrastructure\ProviderState\ProviderState;
use SmartGamma\Behat\PactExtension\Infrastructure\ProviderState\PlainTextStateDTO;
use SmartGamma\Behat\PactExtension\Infrastructure\Interaction\InteractionRequestDTO;
use SmartGamma\Behat\PactExtension\Infrastructure\Interaction\InteractionResponseDTO;
use SmartGamma\Behat\PactExtension\Infrastructure\Pact;
use Behat\Gherkin\Node\ArgumentInterface;

class PactContext implements PactContextInterface
{
    /**
     * @var string
     */
    private static $stepName;

    /**
     * @var array
     */
    private static $tags = [];

    /**
     * @var Pact
     */
    private static $pact;

    /**
     * @var ProviderState
     */
    private static $providerState;

    /**
     * @var array
     */
    private $consumerRequest = [];

    /**
     * @var array
     */
    private $headers = [];

    /**
     * @var Authenticator
     */
    private $authenticator;

    /**
     * @var array
     */
    private $matchingObjectStructures = [];

    /**
     * @param Pact          $pact
     * @param ProviderState $providerState
     * @param Authenticator $authenticator
     */
    public function initialize(Pact $pact, ProviderState $providerState, Authenticator $authenticator): void
    {
        self::$pact          = $pact;
        self::$providerState = $providerState;
        $this->authenticator = $authenticator;
        self::$stepName = __FUNCTION__;
    }

    /**
     * @BeforeScenario
     */
    public function setupBehatTags(ScenarioScope $scope): void
    {
        self::$tags = $scope->getScenario()->getTags();
        self::$providerState->clearStates();
    }

    /**
     * @BeforeScenario
     */
    public static function setupBehatStepName(ScenarioScope $step): void
    {
        if ($step->getScenario()->getTitle()) {

The expression $step->getScenario()->getTitle() of type null|string is loosely compared to true; this is ambiguous if the string can be empty. You might want to explicitly use !== null instead.

            self::$providerState->setDefaultPlainTextState($step->getScenario()->getTitle());
        }
    }

    /**
     * @BeforeStep
     */
    public static function setupBehatScenarioName(StepScope $step): void
    {
        self::$stepName = $step->getStep()->getText();
    }

    /**
     * @Given :providerName request :method to :uri should return response with :status
     */
    public function registerInteraction(

This method seems to be duplicated in your project.

        string $providerName,
        string $method,
        string $uri,
        int $status
    ): void
    {
        $headers = $this->getHeaders($providerName);
        $request       = new InteractionRequestDTO($providerName, self::$stepName, $uri, $method, $headers);
        $response      = new InteractionResponseDTO($status);
        $providerState = self::$providerState->getStateDescription($providerName);

        self::$pact->registerInteraction($request, $response, $providerState);
    }

    /**
     * @Given :providerName request :method to :uri should return response with :status and body:
     */
    public function registerInteractionWithBody(

This method seems to be duplicated in your project.

        string $providerName,
        string $method,
        string $uri,
        int $status,
        TableNode $responseTable
    ): void
    {
        $headers = $this->getHeaders($providerName);
        $request       = new InteractionRequestDTO($providerName, self::$stepName, $uri, $method, $headers);
        $response      = new InteractionResponseDTO($status, $responseTable->getHash(), $this->matchingObjectStructures);
        $providerState = self::$providerState->getStateDescription($providerName);

        self::$pact->registerInteraction($request, $response, $providerState);
    }

    /**
     * @Given :providerName request :method to :uri with :query should return response with :status
     */
    public function registerInteractionWithQuery(

This method seems to be duplicated in your project.

        string $providerName,
        string $method,
        string $uri,
        string $query,
        int $status
    ): void
    {
        $headers = $this->getHeaders($providerName);
        $request       = new InteractionRequestDTO($providerName, self::$stepName, $uri, $method, $headers, $query);
        $response      = new InteractionResponseDTO($status);
        $providerState = self::$providerState->getStateDescription($providerName);

        self::$pact->registerInteraction($request, $response, $providerState);
    }

    /**
     * @Given :providerName request :method to :uri with :query should return response with :status and body:
     */
    public function registerInteractionWithQueryAndBody(

This method seems to be duplicated in your project.

        string $providerName,
        string $method,
        string $uri,
        string $query,
        int $status,
        TableNode $responseTable
    ): void
    {
        $headers = $this->getHeaders($providerName);
        $request       = new InteractionRequestDTO($providerName, self::$stepName, $uri, $method, $headers, $query);
        $response      = new InteractionResponseDTO($status, $responseTable->getHash(), $this->matchingObjectStructures);
        $providerState = self::$providerState->getStateDescription($providerName);

        self::$pact->registerInteraction($request, $response, $providerState);
    }

    /**
     * @Given :providerName request :method to :uri with parameters:
     */
    public function requestToWithParameters(

function requestToWithParameters() does not seem to conform to the naming convention (^(?:is|has|should|may|supports)).

        string $providerName,
        string $method,
        string $uri,
        TableNode $table
    ): bool
    {
        $headers = $this->getHeaders($providerName);
        $requestBody = $table->getRowsHash();
        array_shift($requestBody);
        $this->consumerRequest[$providerName] = new InteractionRequestDTO($providerName, self::$stepName, $uri, $method, $headers, null, $requestBody);

        return true;
    }

    /**
     * @Given request above to :providerName should return response with :status and body:
     */
    public function theProviderRequestShouldReturnResponseWithAndBody(
        string $providerName,
        int $status,
        TableNode $responseTable
    ): void
    {
        if (false === isset($this->consumerRequest[$providerName])) {
            throw new NoConsumerRequestDefined('No consumer InteractionRequestDTO defined. Call step: "Given :providerName request :method to :uri with parameters:" before this one.');
        }

        $request       = $this->consumerRequest[$providerName];
        $response      = new InteractionResponseDTO($status, $responseTable->getHash(), $this->matchingObjectStructures);
        $providerState = self::$providerState->getStateDescription($providerName);
        unset($this->consumerRequest[$providerName]);

        self::$pact->registerInteraction($request, $response, $providerState);
    }

    /**
     * @Given :object object should have follow structure:
     */
    public function hasFollowStructureInTheResponseAbove($object, TableNode $table): bool
    {
        if (!preg_match('/^<.*>$/', $object)) {
            throw new InvalidResponseObjectNameFormat('Response object name should be taken in "<...>" like <name>');
        }

        $eachParameters = $table->getRowsHash();
        array_shift($eachParameters);

        $this->matchingObjectStructures[$object] = $eachParameters;

        return true;
    }

    /**
     * @Given :providerName API is available
     */
    public function mockedApiProviderIsAvailable(string $providerName): int
    {
        return self::$pact->startServer($providerName);
    }

    /**
     * @Given :entity on the provider :providerName:
     */
    public function onTheProvider(string $entity, string $providerName, TableNode $table): void
    {
        $parameters    = \array_slice($table->getRowsHash(), 1);
        $injectorState = new InjectorStateDTO($providerName, $entity, $parameters);
        self::$providerState->addInjectorState($injectorState);
    }

    /**
     * @Given :entity as :entityDescription on the provider :providerName:
     */
    public function onTheProviderWithDescription(string $entity, string $providerName, string $entityDescription, TableNode $table): void
    {
        $parameters    = \array_slice($table->getRowsHash(), 1);
        $injectorState = new InjectorStateDTO($providerName, $entity, $parameters, $entityDescription);
        self::$providerState->addInjectorState($injectorState);
    }

    /**
     * @Given provider :providerName state:
     */
    public function providerPlainTextState(string $providerName, PyStringNode $state): void
    {
        $textStateDTO = new PlainTextStateDTO($providerName, $state->getRaw());
        self::$providerState->setPlainTextState($textStateDTO);
    }

    /**
     * @Given the consumer :authType authorized as :credentials on :providerName
     */
    public function theConsumerAuthorizedAsOn(string $authType, string $credentials, string $providerName): void
    {
        $this->headers[$providerName] = $this->authenticator->authorizeConsumerRequestToProvider($authType, $credentials);
    }

    /**
     * @AfterScenario
     */
    public function verifyInteractions(): void
    {
        if (\in_array('pact', self::$tags, true)) {
            self::$pact->verifyInteractions();
        }
    }

    /**
     * @AfterSuite
     */
    public static function teardown(AfterTestScope $scope): bool

function teardown() does not seem to conform to the naming convention (^(?:is|has|should|may|supports)).

    {
        if (!$scope->getTestResult()->isPassed()) {
            echo 'A test has failed. Skipping PACT file upload.';

            return false;
        }

        return self::$pact->finalize(self::$pact->getConsumerVersion());
    }

    private function getHeaders(string $providerName): array
    {
        return isset($this->headers[$providerName]) ? $this->headers[$providerName] : [];
    }
}