tests/Api/JsonApiTestCase.php (6)

292-312: Good API simplification; consider clarifying the flag semantics and documenting behavior

The refactor to fetch the response internally simplifies tests. The boolean $assertViolationsCount toggles between exact-match and contains-match, which is slightly opaque. Consider renaming it to $exactMatch or improving the docblock to explicitly state “true = exact, false = contains”. Also, since this method asserts 422 and JSON headers already, downstream tests don’t need to assert the status code again.

---

319-360: Harden JSON handling and reduce double-decoding in exact-violations

You decode the response JSON twice and assume both violations and hydra:description exist. Decode once, validate the structure, and produce clearer failure messages if keys are missing.

Apply:

-        $response = $this->client->getResponse();
-
-        $responseContent = $response->getContent() ?: '';
-        $this->assertNotEmpty($responseContent);
-
-        $actualViolations = json_decode($responseContent, true)['violations'];
-        $actualDescription = json_decode($responseContent, true)['hydra:description'];
+        $response = $this->client->getResponse();
+
+        $responseContent = $response->getContent() ?: '';
+        $this->assertNotEmpty($responseContent);
+
+        $decoded = json_decode($responseContent, true);
+        $this->assertIsArray($decoded, 'Response content is not valid JSON or not an object.');
+        $this->assertArrayHasKey('violations', $decoded, 'Response JSON is missing "violations" key.');
+        $this->assertArrayHasKey('hydra:description', $decoded, 'Response JSON is missing "hydra:description" key.');
+
+        $actualViolations = $decoded['violations'];
+        $actualDescription = $decoded['hydra:description'];

---

367-385: Containment check: guard for missing propertyPath and improve diagnostics

Current map-building assumes propertyPath exists on each violation. For robustness, treat missing/empty paths explicitly and surface a focused message when expected paths are absent.

You can minimally harden it with:

-        foreach ($violations as $violation) {
-            $violationMap[$violation['propertyPath']][] = $violation['message'];
-        }
+        foreach ($violations as $violation) {
+            $path = $violation['propertyPath'] ?? '';
+            $violationMap[$path][] = $violation['message'];
+        }

And when asserting:

-            $this->assertArrayHasKey($propertyPath, $violationMap, $responseContent);
+            $this->assertArrayHasKey(
+                $propertyPath,
+                $violationMap,
+                sprintf('Expected violation path "%s" not found. Full response: %s', $propertyPath, $responseContent),
+            );

---

424-437: Helper looks good; consider reusing existing response-code assertion for consistency

The helper is a nice consolidation. For consistency with the rest of the suite, consider using $this->assertResponseCode($response, $statusCode) instead of self::assertEquals(...), which will keep error formatting uniform.

-        self::assertEquals(
-            $statusCode,
-            $response->getStatusCode(),
-            json_encode(json_decode($response->getContent(), true), JSON_PRETTY_PRINT)
-        );
+        $this->assertResponseCode($response, $statusCode);

---

439-463: Surface “expected file missing/invalid” clearly and handle null ComparisonFailure safely

If the expected file is missing, the current message suggests “not valid JSON”. Also, getComparisonFailure() can be null—fallback to the exception message to avoid a fatal.

     protected function assertJsonResponseContent(Response $response, string $filename): void
     {
         $expectedFilePath = $this->expectedResponsesPath . '/' . $filename . '.json';
-        $expected = file_get_contents($expectedFilePath);
+        if (!is_file($expectedFilePath)) {
+            $this->fail(sprintf('Expected response file does not exist: "%s".', $expectedFilePath));
+        }
+        $expected = file_get_contents($expectedFilePath);
         $actual = $response->getContent() ?: '';
 
         $expectedArray = json_decode($expected, true);
         if (null === $expectedArray) {
-            $this->fail(sprintf('Expected response content is not a valid JSON, check the file: "%s".json', $filename));
+            $this->fail(sprintf('Expected response file contains invalid JSON: "%s".', $expectedFilePath));
         }
 
         $actualArray = json_decode($actual, true);
         if (null === $actualArray) {
             $this->fail('Actual response content is not a valid JSON');
         }
 
         $actualArray = $this->replaceDynamicValues($expectedArray, $actualArray);
 
         try {
             $this->assertJsonStringEqualsJsonString(json_encode($expectedArray), json_encode($actualArray));
         } catch (ExpectationFailedException $e) {
-            $expectedFileReferenceMessage = "Check the expected response file: \n" . $expectedFilePath;
-            $this->fail($e->getComparisonFailure()->getDiff() . "\n" . $expectedFileReferenceMessage);
+            $diff = $e->getComparisonFailure() ? $e->getComparisonFailure()->getDiff() : $e->getMessage();
+            $this->fail($diff . "\nCheck the expected response file:\n" . $expectedFilePath);
         }
     }

---

465-523: Dynamic placeholders: add existence/type guards to avoid notices and edge-case mis-replacements

Great addition. A few guards will reduce brittle behavior when keys are missing or types differ (e.g., using substr on non-strings).

     protected function replaceDynamicValues(array $expectedArray, array $actualArray): array
     {
         foreach ($expectedArray as $key => $value) {
-            if (is_array($value) && isset($actualArray[$key]) && is_array($actualArray[$key])) {
+            if (is_array($value) && isset($actualArray[$key]) && is_array($actualArray[$key])) {
                 $actualArray[$key] = $this->replaceDynamicValues($value, $actualArray[$key]);
 
                 continue;
             }
 
             if (is_string($value)) {
                 if (str_contains($value, '@integer@')) {
-                    if (!isset($actualArray[$key])) {
+                    if (!isset($actualArray[$key])) {
                         continue;
                     }
                     $position = strpos($value, '@integer@');
                     if (strcmp(substr($value, 0, $position), substr((string) $actualArray[$key], 0, $position)) !== 0) {
                         continue;
                     }
                     $actualArray[$key] = substr_replace((string)$actualArray[$key], '@integer@', $position);
                 }
-                elseif (str_contains($value, '@array@')) {
+                elseif (str_contains($value, '@array@')) {
+                    if (!isset($actualArray[$key])) {
+                        continue;
+                    }
                     $position = strpos($value, '@array@');
                     $actualArray[$key] = substr_replace(json_encode($actualArray[$key]), '@array@', $position);
                 }
-                elseif (str_contains($value, '@boolean@')) {
+                elseif (str_contains($value, '@boolean@')) {
+                    if (!isset($actualArray[$key])) {
+                        continue;
+                    }
                     $position = strpos($value, '@boolean@');
                     $actualArray[$key] = substr_replace((string)$actualArray[$key], '@boolean@', $position);
                 }
                 elseif (str_contains($value, '@string@')) {
                     if (!isset($actualArray[$key])) {
                         continue;
                     }
                     $position = strpos($value, '@string@');
                     if (strcmp(substr($value, 0, $position), substr((string) $actualArray[$key], 0, $position)) !== 0) {
                         continue;
                     }
                     if (!str_contains($actualArray[$key], substr($value, 8))) {
                         continue;
                     }
 
                     $position = strpos($value, '@string@');
                     $limit = null;
                     if (strlen($value) > strlen('@string@')) {
                         $expectedRightSubstring = substr($value, $position + strlen('@string@'));
                         $actualRightSubstringPosition = strpos($actualArray[$key], $expectedRightSubstring);
                         if (false !== $actualRightSubstringPosition) {
                             $limit = $actualRightSubstringPosition - $position;
                         }
                     }
                     $actualArray[$key] = substr_replace((string)$actualArray[$key], '@string@', $position, $limit);
-                } elseif (str_contains($value, '@date@')) {
+                } elseif (str_contains($value, '@date@')) {
+                    if (!isset($actualArray[$key])) {
+                        continue;
+                    }
                     $position = strpos($value, '@date@');
                     $actualArray[$key] = substr_replace((string)$actualArray[$key], '@date@', $position);
                 }
             }
         }
 
         return $actualArray;
     }

If you want, I can follow up with a more type-aware placeholder strategy (e.g., strict boolean/array checks) without changing current semantics.

tests/Api/Admin/ChannelsTest.php (1)

128-130: Avoid redundant 422 assertions; assertResponseViolations already checks status + headers

assertResponseViolations([...], false) asserts HTTP_UNPROCESSABLE_ENTITY and JSON headers internally. The preceding assertResponseStatusCodeSame(...) is redundant and can be removed to reduce noise.

-        $this->assertResponseStatusCodeSame(Response::HTTP_UNPROCESSABLE_ENTITY);
         $this->assertResponseViolations([$validation], false);

tests/Api/Shop/AddressesTest.php (1)

255-270: Remove redundant 422 assertion; helper already covers it

assertResponseViolations([...]) asserts HTTP 422 and JSON headers internally; the preceding assertResponseStatusCodeSame(...) duplicates that check.

-        $this->assertResponseStatusCodeSame(Response::HTTP_UNPROCESSABLE_ENTITY);
         $this->assertResponseViolations([
             [
                 'propertyPath' => 'countryCode',
                 'message' => 'This value is not a valid country.',
             ],
             [
                 'propertyPath' => 'phoneNumber',
                 'message' => 'This value is too long. It should have 255 characters or less.',
             ],
             [
                 'propertyPath' => 'company',
                 'message' => 'This value is too long. It should have 255 characters or less.',
             ],
         ]);

tests/Api/Admin/AddressesTest.php (1)

101-119: Avoid repeated status check; relies on helper’s internal 422 assertion

Same as other tests: assertResponseViolations([...], false) asserts 422 already, so the explicit assertResponseStatusCodeSame(...) can be dropped.

-        $this->assertResponseStatusCodeSame(Response::HTTP_UNPROCESSABLE_ENTITY);
         $this->assertResponseViolations(
             [
                 [
                     'propertyPath' => 'countryCode',
                     'message' => 'This value is not a valid country.',
                 ],
                 [
                     'propertyPath' => 'phoneNumber',
                     'message' => 'This value is too long. It should have 255 characters or less.',
                 ],
                 [
                     'propertyPath' => 'company',
                     'message' => 'This value is too long. It should have 255 characters or less.',
                 ],
             ],
             false,
         );

tests/Api/Shop/OrdersTest.php (1)

463-467: Consider "contains" vs "exact" violation assertion

The new assertResponseViolations defaults to exact-count checks. If the API ever returns additional violations alongside the message you assert, this test may become brittle. If your intent is “contains,” add false as the second param.

Proposed change:

-        $this->assertResponseViolations(
+        $this->assertResponseViolations(
             [
                 ['propertyPath' => '', 'message' => 'You cannot change the payment method for a cancelled order.'],
             ],
-        );
+            false,
+        );

tests/Api/Admin/ShippingMethodsTest.php (2)

270-297: WEB/MOBILE propertyPath swap — double-check backend mapping

You’ve switched expected paths to rules[2].configuration[WEB][amount] then [MOBILE], and likewise for rules[3]. If backend assembles violations per-channel without guaranteed order, relying on exact paths may be order-sensitive. If flakiness occurs, prefer contains mode (second param false) or ensure the comparison is order-insensitive.

Option if you prefer “contains” semantics here:

-        $this->assertResponseViolations(
+        $this->assertResponseViolations(
             [
                 [
                     'propertyPath' => 'rules[0].configuration[weight]',
                     'message' => 'This value should be of type numeric.',
                 ],
                 [
                     'propertyPath' => 'rules[1].configuration[weight]',
                     'message' => 'This value should be of type numeric.',
                 ],
                 [
                     'propertyPath' => 'rules[2].configuration[WEB][amount]',
                     'message' => 'This value should be of type numeric.',
                 ],
                 [
                     'propertyPath' => 'rules[2].configuration[MOBILE][amount]',
                     'message' => 'This value should be of type numeric.',
                 ],
                 [
                     'propertyPath' => 'rules[3].configuration[WEB][amount]',
                     'message' => 'This value should be of type numeric.',
                 ],
                 [
                     'propertyPath' => 'rules[3].configuration[MOBILE][amount]',
                     'message' => 'This value should be of type numeric.',
                 ],
-            ],
-        );
+            ],
+            false,
+        );

---

536-560: Keep channel-key expectations stable across updates

Same WEB/MOBILE path ordering adjustment here. If validator internals change key iteration, exact matching might become brittle. Consider contains mode or confirm your JsonApiTestCase asserts ignore ordering when comparing arrays of violations.

If you decide to switch to contains:

-        $this->assertResponseViolations(
+        $this->assertResponseViolations(
             [
                 [
                     'propertyPath' => 'rules[0].configuration[weight]',
                     'message' => 'This value should be of type numeric.',
                 ],
                 [
                     'propertyPath' => 'rules[1].configuration[weight]',
                     'message' => 'This value should be of type numeric.',
                 ],
                 [
                     'propertyPath' => 'rules[2].configuration[WEB][amount]',
                     'message' => 'This value should be of type numeric.',
                 ],
                 [
                     'propertyPath' => 'rules[2].configuration[MOBILE][amount]',
                     'message' => 'This value should be of type numeric.',
                 ],
                 [
                     'propertyPath' => 'rules[3].configuration[WEB][amount]',
                     'message' => 'This value should be of type numeric.',
                 ],
                 [
                     'propertyPath' => 'rules[3].configuration[MOBILE][amount]',
                     'message' => 'This value should be of type numeric.',
                 ],
-            ],
-        );
+            ],
+            false,
+        );

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

💡 Knowledge Base configuration:

• MCP integration is disabled by default for public repositories
• Jira integration is disabled by default for public repositories
• Linear integration is disabled by default for public repositories

You can enable these sources in your CodeRabbit configuration.