AbstractResourceCest::internalDelete() - Code Metrics - ROAResearch/yii2-roa - Measure and Improve Code Quality continuously with Scrutinizer

AbstractResourceCest::internalDelete() A
last analyzed 2022-11-23 22:41 UTC

↳ Parent: AbstractResourceCest
Complexity

Conditions	1
Paths	1
Size

Total Lines	10
Code Lines	3
Duplication

Lines	0
Ratio	0 %
Code Coverage

Tests	4
CRAP Score	1
Importance

Changes
Metric	Value
cc	1
eloc	3
nc	1
nop	2
dl	0
loc	10
ccs	4
cts	4
cp	1
crap	1
rs	10
c	0
b	0
f	0
<?php

namespace roaresearch\yii2\roa\test;

use Codeception\{Example, Util\HttpCode, Verify\Verify};
use roaresearch\yii2\roa\urlRules\Resource as ResourceUrlRule;
use yii\web\UrlManager;

abstract class AbstractResourceCest
{
    /**
     * @var UrlManager url manager used to parse Route's for the services.
     */
    protected $urlManager;

    /**
     * Initializes the `$urlManager` object
     */
    public function __construct()
    {
        $this->urlManager = new UrlManager([
            'enablePrettyUrl' => true,
            'showScriptName' => false,
            'cache' => false,
            'rules' => [
                $this->getRoutePattern() . '/<id:\d+>'=> 'test/action',
                $this->getRoutePattern() => 'test/action',
            ],
        ]);
    }

    /**
     * Authenticates a user identified by 'authUser' index in the `$example`.
     *
     * @param Tester $I
     * @param Example $example data used for the testing. It uses the keys
     * - tokenName: (optional) string name of the token used to authenticate.
     */
    protected function authUser(Tester $I, Example $example)
    {
        if (!empty($example['tokenName'])) {
            $I->amAuthByToken($example['tokenName']);
        }
    }

    /**
     * Parses the Route for the test using `$urlManager` and `getRoutePattern()`
     *
     * @param Example $example data used for the testing. It uses the keys
     * - url: (optional) string if provided it will be used directly.
     * - urlParams: (optional) string[] GET params to parse the url rule with
     *   `getRoutePattern()`.
     * @return string the url which will be used for the service.
     */
    protected function parseUrl(Example $example): string
    {
        if (isset($example['url'])) {
            return $example['url'];
        }
        $params = $example['urlParams'] ?? [];
        $params[0] = 'test/action';

        return $this->urlManager->createUrl($params);
    }

    /**
     * Handles the internal logic when running a test on a collection resource.
     *
     * @param Tester $I
     * @param Example $example data used for the testing. It uses the keys
     * - tokenName: (optional) string name of the token used to authenticate.
     * - url: (optional) string if provided it will be used directly.
     * - urlParams: (optional) string[] GET params to parse the url rule with
     *   `getRoutePattern()`.
     * - headers: (optional) string[] pairs of header => value expected in the
     *   response.
     */
    protected function internalIndex(Tester $I, Example $example)
    {
        // Authenticates configured user.
        $this->authUser($I, $example);

        // Send request
        $I->sendGET($this->parseUrl($example));
            sendGET($this->parseUrl($example));

        // Checks the response has the required headers and body.
        $this->checkResponse([
            HttpCode::OK => 'checkSuccessIndexResponse',
            HttpCode::UNPROCESSABLE_ENTITY => 'checkValidationResponse',
        ], $I, $example);
    }

    /**
     * Handles the internal logic when running a test on a creating a record.
     *
     * @param Tester $I
     * @param Example $example data used for the testing. It uses the keys
     * - tokenName: (optional) string name of the token used to authenticate.
     * - url: (optional) string if provided it will be used directly.
     * - urlParams: (optional) string[] GET params to parse the url rule with
     *   `getRoutePattern()`.
     * - data: (optional) POST data sent on the request.
     * - headers: (optional) string[] pairs of header => value expected in the
     *   response.
     */
    protected function internalCreate(Tester $I, Example $example)
    {
        // Authenticates configured user.
        $this->authUser($I, $example);

        // Send request
        $I->sendPOST(
            sendPOST(
            $this->parseUrl($example),
            $example['data'] ?? []
        );

        // Checks the response has the required headers and body.
        $this->checkResponse([
            HttpCode::CREATED => 'checkSuccessCreateResponse',
            HttpCode::UNPROCESSABLE_ENTITY => 'checkValidationResponse',
        ], $I, $example);
    }

    /**
     * Handles the internal logic when running a test on a record resource.
     *
     * @param Tester $I
     * @param Example $example data used for the testing. It uses the keys
     * - tokenName: (optional) string name of the token used to authenticate.
     * - url: string if provided it will be used directly.
     * - urlParams: string[] GET params to parse the url rule with
     *   `getRoutePattern()`.
     * - httpCode: integer expected Http Code response. If the httpCode is
     *   a key in `$responses` parameter then the method defined there will be
     *   used to analyze the response. Otherwise `checkErrorResponse()` will be
     *   used.
     * - error: string|string[] expected json being contained in the response.
     * - headers: (optional) string[] pairs of header => value expected in the
     *   response.
     */
    protected function internalView(Tester $I, Example $example)
    {
        // Authenticates configured user.
        $this->authUser($I, $example);

        // Send request
        $I->sendGET($this->parseUrl($example));

        // Checks the response has the required headers and body.
        $this->checkResponse([
            HttpCode::OK => 'checkSuccessViewResponse',
        ], $I, $example);
    }

    /**
     * Handles the internal logic when running a test on a updating a record.
     *
     * @param Tester $I
     * @param Example $example data used for the testing. It uses the keys
     * - tokenName: (optional) string name of the token used to authenticate.
     * - url: (optional) string if provided it will be used directly.
     * - urlParams: (optional) string[] GET params to parse the url rule with
     *   `getRoutePattern()`.
     * - data: (optional) POST data sent on the request.
     * - expected: (optional) expected in the JSON response body.
     * - headers: (optional) string[] pairs of header => value expected in the
     *   response.
     */
    protected function internalUpdate(Tester $I, Example $example)
    {
        // Authenticates configured user.
        $this->authUser($I, $example);

        // Send request
        $I->sendPATCH($this->parseUrl($example), $example['data']);
            sendPATCH($this->parseUrl($example), $example['data']);

        // Checks the response has the required headers and body.
        $this->checkResponse([
            HttpCode::OK => 'checkSuccessViewResponse',
            HttpCode::UNPROCESSABLE_ENTITY => 'checkValidationResponse',
        ], $I, $example);

        if (isset($example['expected'])) {
            $I->seeResponseContainsJson($example['expected']);
                seeResponseContainsJson($example['expected']);
        }
    }

    /**
     * Handles the internal logic when running a test on a updating a record.
     *
     * @param Tester $I
     * @param Example $example data used for the testing. It uses the keys
     * - tokenName: (optional) string name of the token used to authenticate.
     * - url: (optional) string if provided it will be used directly.
     * - urlParams: (optional) string[] GET params to parse the url rule with
     *   `getRoutePattern()`.
     * - httpCode: integer expected Http Code response.
     */
    protected function internalDelete(Tester $I, Example $example)
    {
        // Authenticates configured user.
        $this->authUser($I, $example);

        // Send request
        $I->sendDELETE($this->parseUrl($example));
            sendDELETE($this->parseUrl($example));

        // Check response code.
        $I->seeResponseCodeIs($example['httpCode']);
            seeResponseCodeIs($example['httpCode']);
    }

    /**
     * Checks the response Http code and the response based on the Http code and
     * a list of pairs 'httpCode' => 'responseMethod' provided in the
     * `$responses` parameter.
     *
     * If the Http Code in the response doesn't match any of the keys in
     * `$responses` then `checkErrorResponse` will be used instead.
     *
     * @param array $responses pairs of 'httpCode' => 'responseMethod' which
     * will determine how to check the response.
     * @param Tester $I
     * @param Example $example data used for the testing. It uses the keys
     * - httpCode: integer expected Http Code response. If the httpCode is
     *   a key in `$responses` parameter then the method defined there will be
     *   used to analyze the response. Otherwise `checkErrorResponse()` will be
     *   used.
     * - error: (optional) mixed expected json being contained in the response.
     * - headers: (optional) string[] pairs of header => value expected in the
     *   response.
     */
    protected function checkResponse(
        array $responses,
        Tester $I,
        Example $example
    ) {
        $I->seeResponseCodeIs($example['httpCode']);
        if (isset($responses[$example['httpCode']])) {
            $responseMethod = $responses[$example['httpCode']];
            $this->$responseMethod($I, $example);
        } else {
            $this->checkErrorResponse($I, $example);
        }
        if (isset($example['headers'])) {
            foreach ($example['headers'] as $header => $value) {
                $I->seeHttpHeader($header, (string)$value);
                    seeHttpHeader($header, (string)$value);
            }
        }
    }

    /**
     * Checks an expected success collection response.
     *
     * @param Tester $I
     * @param Example $example
     */
    protected function checkSuccessIndexResponse(Tester $I, Example $example)
    {
        $I->seeResponseMatchesJsonType($this->recordJsonType());
            seeResponseMatchesJsonType($this->recordJsonType());
        $I->seeContentTypeHttpHeader();
        $I->seePaginationHttpHeaders();
    }

    /**
     * Checks an expected success record response.
     *
     * @param Tester $I
     * @param Example $example
     */
    protected function checkSuccessViewResponse(Tester $I, Example $example)
    {
        $I->seeResponseMatchesJsonType($this->recordJsonType());
        $I->seeContentTypeHttpHeader();
    }

    /**
     * Checks an expected success record creation response.
     *
     * @param Tester $I
     * @param Example $example
     */
    protected function checkSuccessCreateResponse(Tester $I, Example $example)
    {
        $this->checkSuccessViewResponse($I, $example);
        $I->seeHttpHeaderOnce('Location');
            seeHttpHeaderOnce('Location');
        $this->checkSelfLink($I, $I->grabHttpHeader('Location'));
        $this->checkSelfLink($I, $I->/** @scrutinizer ignore-call */ grabHttpHeader('Location'));
    }

    /**
     * Checks an expected response containing validation errors.
     *
     * @param Tester $I
     * @param Example $example data used for the testing. It uses the keys
     * - validationErrors: string[] (optional) pairs of field => message
     *   validation errors.
     */
    protected function checkValidationResponse(Tester $I, Example $example)
    {
        $I->seeResponseMatchesJsonType([
            'field' => 'string',
            'message' => 'string',
        ]);
        if (empty($example['validationErrors'])) {
            return;
        }
        $expected = [];
        foreach ($example['validationErrors'] as $field => $message) {
            $expected[] = [
                'field' => $field,
                'message' => $message,
            ];
        }
        $I->seeResponseContainsJson($expected);
    }

    /**
     * Checks an expected error response from user input.
     *
     * @param Tester $I
     * @param Example $example data used for the testing. It uses the keys
     * - error: (optional) mixed expected json being contained in the response.
     */
    protected function checkErrorResponse(Tester $I, Example $example)
    {
        $I->seeResponseMatchesJsonType([
            'name' => 'string',
            'message' => 'string',
            'code' => 'integer',
        ]);
        if (isset($example['error'])) {
            $I->seeResponseContainsJson($example['error']);
        }
    }

    /**
     * @param Tester $I
     * @param string $expected the expected self link.
     */
    protected function checkSelfLink(Tester $I, string $expected)
    {
        if ('' == $path = $this->selfLinkPath()) {
            return;
        }
        Verify::Array($I->grabDataFromResponseByJsonPath($path))
        Verify::Array($I->/** @scrutinizer ignore-call */ grabDataFromResponseByJsonPath($path))
            ->contains($expected);
    }

    /**
     * @return string the path which will be used to obtain the self link of a
     * record. Return empty string to skip that check.
     */
    protected function selfLinkPath(): string
    {
        return '$._links.self.href';
    }

    /**
     * Expected Json Type for each resource.
     *
     * @return array
     * @see http://codeception.com/docs/modules/REST#seeResponseMatchesJsonType
     */
    abstract protected function recordJsonType(): array;

    /**
     * @return string route pattern to create the
     */
    abstract protected function getRoutePattern(): string;
}
ROAResearch / yii2-roa

AbstractResourceCest::internalDelete() A last analyzed 2022-11-23 22:41 UTC

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like

AbstractResourceCest::internalDelete() A
last analyzed 2022-11-23 22:41 UTC
