refactor: clean up http testing

Author: innocenzi

src/Tempest/Framework/Testing/Http/HttpRouterTester.php

@@ -13,6 +13,7 @@
 use Tempest\Http\Request;
 use Tempest\Router\RouteConfig;
 use Tempest\Router\Router;
+use Tempest\Validation\Validator;
 
 use function Tempest\map;
 
@@ -140,7 +141,8 @@ public function sendRequest(Request $request): TestResponseHelper
         $this->container->get(RouteConfig::class)->throwHttpExceptions = $this->throwHttpExceptions;
 
         return new TestResponseHelper(
-            $router->dispatch(map($request)->with(RequestToPsrRequestMapper::class)->do()),
+            response: $router->dispatch(map($request)->with(RequestToPsrRequestMapper::class)->do()),
+            container: $this->container,
         );
     }
 

src/Tempest/Framework/Testing/Http/TestResponseHelper.php

@@ -7,12 +7,14 @@
 use Closure;
 use Generator;
 use PHPUnit\Framework\Assert;
+use Tempest\Container\Container;
 use Tempest\Http\Cookie\CookieManager;
 use Tempest\Http\Response;
 use Tempest\Http\Responses\Invalid;
 use Tempest\Http\Session\Session;
 use Tempest\Http\Status;
 use Tempest\Validation\Rule;
+use Tempest\Validation\Validator;
 use Tempest\View\View;
 use Tempest\View\ViewRenderer;
 
@@ -23,6 +25,7 @@ final class TestResponseHelper
 {
     public function __construct(
         private(set) Response $response,
+        private(set) ?Container $container = null,
     ) {}
 
     public Status $status {
@@ -110,9 +113,9 @@ public function assertStatus(Status $expected): self
 
     public function assertHasCookie(string $key, ?Closure $callback = null): self
     {
-        $cookies = get(CookieManager::class);
+        $this->assertHasContainer();
 
-        $cookie = $cookies->get($key);
+        $cookie = $this->container->get(CookieManager::class)->get($key);
 
         Assert::assertNotNull($cookie);
 
@@ -125,14 +128,14 @@ public function assertHasCookie(string $key, ?Closure $callback = null): self
 
     public function assertHasSession(string $key, ?Closure $callback = null): self
     {
-        /** @var Session $session */
-        $session = get(Session::class);
+        $this->assertHasContainer();
 
+        $session = $this->container->get(Session::class);
         $data = $session->get($key);
 
         Assert::assertNotNull(
-            $data,
-            sprintf(
+            actual: $data,
+            message: sprintf(
                 'No session value was set for [%s], available session keys: %s',
                 $key,
                 implode(', ', array_keys($session->data)),
@@ -148,15 +151,13 @@ public function assertHasSession(string $key, ?Closure $callback = null): self
 
     public function assertHasValidationError(string $key, ?Closure $callback = null): self
     {
-        /** @var Session $session */
-        $session = get(Session::class);
-
+        $session = $this->container->get(Session::class);
         $validationErrors = $session->get(Session::VALIDATION_ERRORS) ?? [];
 
         Assert::assertArrayHasKey(
-            $key,
-            $validationErrors,
-            sprintf(
+            key: $key,
+            array: $validationErrors,
+            message: sprintf(
                 'No validation error was set for [%s], available validation errors: %s',
                 $key,
                 implode(', ', array_keys($validationErrors)),
@@ -172,23 +173,16 @@ public function assertHasValidationError(string $key, ?Closure $callback = null)
 
     public function assertHasNoValidationsErrors(): self
     {
-        /** @var Session $session */
-        $session = get(Session::class);
-
+        $session = $this->container->get(Session::class);
         $validationErrors = $session->get(Session::VALIDATION_ERRORS) ?? [];
 
         Assert::assertEmpty(
-            $validationErrors,
-            sprintf(
-                'There should be no validation errors, but there were: %s',
-                arr($validationErrors)
-                    ->map(function (array $failingRules, $key) {
-                        $failingRules = arr($failingRules)->map(fn (Rule $rule) => $rule->getTranslationVariables())->implode(', ');
-
-                        return $key . ': ' . $failingRules;
-                    })
-                    ->implode(', '),
-            ),
+            actual: $validationErrors,
+            message: arr($validationErrors)
+                ->map(fn (array $failingRules, string $key) => $key . ': ' . arr($failingRules)->map(fn (Rule $rule) => $rule::class)->implode(', '))
+                ->implode(', ')
+                ->prepend('There should be no validation errors, but there were: ')
+                ->toString(),
         );
 
         return $this;
@@ -199,7 +193,7 @@ public function assertSee(string $search): self
         $body = $this->body;
 
         if ($body instanceof View) {
-            $body = get(ViewRenderer::class)->render($body);
+            $body = $this->container->get(ViewRenderer::class)->render($body);
         }
 
         Assert::assertStringContainsString($search, $body);
@@ -212,7 +206,7 @@ public function assertNotSee(string $search): self
         $body = $this->body;
 
         if ($body instanceof View) {
-            $body = get(ViewRenderer::class)->render($body);
+            $body = $this->container->get(ViewRenderer::class)->render($body);
         }
 
         Assert::assertStringNotContainsString($search, $body);
@@ -435,18 +429,21 @@ public function assertJsonContains(array $expected): self
      */
     public function assertHasJsonValidationErrors(array $expectedErrors): self
     {
+        $this->assertHasContainer();
+
         Assert::assertInstanceOf(Invalid::class, $this->response);
         Assert::assertContains($this->response->status, [Status::BAD_REQUEST, Status::FOUND]);
         Assert::assertNotNull($this->response->getHeader('x-validation'));
 
-        $session = get(Session::class);
+        $session = $this->container->get(Session::class);
+        $validator = $this->container->get(Validator::class);
         $validationRules = arr($session->get(Session::VALIDATION_ERRORS))->dot();
 
-        $dottedExpectedErrors = arr($expectedErrors)->dot();
-        arr($dottedExpectedErrors)
+        arr($expectedErrors)
+            ->dot()
             ->each(fn ($expectedErrorValue, $expectedErrorKey) => Assert::assertEquals(
-                $expectedErrorValue,
-                $validationRules->get($expectedErrorKey)->message(),
+                expected: $expectedErrorValue,
+                actual: $validator->getErrorMessage($validationRules->get($expectedErrorKey)),
             ));
 
         return $this;
@@ -478,4 +475,11 @@ public function dd(): void
          */
         dd($this->response); // @mago-expect best-practices/no-debug-symbols
     }
+
+    private function assertHasContainer(): void
+    {
+        if ($this->container === null) {
+            Assert::fail('This assertion requires a container.');
+        }
+    }
 }

tests/Integration/Http/ValidationResponseTest.php

@@ -96,7 +96,7 @@ public function test_failing_post_request(): void
                 uri([ValidationController::class, 'updateBook'], book: 1),
                 body: ['book' => ['title' => 1]],
             )
-            ->assertHasJsonValidationErrors(['title' => ['Value should be between 1 and 120']]);
+            ->assertHasJsonValidationErrors(['title' => ['Value must be between 1 and 120']]);
 
         $this->assertSame('Timeline Taxi', Book::find(id: 1)->first()->title);
     }