Add support for reload, reloadOnly and reloadExcept

Author: pascalbaljet

src/Testing/AssertableInertia.php

@@ -3,7 +3,6 @@
 namespace Inertia\Testing;
 
 use Closure;
-use Illuminate\Foundation\Application;
 use Illuminate\Testing\Fluent\AssertableJson;
 use Illuminate\Testing\TestResponse;
 use InvalidArgumentException;
@@ -83,21 +82,30 @@ public function version(string $value): self
         return $this;
     }
 
-    public function partial(array|string $key, ?Closure $callback = null, ?Application $app = null): self
+    public function reload(?Closure $callback = null, array|string|null $only = null, array|string|null $except = null): self
     {
-        $partialRequest = new PartialRequest(
-            is_array($key) ? implode(',', $key) : $key,
+        if (is_array($only)) {
+            $only = implode(',', $only);
+        }
+
+        if (is_array($except)) {
+            $except = implode(',', $except);
+        }
+
+        $reloadRequest = new ReloadRequest(
             $this->url,
             $this->component,
             $this->version,
-            $app ?? app()
+            $only,
+            $except,
         );
 
-        $assertable = static::fromTestResponse($partialRequest());
+        $assertable = AssertableInertia::fromTestResponse($reloadRequest());
+
+        // Make sure we get the same data as the original request.
         $assertable->component($this->component);
         $assertable->url($this->url);
         $assertable->version($this->version);
-        $assertable->hasAll(is_array($key) ? $key : explode(',', $key));
 
         if ($callback) {
             $callback($assertable);
@@ -106,6 +114,28 @@ public function partial(array|string $key, ?Closure $callback = null, ?Applicati
         return $this;
     }
 
+    public function reloadOnly(array|string $only, ?Closure $callback = null): self
+    {
+        return $this->reload(only: $only, callback: function (AssertableInertia $assertable) use ($only, $callback) {
+            $assertable->hasAll(explode(',', $only));
+
+            if ($callback) {
+                $callback($assertable);
+            }
+        });
+    }
+
+    public function reloadExcept(array|string $except, ?Closure $callback = null): self
+    {
+        return $this->reload(except: $except, callback: function (AssertableInertia $assertable) use ($except, $callback) {
+            $assertable->missingAll(explode(',', $except));
+
+            if ($callback) {
+                $callback($assertable);
+            }
+        });
+    }
+
     public function toArray()
     {
         return [

src/Testing/PartialRequest.php

@@ -0,0 +1,41 @@
+<?php
+
+namespace Inertia\Testing;
+
+use Illuminate\Foundation\Application;
+use Illuminate\Foundation\Testing\Concerns\MakesHttpRequests;
+use Illuminate\Testing\TestResponse;
+use Inertia\Support\Header;
+
+class ReloadRequest
+{
+    use MakesHttpRequests;
+
+    public function __construct(
+        protected string $url,
+        protected string $component,
+        protected string $version,
+        protected ?string $only = null,
+        protected ?string $except = null,
+        protected ?Application $app = null
+    ) {
+        $this->app ??= app();
+    }
+
+    public function __invoke(): TestResponse
+    {
+        $headers = [Header::VERSION => $this->version];
+
+        if (! blank($this->only)) {
+            $headers[Header::PARTIAL_COMPONENT] = $this->component;
+            $headers[Header::PARTIAL_ONLY] = $this->only;
+        }
+
+        if (! blank($this->except)) {
+            $headers[Header::PARTIAL_COMPONENT] = $this->component;
+            $headers[Header::PARTIAL_EXCEPT] = $this->except;
+        }
+
+        return $this->get($this->url, $headers);
+    }
+}

src/Testing/ReloadRequest.php

@@ -52,7 +52,7 @@ protected function getTestResponseClass(): string
     protected function makeMockRequest($view)
     {
         app('router')->get('/example-url', function () use ($view) {
-            return $view;
+            return is_callable($view) ? $view() : $view;
         });
 
         return $this->get('/example-url');

tests/TestCase.php

@@ -3,6 +3,7 @@
 namespace Inertia\Tests\Testing;
 
 use Inertia\Inertia;
+use Inertia\Testing\AssertableInertia;
 use Inertia\Tests\TestCase;
 use PHPUnit\Framework\AssertionFailedError;
 
@@ -194,23 +195,85 @@ public function test_the_asset_version_does_not_match(): void
         });
     }
 
+    public function test_reloading_a_visit(): void
+    {
+        $foo = 0;
+
+        $response = $this->makeMockRequest(function () use (&$foo) {
+            return Inertia::render('foo', [
+                'foo' => $foo++,
+            ]);
+        });
+
+        $called = false;
+
+        $response->assertInertia(function ($inertia) use (&$called) {
+            $inertia->where('foo', 0);
+
+            $inertia->reload(function ($inertia) use (&$called) {
+                $inertia->where('foo', 1);
+                $called = true;
+            });
+        });
+
+        $this->assertTrue($called);
+    }
+
     public function test_lazy_props_can_be_evaluated(): void
     {
         $response = $this->makeMockRequest(
             Inertia::render('foo', [
                 'foo' => 'bar',
-                'lazy' => Inertia::lazy(fn () => 'baz'),
+                'lazy1' => Inertia::lazy(fn () => 'baz'),
+                'lazy2' => Inertia::lazy(fn () => 'qux'),
             ])
         );
 
-        $response->assertInertia(function ($inertia) {
+        $called = false;
+
+        $response->assertInertia(function ($inertia) use (&$called) {
             $inertia->where('foo', 'bar');
-            $inertia->missing('lazy');
+            $inertia->missing('lazy1');
+            $inertia->missing('lazy2');
 
-            $inertia->partial('lazy', function ($inertia) {
-                $inertia->where('lazy', 'baz');
+            $result = $inertia->reloadOnly('lazy1', function ($inertia) use (&$called) {
                 $inertia->missing('foo');
+                $inertia->where('lazy1', 'baz');
+                $inertia->missing('lazy2');
+                $called = true;
             });
+
+            $this->assertSame($result, $inertia);
         });
+
+        $this->assertTrue($called);
+    }
+
+    public function test_lazy_props_can_be_evaluated_with_except(): void
+    {
+        $response = $this->makeMockRequest(
+            Inertia::render('foo', [
+                'foo' => 'bar',
+                'lazy1' => Inertia::lazy(fn () => 'baz'),
+                'lazy2' => Inertia::lazy(fn () => 'qux'),
+            ])
+        );
+
+        $called = false;
+
+        $response->assertInertia(function (AssertableInertia $inertia) use (&$called) {
+            $inertia->where('foo', 'bar');
+            $inertia->missing('lazy1');
+            $inertia->missing('lazy2');
+
+            $inertia->reloadExcept('lazy1', function ($inertia) use (&$called) {
+                $inertia->where('foo', 'bar');
+                $inertia->missing('lazy1');
+                $inertia->where('lazy2', 'qux');
+                $called = true;
+            });
+        });
+
+        $this->assertTrue($called);
     }
 }