Refactored endpoints, api and test cases for better usability/stability

- Tests are now mockery free. - Add more tests for Laravel container
wrk-flow · Oct 2, 2023 · a7d0244 · a7d0244
1 parent 262d1e3
commit a7d0244
Show file tree

Hide file tree

Showing 31 changed files with 1,152 additions and 583 deletions.
diff --git a/src/AbstractApi.php b/src/AbstractApi.php
@@ -7,8 +7,6 @@
 use Closure;
 use JustSteveKing\UriBuilder\Uri;
 use Psr\Http\Message\ResponseInterface;
-use Psr\Http\Message\StreamInterface;
-use WrkFlow\ApiSdkBuilder\Actions\SendRequestAction;
 use WrkFlow\ApiSdkBuilder\Contracts\ApiFactoryContract;
 use WrkFlow\ApiSdkBuilder\Endpoints\AbstractEndpoint;
 use WrkFlow\ApiSdkBuilder\Environments\AbstractEnvironment;
@@ -17,8 +15,6 @@
 use WrkFlow\ApiSdkBuilder\Exceptions\ServerFailedException;
 use WrkFlow\ApiSdkBuilder\Interfaces\ApiInterface;
 use WrkFlow\ApiSdkBuilder\Interfaces\EnvironmentOverrideEndpointsInterface;
-use WrkFlow\ApiSdkBuilder\Interfaces\OptionsInterface;
-use WrkFlow\ApiSdkBuilder\Responses\AbstractResponse;
 
 abstract class AbstractApi implements ApiInterface
 {
@@ -29,25 +25,17 @@ abstract class AbstractApi implements ApiInterface
      */
     private array $cachedEndpoints = [];
 
-    private ?SendRequestAction $sendRequestAction = null;
-
     /**
      * @var array<class-string, class-string<AbstractEndpoint>>
      */
     private readonly array $overrideEndpoints;
 
-    /**
-     * @param array<class-string, class-string<AbstractEndpoint>> $overrideEndpoints
-     */
+
     public function __construct(
         private readonly AbstractEnvironment $environment,
-        private readonly ApiFactoryContract $factory,
-        array $overrideEndpoints = []
+        private readonly ApiFactoryContract $factory
     ) {
-        $this->overrideEndpoints = array_merge(
-            $overrideEndpoints,
-            $environment instanceof EnvironmentOverrideEndpointsInterface ? $environment->endpoints() : []
-        );
+        $this->overrideEndpoints = $environment instanceof EnvironmentOverrideEndpointsInterface ? $environment->endpoints() : [];
     }
 
     final public function environment(): AbstractEnvironment
@@ -67,124 +55,6 @@ final public function uri(): Uri
         return $this->environment->uri();
     }
 
-    final public function get(
-        string $responseClass,
-        Uri $uri,
-        array $headers = [],
-        ?int $expectedResponseStatusCode = null,
-        Closure $shouldIgnoreLoggersOnError = null,
-    ): AbstractResponse {
-        $request = $this->factory()
-            ->request()
-            ->createRequest('GET', $uri->toString());
-
-        return $this->sendRequestAction()
-            ->execute(
-                api: $this,
-                request: $request,
-                responseClass: $responseClass,
-                headers: $headers,
-                expectedResponseStatusCode: $expectedResponseStatusCode,
-                shouldIgnoreLoggersOnError: $shouldIgnoreLoggersOnError,
-            );
-    }
-
-    final public function post(
-        string $responseClass,
-        Uri $uri,
-        OptionsInterface|StreamInterface|string $body = null,
-        array $headers = [],
-        ?int $expectedResponseStatusCode = null,
-        Closure $shouldIgnoreLoggersOnError = null,
-    ): AbstractResponse {
-        $request = $this->factory()
-            ->request()
-            ->createRequest('POST', $uri->toString());
-
-        return $this->sendRequestAction()
-            ->execute(
-                api: $this,
-                request: $request,
-                responseClass: $responseClass,
-                body: $body,
-                headers: $headers,
-                expectedResponseStatusCode: $expectedResponseStatusCode,
-                shouldIgnoreLoggersOnError: $shouldIgnoreLoggersOnError,
-            );
-    }
-
-    final public function put(
-        string $responseClass,
-        Uri $uri,
-        OptionsInterface|StreamInterface|string $body = null,
-        array $headers = [],
-        ?int $expectedResponseStatusCode = null,
-        Closure $shouldIgnoreLoggersOnError = null,
-    ): AbstractResponse {
-        $request = $this->factory()
-            ->request()
-            ->createRequest('PUT', $uri->toString());
-
-        return $this->sendRequestAction()
-            ->execute(
-                api: $this,
-                request: $request,
-                responseClass: $responseClass,
-                body: $body,
-                headers: $headers,
-                expectedResponseStatusCode: $expectedResponseStatusCode,
-                shouldIgnoreLoggersOnError: $shouldIgnoreLoggersOnError,
-            );
-    }
-
-    final public function delete(
-        string $responseClass,
-        Uri $uri,
-        OptionsInterface|StreamInterface|string $body = null,
-        array $headers = [],
-        ?int $expectedResponseStatusCode = null,
-        Closure $shouldIgnoreLoggersOnError = null,
-    ): AbstractResponse {
-        $request = $this->factory()
-            ->request()
-            ->createRequest('DELETE', $uri->toString());
-
-        return $this->sendRequestAction()
-            ->execute(
-                api: $this,
-                request: $request,
-                responseClass: $responseClass,
-                body: $body,
-                headers: $headers,
-                expectedResponseStatusCode: $expectedResponseStatusCode,
-                shouldIgnoreLoggersOnError: $shouldIgnoreLoggersOnError,
-            );
-    }
-
-    public function fake(
-        ResponseInterface $response,
-        string $responseClass,
-        Uri $uri,
-        OptionsInterface|StreamInterface|string $body = null,
-        array $headers = [],
-        ?int $expectedResponseStatusCode = null,
-        Closure $shouldIgnoreLoggersOnError = null,
-    ): AbstractResponse {
-        return $this->sendRequestAction()
-            ->execute(
-                api: $this,
-                request: $this->factory()
-                    ->request()
-                    ->createRequest('FAKE', $uri->toString()),
-                responseClass: $responseClass,
-                body: $body,
-                headers: $headers,
-                expectedResponseStatusCode: $expectedResponseStatusCode,
-                fakedResponse: $response,
-                shouldIgnoreLoggersOnError: $shouldIgnoreLoggersOnError,
-            );
-    }
-
     public function createFailedResponseException(int $statusCode, ResponseInterface $response): ResponseException
     {
         if ($statusCode >= 400 && $statusCode < 500) {
@@ -194,6 +64,11 @@ public function createFailedResponseException(int $statusCode, ResponseInterface
         return new ServerFailedException($response);
     }
 
+    final public function shouldIgnoreLoggersOnException(): ?Closure
+    {
+        return null;
+    }
+
     /**
      * @template T of AbstractEndpoint
      *
@@ -247,15 +122,4 @@ private function getOverrideEndpointClassIfCan(string $endpoint): string
 
         return $endpoint;
     }
-
-    private function sendRequestAction(): SendRequestAction
-    {
-        if ($this->sendRequestAction instanceof SendRequestAction === false) {
-            $this->sendRequestAction = $this->factory()
-                ->container()
-                ->make(SendRequestAction::class);
-        }
-
-        return $this->sendRequestAction;
-    }
 }
diff --git a/src/Actions/MakeApiFactory.php b/src/Actions/MakeApiFactory.php
@@ -61,7 +61,7 @@ interface: StreamFactoryInterface::class,
     }
 
     /**
-     * @template T
+     * @template T of object
      *
      * @param class-string<T> $interface
      * @param Closure():T     $create

diff --git a/src/Actions/SendRequestAction.php b/src/Actions/SendRequestAction.php
@@ -10,23 +10,25 @@
 use Psr\Http\Message\RequestInterface;
 use Psr\Http\Message\ResponseInterface;
 use Psr\Http\Message\StreamInterface;
-use Throwable;
-use WrkFlow\ApiSdkBuilder\AbstractApi;
+use WrkFlow\ApiSdkBuilder\Contracts\SendRequestActionContract;
 use WrkFlow\ApiSdkBuilder\Environments\AbstractEnvironment;
 use WrkFlow\ApiSdkBuilder\Events\RequestConnectionFailedEvent;
 use WrkFlow\ApiSdkBuilder\Events\RequestFailedEvent;
 use WrkFlow\ApiSdkBuilder\Events\ResponseReceivedEvent;
 use WrkFlow\ApiSdkBuilder\Events\SendingRequestEvent;
 use WrkFlow\ApiSdkBuilder\Exceptions\ResponseException;
+use WrkFlow\ApiSdkBuilder\Interfaces\ApiInterface;
 use WrkFlow\ApiSdkBuilder\Interfaces\EnvironmentFakeResponseInterface;
-use WrkFlow\ApiSdkBuilder\Interfaces\HeadersInterface;
 use WrkFlow\ApiSdkBuilder\Interfaces\OptionsInterface;
 use WrkFlow\ApiSdkBuilder\Log\Entities\LoggerConfigEntity;
 use WrkFlow\ApiSdkBuilder\Log\Entities\LoggerFailConfigEntity;
 use WrkFlow\ApiSdkBuilder\Log\Interfaces\ApiLoggerInterface;
 use WrkFlow\ApiSdkBuilder\Responses\AbstractResponse;
 
-final class SendRequestAction
+/**
+ * @phpstan-import-type IgnoreLoggersOnExceptionClosure from ApiInterface
+ */
+final class SendRequestAction implements SendRequestActionContract
 {
     public function __construct(
         private readonly BuildHeadersAction $buildHeadersAction,
@@ -35,20 +37,8 @@ public function __construct(
     ) {
     }
 
-    /**
-     * @template TResponse of AbstractResponse
-     *
-     * @param array<int|string,HeadersInterface|string|string[]> $headers
-     * @param class-string<TResponse>                            $responseClass
-     * @param int|null                                           $expectedResponseStatusCode Will raise and failed
-     *                                                                                      exception if response
-     *                                                                                      status code is different
-     * @param Closure(Throwable):array<ApiLoggerInterface>|null $shouldIgnoreLoggersOnError
-     *
-     * @return TResponse
-     */
     public function execute(
-        AbstractApi $api,
+        ApiInterface $api,
         RequestInterface $request,
         string $responseClass,
         OptionsInterface|StreamInterface|string|null $body = null,
@@ -68,7 +58,7 @@ public function execute(
         $loggerConfig = $api->factory()
             ->loggerConfig();
 
-        $logger = $this->getLoggerAction->execute(config: $loggerConfig, host: $request->getUri() ->getHost());
+        $logger = $this->getLoggerAction->execute(config: $loggerConfig, host: $request->getUri()->getHost());
 
         $environment = $api->environment();
 
@@ -107,7 +97,7 @@ public function execute(
      */
     private function sendRequest(
         AbstractEnvironment $environment,
-        AbstractApi $api,
+        ApiInterface $api,
         ?EventDispatcherInterface $dispatcher,
         ?ApiLoggerInterface $logger,
         LoggerConfigEntity $loggerConfig,
@@ -149,7 +139,7 @@ private function sendRequest(
     }
 
     private function withBody(
-        AbstractApi $api,
+        ApiInterface $api,
         OptionsInterface|StreamInterface|string|null $body,
         RequestInterface $request
     ): RequestInterface {
@@ -174,16 +164,16 @@ private function getRequestDuration(float $timeStart): float
     /**
      * @template TResponse of AbstractResponse
      *
-     * @param class-string<TResponse> $responseClass
-     * @param int|null                $expectedResponseStatusCode Will raise and failed
+     * @param class-string<TResponse>         $responseClass
+     * @param int|null                        $expectedResponseStatusCode Will raise and failed
      *                                                                                      exception if response
      *                                                                                      status code is different
-     * @param Closure(Throwable):array<ApiLoggerInterface>|null $shouldIgnoreLoggersOnError
+     * @param IgnoreLoggersOnExceptionClosure $shouldIgnoreLoggersOnError
      *
      * @return TResponse
      */
     private function handleResponse(
-        AbstractApi $api,
+        ApiInterface $api,
         ResponseInterface $response,
         ?int $expectedResponseStatusCode,
         string $responseClass,
@@ -254,7 +244,7 @@ private function handleResponse(
 
     private function buildRequest(
         AbstractEnvironment $environment,
-        AbstractApi $api,
+        ApiInterface $api,
         array $headers,
         RequestInterface $request,
         StreamInterface|string|OptionsInterface|null $body

diff --git a/src/Contracts/SDKContainerFactoryContract.php b/src/Contracts/SDKContainerFactoryContract.php
@@ -5,8 +5,8 @@
 namespace WrkFlow\ApiSdkBuilder\Contracts;
 
 use Psr\Http\Message\ResponseInterface;
-use WrkFlow\ApiSdkBuilder\AbstractApi;
 use WrkFlow\ApiSdkBuilder\Endpoints\AbstractEndpoint;
+use WrkFlow\ApiSdkBuilder\Interfaces\ApiInterface;
 use WrkFlow\ApiSdkBuilder\Responses\AbstractResponse;
 use Wrkflow\GetValue\GetValue;
 
@@ -19,12 +19,12 @@ interface SDKContainerFactoryContract
      *
      * @return T
      */
-    public function makeEndpoint(AbstractApi $api, string $endpointClass): AbstractEndpoint;
+    public function makeEndpoint(ApiInterface $api, string $endpointClass): AbstractEndpoint;
 
     /**
      * Dynamically creates an instance of the given class.
      * - Some classes should be cached for performance (as singletons).
-     * @template T
+     * @template T of object
      *
      * @param class-string<T> $class
      *

diff --git a/src/Contracts/SendRequestActionContract.php b/src/Contracts/SendRequestActionContract.php
@@ -0,0 +1,42 @@
+<?php
+
+declare(strict_types=1);
+
+namespace WrkFlow\ApiSdkBuilder\Contracts;
+
+use Closure;
+use Psr\Http\Message\RequestInterface;
+use Psr\Http\Message\ResponseInterface;
+use Psr\Http\Message\StreamInterface;
+use WrkFlow\ApiSdkBuilder\Interfaces\ApiInterface;
+use WrkFlow\ApiSdkBuilder\Interfaces\HeadersInterface;
+use WrkFlow\ApiSdkBuilder\Interfaces\OptionsInterface;
+use WrkFlow\ApiSdkBuilder\Responses\AbstractResponse;
+
+/**
+ * @phpstan-import-type IgnoreLoggersOnExceptionClosure from ApiInterface
+ */
+interface SendRequestActionContract
+{
+    /**
+     * @template TResponse of AbstractResponse
+     *
+     * @param array<int|string,HeadersInterface|string|string[]> $headers
+     * @param class-string<TResponse>                            $responseClass
+     * @param int|null                                           $expectedResponseStatusCode Will raise and failed
+     *                                                                                      exception if response
+     *                                                                                      status code is different
+     * @param IgnoreLoggersOnExceptionClosure                    $shouldIgnoreLoggersOnError
+     * @return TResponse
+     */
+    public function execute(
+        ApiInterface $api,
+        RequestInterface $request,
+        string $responseClass,
+        OptionsInterface|StreamInterface|string|null $body = null,
+        array $headers = [],
+        ?int $expectedResponseStatusCode = null,
+        ?ResponseInterface $fakedResponse = null,
+        Closure $shouldIgnoreLoggersOnError = null
+    ): AbstractResponse;
+}