ApiTestCase::setRequester() - Code Metrics - Inspection of "Add Parameter to test against the URL and QueryStr..." - byjg/php-swagger-test - Measure and Improve Code Quality continuously with Scrutinizer

Passed
Pull Request — master (#82)

by Joao
created 2025-07-02 21:49 UTC
ApiTestCase::setRequester() A

↳ Parent: ApiTestCase
Complexity

Conditions	1
Paths	1
Size

Total Lines	3
Code Lines	1
Duplication

Lines	0
Ratio	0 %
Importance

Changes
Metric	Value
eloc	1
dl	0
loc	3
c	0
b	0
f	0
rs	10
cc	1
nc	1
nop	1
<?php

namespace ByJG\ApiTools;

use ByJG\ApiTools\Base\Schema;
use ByJG\ApiTools\Exception\DefinitionNotFoundException;
use ByJG\ApiTools\Exception\GenericSwaggerException;
use ByJG\ApiTools\Exception\HttpMethodNotFoundException;
use ByJG\ApiTools\Exception\InvalidDefinitionException;
use ByJG\ApiTools\Exception\InvalidRequestException;
use ByJG\ApiTools\Exception\NotMatchedException;
use ByJG\ApiTools\Exception\PathNotFoundException;
use ByJG\ApiTools\Exception\RequiredArgumentNotFound;
use ByJG\ApiTools\Exception\StatusCodeNotMatchedException;
use ByJG\WebRequest\Psr7\Response;
use PHPUnit\Framework\TestCase;
use Psr\Http\Message\ResponseInterface;
use Throwable;

abstract class ApiTestCase extends TestCase
{
    /**
     * @var Schema|null
     */
    protected ?Schema $schema = null;

    /**
     * @var AbstractRequester|null
     */
    protected ?AbstractRequester $requester = null;

    /**
     * configure the schema to use for requests
     *
     * When set, all requests without an own schema use this one instead.
     *
     * @param Schema|null $schema
     */
    public function setSchema(?Schema $schema): void
    {
        $this->schema = $schema;
    }

    public function setRequester(AbstractRequester $requester): void
    {
        $this->requester = $requester;
    }

    /**
     * @return AbstractRequester|null
     */
    protected function getRequester(): AbstractRequester|null
    {
        if (is_null($this->requester)) {
            $this->requester = new ApiRequester();
        }
        return $this->requester;
    }

    /**
     * @param string $method The HTTP Method: GET, PUT, DELETE, POST, etc
     * @param string $path The REST path call
     * @param int $statusExpected
     * @param string|array|null $query
     * @param array|string|null $requestBody
     * @param array $requestHeader
     * @return mixed
     * @throws DefinitionNotFoundException
     * @throws GenericSwaggerException
     * @throws HttpMethodNotFoundException
     * @throws InvalidDefinitionException
     * @throws InvalidRequestException
     * @throws NotMatchedException
     * @throws PathNotFoundException
     * @throws RequiredArgumentNotFound
     * @throws StatusCodeNotMatchedException
     * @deprecated Use assertRequest instead
     */
    protected function makeRequest(
        string $method,
        string $path,
        int $statusExpected = 200,
        string|array|null $query = null,
        array|string $requestBody = null,
        array $requestHeader = []
    ): ResponseInterface {
        $this->checkSchema();
        $body = $this->requester
            ->withSchema($this->schema)
            ->/** @scrutinizer ignore-call */ withSchema($this->schema)
            ->withMethod($method)
            ->withPath($path)
            ->withQuery($query)
            ->withRequestBody($requestBody)
            ->withRequestBody(/** @scrutinizer ignore-type */ $requestBody)
            ->withRequestHeader($requestHeader)
            ->assertResponseCode($statusExpected)
            ->send();

        // Note:
        // This code is only reached if to send is successful and
        // all matches are satisfied. Otherwise, an error is throwed before
        // reach this
        $this->assertTrue(true);

        return $body;
    }

    /**
     * @param AbstractRequester $request
     * @return Response
     * @throws DefinitionNotFoundException
     * @throws GenericSwaggerException
     * @throws HttpMethodNotFoundException
     * @throws InvalidDefinitionException
     * @throws InvalidRequestException
     * @throws NotMatchedException
     * @throws PathNotFoundException
     * @throws RequiredArgumentNotFound
     * @throws StatusCodeNotMatchedException
     */
    public function assertRequest(AbstractRequester $request, bool $matchQueryParams = true): ResponseInterface
    {
        // Add own schema if nothing is passed.
        if (!$request->hasSchema()) {
            $this->checkSchema();
            $request = $request->withSchema($this->schema);
            $request = $request->withSchema(/** @scrutinizer ignore-type */ $this->schema);
        }

        // Request based on the Swagger Request definitios
        $body = $request->send($matchQueryParams);

        // Note:
        // This code is only reached if to send is successful and
        // all matches are satisfied. Otherwise, an error is throwed before
        // reach this
        $this->assertTrue(true);

        return $body;
    }

    public function assertRequestException(AbstractRequester $request, string $exceptionClass, string $exceptionMessage = null, bool $matchQueryParams = true): Throwable
    {
        try {
            $this->assertRequest($request, $matchQueryParams);
        } catch (Throwable $ex) {
            $this->assertInstanceOf($exceptionClass, $ex);

            if (!empty($exceptionMessage)) {
                $this->assertStringContainsString($exceptionMessage, $ex->getMessage());
            }

            return $ex;
        }
        $this->fail("Expected exception '{$exceptionClass}' but no exception was thrown");
interface ReturnsInt {
    public function returnsIntHinted(): int;
}

class MyClass implements ReturnsInt {
    public function returnsIntHinted(): int
    {
        if (foo()) {
            return 123;
        }
        // here: null is implicitly returned
    }
}
    }


    /**
     * @throws GenericSwaggerException
     */
    protected function checkSchema(): void
    {
        if (!$this->schema) {
            throw new GenericSwaggerException('You have to configure a schema for either the request or the testcase');
        }
    }
}

byjg / php-swagger-test

Pull Request — master (#82)

ApiTestCase::setRequester() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like
