Request chunking and better testing helpers

Author: aarondfrancis

src/Client.php

@@ -5,9 +5,9 @@
 
 namespace Torchlight;
 
+use Illuminate\Http\Client\Pool;
 use Illuminate\Support\Arr;
 use Illuminate\Support\Collection;
-use Illuminate\Support\Facades\Cache;
 use Illuminate\Support\Facades\Http;
 use Throwable;
 use Torchlight\Exceptions\ConfigurationException;
@@ -42,26 +42,35 @@ public function highlight($blocks)
 
     protected function request(Collection $blocks)
     {
-        $blocks = $this->collectionOfBlocks($blocks);
-
-        $host = Torchlight::config('host', 'https://api.torchlight.dev');
+        $error = false;
 
         try {
-            $response = Http::timeout(5)
-                ->withToken($this->getToken())
-                ->post($host . '/highlight', [
-                    'blocks' => $this->blocksAsRequestParam($blocks)->values()->toArray(),
-                ])
-                ->json();
+            $response = $this->collectionOfBlocks($blocks)
+                ->chunk(Torchlight::config('request_chunk_size', 15))
+                ->pipe(function ($chunks) {
+                    return collect($this->requestChunks($chunks));
+                })
+                ->map(function ($response) use (&$error) {
+                    if ($response instanceof Throwable) {
+                        $error = $response;
+
+                        return [];
+                    }
+
+                    if ($response->failed()) {
+                        $error = $response->toException();
+
+                        return [];
+                    }
+
+                    return Arr::get($response->json(), 'blocks', []);
+                })
+                ->flatten(1);
         } catch (Throwable $e) {
-            $response = [
-                'error' => $e->getMessage()
-            ];
+            $this->throwUnlessProduction($e);
         }
 
-        $this->potentiallyThrowRequestException($response);
-
-        $response = collect(Arr::get($response, 'blocks', []))->keyBy('id');
+        $response = collect($response)->keyBy('id');
 
         $blocks->each(function (Block $block) use ($response) {
             $blockFromResponse = Arr::get($response, "{$block->id()}", []);
@@ -84,9 +93,28 @@ protected function request(Collection $blocks)
         // Only store the ones we got back from the API.
         $this->setCacheFromBlocks($blocks, $response->keys());
 
+        $this->potentiallyThrowRequestException($error);
+
         return $blocks;
     }
 
+    protected function requestChunks($chunks)
+    {
+        return Http::pool(function (Pool $pool) use ($chunks) {
+            $host = Torchlight::config('host', 'https://api.torchlight.dev');
+            $timeout = Torchlight::config('request_timeout', 5);
+
+            $chunks->each(function ($blocks) use ($pool, $host, $timeout) {
+                $pool->timeout($timeout)
+                    ->baseUrl($host)
+                    ->withToken($this->getToken())
+                    ->post('highlight', [
+                        'blocks' => $this->blocksAsRequestParam($blocks)->values()->toArray(),
+                    ]);
+            });
+        });
+    }
+
     protected function collectionOfBlocks($blocks)
     {
         return collect($blocks)->each(function ($block) {
@@ -109,10 +137,10 @@ protected function getToken()
         return $token;
     }
 
-    protected function potentiallyThrowRequestException($response)
+    protected function potentiallyThrowRequestException($exception)
     {
-        if ($error = Arr::get($response, 'error')) {
-            $this->throwUnlessProduction(new RequestException($error));
+        if ($exception) {
+            $this->throwUnlessProduction(new RequestException($exception->getMessage()));
         }
     }
 

tests/BaseTest.php

@@ -5,15 +5,106 @@
 
 namespace Torchlight\Tests;
 
+use Exception;
+use GuzzleHttp\Exception\ConnectException;
+use GuzzleHttp\Exception\TransferException;
+use GuzzleHttp\Promise\FulfilledPromise;
+use http\Client\Response;
+use Illuminate\Http\Client\ConnectionException;
+use Illuminate\Http\Client\Request;
+use Illuminate\Support\Arr;
+use Illuminate\Support\Facades\Http;
 use Orchestra\Testbench\TestCase;
+use Throwable;
+use Torchlight\Block;
 use Torchlight\TorchlightServiceProvider;
 
 abstract class BaseTest extends TestCase
 {
+    protected $apiFaked = false;
+
+    protected $fakeResponseBlocks = [];
+
+    protected function setUp(): void
+    {
+        parent::setUp();
+    }
+
     protected function getPackageProviders($app)
     {
         return [
             TorchlightServiceProvider::class
         ];
     }
+
+    protected function fakeApi()
+    {
+        $this->apiFaked = true;
+
+        $this->fakeResponseBlocks = [];
+
+        Http::fake([
+            'api.torchlight.dev/*' => function (Request $request) {
+                $response = [];
+
+                foreach ($request->data()['blocks'] as $block) {
+                    if (!Arr::has($this->fakeResponseBlocks, $block['id'])) {
+                        throw new TransferException('Torchlight block response not set for ' . $block['id']);
+                    }
+
+                    $fake = $this->fakeResponseBlocks[$block['id']];
+
+                    if (is_array($fake)) {
+                        $highlighted = "<div class='highlighted'>" . $block['code'] . "</div>";
+                        
+                        $response[] = array_merge($block, [
+                            'classes' => 'torchlight',
+                            'styles' => 'background-color: #000000;',
+                            'wrapped' => "<pre><code>$highlighted</code></pre>",
+                            'highlighted' => $highlighted,
+                        ], $fake);
+                    }
+
+                    if ($fake === ConnectException::class) {
+                        throw new ConnectException('Connection timed out', $request->toPsrRequest());
+                    }
+
+                    if ($fake instanceof Response || $fake instanceof FulfilledPromise) {
+                        return $fake;
+                    }
+                }
+
+                return Http::response([
+                    'duration' => 100,
+                    'engine' => 1,
+                    'blocks' => $response
+                ], 200);
+            },
+        ]);
+    }
+
+    protected function fakeSuccessfulResponse($id, $response = [])
+    {
+        $this->addFake($id, $response);
+    }
+
+    protected function fakeTimeout($id)
+    {
+        $this->addFake($id, ConnectException::class);
+    }
+
+    protected function fakeNullResponse($id)
+    {
+        $this->addFake($id, Http::response(null, 200));
+    }
+
+    protected function addFake($id, $response)
+    {
+        if (!$this->apiFaked) {
+            $this->fakeApi();
+        }
+
+        $this->fakeResponseBlocks[$id] = $response;
+    }
+
 }