Merge pull request #141 from Sammyjo20/feature/v2-handling-simulated-responses

Feature | V2 Allow other simulated responses to take priority

Author: Sammyjo20

src/Contracts/MiddlewarePipeline.php

@@ -11,20 +11,20 @@ interface MiddlewarePipeline
     /**
      * Add a middleware before the request is sent
      *
-     * @param callable $closure
+     * @param callable $callable
      * @param bool $prepend
      * @return $this
      */
-    public function onRequest(callable $closure, bool $prepend = false): static;
+    public function onRequest(callable $callable, bool $prepend = false): static;
 
     /**
      * Add a middleware after the request is sent
      *
-     * @param callable $closure
+     * @param callable $callable
      * @param bool $prepend
      * @return $this
      */
-    public function onResponse(callable $closure, bool $prepend = false): static;
+    public function onResponse(callable $callable, bool $prepend = false): static;
 
     /**
      * Process the request pipeline.

src/Contracts/PendingRequest.php

@@ -232,4 +232,19 @@ public function sendAsync(): PromiseInterface;
      * @return mixed
      */
     public function createDtoFromResponse(Response $response): mixed;
+
+    /**
+     * Set if the request is going to be sent asynchronously
+     *
+     * @param bool $asynchronous
+     * @return $this
+     */
+    public function setAsynchronous(bool $asynchronous): static;
+
+    /**
+     * Check if the request is asynchronous
+     *
+     * @return bool
+     */
+    public function isAsynchronous(): bool;
 }

src/Helpers/MiddlewarePipeline.php

@@ -37,14 +37,14 @@ public function __construct()
     /**
      * Add a middleware before the request is sent
      *
-     * @param callable $closure
+     * @param callable $callable
      * @param bool $prepend
      * @return $this
      */
-    public function onRequest(callable $closure, bool $prepend = false): static
+    public function onRequest(callable $callable, bool $prepend = false): static
     {
-        $this->requestPipeline = $this->requestPipeline->pipe(function (PendingRequest $pendingRequest) use ($closure) {
-            $result = $closure($pendingRequest);
+        $this->requestPipeline = $this->requestPipeline->pipe(function (PendingRequest $pendingRequest) use ($callable) {
+            $result = $callable($pendingRequest);
 
             if ($result instanceof PendingRequest) {
                 return $result;
@@ -63,14 +63,14 @@ public function onRequest(callable $closure, bool $prepend = false): static
     /**
      * Add a middleware after the request is sent
      *
-     * @param callable $closure
+     * @param callable $callable
      * @param bool $prepend
      * @return $this
      */
-    public function onResponse(callable $closure, bool $prepend = false): static
+    public function onResponse(callable $callable, bool $prepend = false): static
     {
-        $this->responsePipeline = $this->responsePipeline->pipe(function (Response $response) use ($closure) {
-            $result = $closure($response);
+        $this->responsePipeline = $this->responsePipeline->pipe(function (Response $response) use ($callable) {
+            $result = $callable($response);
 
             return $result instanceof Response ? $result : $response;
         }, $prepend);

src/Http/Dispatcher.php

@@ -16,9 +16,8 @@ class Dispatcher implements DispatcherContract
      * Constructor
      *
      * @param PendingRequest $pendingRequest
-     * @param bool $asynchronous
      */
-    public function __construct(protected PendingRequest $pendingRequest, protected bool $asynchronous = false)
+    public function __construct(protected PendingRequest $pendingRequest)
     {
         //
     }
@@ -37,7 +36,7 @@ public function execute(): Response|PromiseInterface
         // to create the SimulatedResponse and return that. Otherwise, we
         // will send a real request to the sender.
 
-        $response = $this->getSender()->sendRequest($pendingRequest, $this->asynchronous);
+        $response = $this->getSender()->sendRequest($pendingRequest, $pendingRequest->isAsynchronous());
 
         // Next we will need to run the response pipeline. If the response
         // is a Response we can run it directly, but if it is

src/Http/Middleware/DetermineMockResponse.php

@@ -25,6 +25,10 @@ public function __invoke(PendingRequest $pendingRequest): PendingRequest|MockRes
             return $pendingRequest;
         }
 
+        if ($pendingRequest->hasSimulatedResponsePayload()) {
+            return $pendingRequest;
+        }
+
         $mockClient = $pendingRequest->getMockClient();
 
         // When we guess the next response from the MockClient it will

src/Http/PendingRequest.php

@@ -87,6 +87,13 @@ class PendingRequest implements PendingRequestContract
      */
     protected ?SimulatedResponsePayload $simulatedResponsePayload = null;
 
+    /**
+     * Determine if the pending request is asynchronous
+     *
+     * @var bool
+     */
+    protected bool $asynchronous = false;
+
     /**
      * Build up the request payload.
      *
@@ -436,6 +443,8 @@ protected function resolveResponseClass(): string
      */
     public function send(): ResponseContract
     {
+        $this->setAsynchronous(false);
+
         return (new Dispatcher($this))->execute();
     }
 
@@ -446,7 +455,9 @@ public function send(): ResponseContract
      */
     public function sendAsync(): PromiseInterface
     {
-        return (new Dispatcher($this, true))->execute();
+        $this->setAsynchronous(true);
+
+        return (new Dispatcher($this))->execute();
     }
 
     /**
@@ -459,4 +470,27 @@ public function createDtoFromResponse(ResponseContract $response): mixed
     {
         return $this->request->createDtoFromResponse($response) ?? $this->connector->createDtoFromResponse($response);
     }
+
+    /**
+     * Set if the request is going to be sent asynchronously
+     *
+     * @param bool $asynchronous
+     * @return PendingRequestContract
+     */
+    public function setAsynchronous(bool $asynchronous): static
+    {
+        $this->asynchronous = $asynchronous;
+
+        return $this;
+    }
+
+    /**
+     * Check if the request is asynchronous
+     *
+     * @return bool
+     */
+    public function isAsynchronous(): bool
+    {
+        return $this->asynchronous;
+    }
 }

src/Http/Pool.php

@@ -141,8 +141,10 @@ public function getRequests(): Generator
      * Send the pool and create a Promise
      *
      * @return \GuzzleHttp\Promise\PromiseInterface
+     * @throws \ReflectionException
      * @throws \Saloon\Exceptions\InvalidPoolItemException
-     * @throws \Saloon\Exceptions\SaloonException
+     * @throws \Saloon\Exceptions\InvalidResponseClassException
+     * @throws \Saloon\Exceptions\PendingRequestException
      */
     public function send(): PromiseInterface
     {

tests/Feature/AsyncRequestTest.php

@@ -25,6 +25,7 @@
 
     $data = $response->json();
 
+    expect($response->getPendingRequest()->isAsynchronous())->toBeTrue();
     expect($response->isMocked())->toBeFalse();
     expect($response->status())->toEqual(200);
 

tests/Feature/RequestTest.php

@@ -16,6 +16,7 @@
 
     $data = $response->json();
 
+    expect($response->getPendingRequest()->isAsynchronous())->toBeFalse();
     expect($response)->toBeInstanceOf(Response::class);
     expect($response->isMocked())->toBeFalse();
     expect($response->status())->toEqual(200);

tests/Feature/SimulatedResponsePayloadTest.php

@@ -0,0 +1,26 @@
+<?php
+
+declare(strict_types=1);
+
+use Saloon\Http\Faking\MockClient;
+use Saloon\Http\Faking\MockResponse;
+use Saloon\Tests\Fixtures\Requests\UserRequest;
+use Saloon\Http\Faking\SimulatedResponsePayload;
+use Saloon\Tests\Fixtures\Connectors\TestConnector;
+
+test('if a simulated response payload was provided before mock response it will take priority', function () {
+    $mockClient = new MockClient([
+        new MockResponse(['name' => 'Sam'], 200, ['X-Greeting' => 'Howdy']),
+    ]);
+
+    $fakeResponse = new SimulatedResponsePayload(['name' => 'Gareth'], 201, ['X-Greeting' => 'Hello']);
+
+    $request = new UserRequest;
+    $request->middleware()->onRequest(fn () => $fakeResponse);
+
+    $response = TestConnector::make()->send($request, $mockClient);
+
+    expect($response->json())->toEqual(['name' => 'Gareth']);
+    expect($response->status())->toEqual(201);
+    expect($response->header('X-Greeting'))->toEqual('Hello');
+});