Merge pull request #90 from Sammyjo20/feature/recording-mock-client

Feature | Mocking Fixtures

Author: Sammyjo20

.gitignore

@@ -3,3 +3,4 @@ composer.lock
 vendor
 .php-cs-fixer.cache
 .phpunit.result.cache
+tests/Fixtures/Saloon

composer.json

@@ -26,6 +26,7 @@
     },
     "require-dev": {
         "friendsofphp/php-cs-fixer": "^3.5",
+        "league/flysystem": "^3.0",
         "pestphp/pest": "^1.21",
         "spatie/ray": "^1.33"
     },

src/Clients/BaseMockClient.php

@@ -3,6 +3,7 @@
 namespace Sammyjo20\Saloon\Clients;
 
 use ReflectionClass;
+use Sammyjo20\Saloon\Http\Fixture;
 use Sammyjo20\Saloon\Helpers\URLHelper;
 use Sammyjo20\Saloon\Http\MockResponse;
 use PHPUnit\Framework\Assert as PHPUnit;
@@ -80,12 +81,12 @@ public function addResponses(array $responses): void
     /**
      * Add a mock response to the client
      *
-     * @param MockResponse|callable $response
+     * @param MockResponse|Fixture|callable $response
      * @param string|null $captureMethod
      * @return void
      * @throws SaloonInvalidMockResponseCaptureMethodException
      */
-    public function addResponse(MockResponse|callable $response, ?string $captureMethod = null): void
+    public function addResponse(MockResponse|Fixture|callable $response, ?string $captureMethod = null): void
     {
         if (is_null($captureMethod)) {
             $this->sequenceResponses[] = $response;
@@ -135,11 +136,12 @@ public function getNextFromSequence(): mixed
      * Guess the next response based on the request.
      *
      * @param SaloonRequest $request
-     * @return MockResponse
+     * @return MockResponse|Fixture
      * @throws SaloonNoMockResponseFoundException
+     * @throws \ReflectionException
      * @throws \Sammyjo20\Saloon\Exceptions\SaloonInvalidConnectorException
      */
-    public function guessNextResponse(SaloonRequest $request): MockResponse
+    public function guessNextResponse(SaloonRequest $request): MockResponse|Fixture
     {
         $requestClass = get_class($request);
 
@@ -173,7 +175,7 @@ public function guessNextResponse(SaloonRequest $request): MockResponse
      * @return MockResponse|null
      * @throws \Sammyjo20\Saloon\Exceptions\SaloonInvalidConnectorException
      */
-    private function guessResponseFromUrl(SaloonRequest $request): MockResponse|callable|null
+    private function guessResponseFromUrl(SaloonRequest $request): MockResponse|Fixture|callable|null
     {
         foreach ($this->urlResponses as $url => $response) {
             if (! URLHelper::matches($url, $request->getFullRequestUrl())) {
@@ -458,18 +460,22 @@ private function checkHistoryEmpty(): bool
     }
 
     /**
-     * Create the mock response. If it is a callable, we will call it.
+     * Get the mock value.
      *
-     * @param MockResponse|callable $mockResponse
+     * @param MockResponse|Fixture|callable $mockable
      * @param SaloonRequest $request
-     * @return MockResponse
+     * @return MockResponse|Fixture
      */
-    private function mockResponseValue(MockResponse|callable $mockResponse, SaloonRequest $request): MockResponse
+    private function mockResponseValue(MockResponse|Fixture|callable $mockable, SaloonRequest $request): MockResponse|Fixture
     {
-        if ($mockResponse instanceof MockResponse) {
-            return $mockResponse;
+        if ($mockable instanceof MockResponse) {
+            return $mockable;
+        }
+
+        if ($mockable instanceof Fixture) {
+            return $mockable;
         }
 
-        return $mockResponse($request);
+        return $mockable($request);
     }
 }

src/Data/FixtureData.php

@@ -0,0 +1,93 @@
+<?php
+
+namespace Sammyjo20\Saloon\Data;
+
+use JsonSerializable;
+use Psr\Http\Message\ResponseInterface;
+use Sammyjo20\Saloon\Http\MockResponse;
+
+class FixtureData implements JsonSerializable
+{
+    /**
+     * Constructor
+     *
+     * @param int $statusCode
+     * @param array $headers
+     * @param mixed $data
+     */
+    public function __construct(
+        public int $statusCode,
+        public array $headers = [],
+        public mixed $data = null,
+    ) {
+        //
+    }
+
+    /**
+     * Create an instance from file contents
+     *
+     * @param string $contents
+     * @return static
+     * @throws \JsonException
+     */
+    public static function fromFile(string $contents): static
+    {
+        $fileData = json_decode($contents, true, 512, JSON_THROW_ON_ERROR);
+
+        return new static(
+            statusCode: $fileData['statusCode'],
+            headers: $fileData['headers'],
+            data: $fileData['data']
+        );
+    }
+
+    /**
+     * Create an instance from a Guzzle response
+     *
+     * @param ResponseInterface $response
+     * @return static
+     */
+    public static function fromGuzzleResponse(ResponseInterface $response): static
+    {
+        return new static(
+            statusCode: $response->getStatusCode(),
+            headers: $response->getHeaders(),
+            data: (string)$response->getBody(),
+        );
+    }
+
+    /**
+     * Encode the instance to be stored as a file
+     *
+     * @return string
+     * @throws \JsonException
+     */
+    public function toFile(): string
+    {
+        return json_encode($this, JSON_THROW_ON_ERROR);
+    }
+
+    /**
+     * Create a mock response from the fixture
+     *
+     * @return MockResponse
+     */
+    public function toMockResponse(): MockResponse
+    {
+        return new MockResponse($this->data, $this->statusCode, $this->headers);
+    }
+
+    /**
+     * Define the JSON object if this class is converted into JSON
+     *
+     * @return array
+     */
+    public function jsonSerialize(): array
+    {
+        return [
+            'statusCode' => $this->statusCode,
+            'headers' => $this->headers,
+            'data' => $this->data,
+        ];
+    }
+}

src/Exceptions/DirectoryNotFoundException.php

@@ -0,0 +1,16 @@
+<?php
+
+namespace Sammyjo20\Saloon\Exceptions;
+
+class DirectoryNotFoundException extends SaloonException
+{
+    /**
+     * Constructor
+     *
+     * @param string $directory
+     */
+    public function __construct(string $directory)
+    {
+        parent::__construct(sprintf('The directory "%s" does not exist or is not a valid directory.', $directory));
+    }
+}

src/Exceptions/FixtureMissingException.php

@@ -0,0 +1,16 @@
+<?php
+
+namespace Sammyjo20\Saloon\Exceptions;
+
+class FixtureMissingException extends SaloonException
+{
+    /**
+     * Constructor
+     *
+     * @param string $name
+     */
+    public function __construct(string $name)
+    {
+        parent::__construct(sprintf('The fixture "%s" could not be found in storage.', $name));
+    }
+}

src/Exceptions/OAuthConfigValidationException.php

@@ -2,9 +2,7 @@
 
 namespace Sammyjo20\Saloon\Exceptions;
 
-use \Exception;
-
-class OAuthConfigValidationException extends Exception
+class OAuthConfigValidationException extends SaloonException
 {
     //
 }

src/Exceptions/UnableToCreateDirectoryException.php

@@ -0,0 +1,16 @@
+<?php
+
+namespace Sammyjo20\Saloon\Exceptions;
+
+class UnableToCreateDirectoryException extends SaloonException
+{
+    /**
+     * Constructor
+     *
+     * @param string $directory
+     */
+    public function __construct(string $directory)
+    {
+        parent::__construct(sprintf('Unable to create the directory: %s.', $directory));
+    }
+}

src/Exceptions/UnableToCreateFileException.php

@@ -0,0 +1,16 @@
+<?php
+
+namespace Sammyjo20\Saloon\Exceptions;
+
+class UnableToCreateFileException extends SaloonException
+{
+    /**
+     * Constructor
+     *
+     * @param string $path
+     */
+    public function __construct(string $path)
+    {
+        parent::__construct(sprintf('We were unable to create the "%s" file.', $path));
+    }
+}

src/Helpers/MockConfig.php

@@ -0,0 +1,61 @@
+<?php
+
+namespace Sammyjo20\Saloon\Helpers;
+
+class MockConfig
+{
+    /**
+     * Default fixture path
+     *
+     * @var string
+     */
+    private static string $fixturePath = 'tests/Fixtures/Saloon';
+
+    /**
+     * Denotes if an exception should be thrown if a fixture is missing.
+     *
+     * @var bool
+     */
+    private static bool $throwOnMissingFixtures = false;
+
+    /**
+     * Set the fixture path
+     *
+     * @param string $path
+     * @return void
+     */
+    public static function setFixturePath(string $path): void
+    {
+        self::$fixturePath = $path;
+    }
+
+    /**
+     * Throw an exception if a fixture doesn't exist instead of recording it.
+     *
+     * @return void
+     */
+    public static function throwOnMissingFixtures(): void
+    {
+        self::$throwOnMissingFixtures = true;
+    }
+
+    /**
+     * Return the fixture path
+     *
+     * @return string
+     */
+    public static function getFixturePath(): string
+    {
+        return self::$fixturePath;
+    }
+
+    /**
+     * Should we throw an exception if a fixture is missing?
+     *
+     * @return bool
+     */
+    public static function isThrowingOnMissingFixtures(): bool
+    {
+        return self::$throwOnMissingFixtures;
+    }
+}