Polish tests and docs

Author: spawnia

src/Validator/ValidationCache.php

@@ -22,9 +22,8 @@ interface ValidationCache
      * This method should return true if the query has previously passed validation for the provided schema.
      * Only successful validations should be considered "cached" — failed validations are not cached.
      *
-     * Note: This allows for optimizations in systems where validation may not be necessary on every request —
-     * for example, when using persisted queries that are known to be valid ahead of time. In such cases, you
-     * can implement this method to always return true.
+     * This allows for optimizations in systems where validation may not be necessary on every request.
+     * For example, you can always return true for persisted queries that are known to be valid ahead of time.
      *
      * @return bool true if validation for the given schema + AST is already known to be valid; false otherwise
      */

tests/Executor/ValidationWithCacheTest.php

@@ -83,8 +83,8 @@ public function testIsValidationCachedWithAdapter(): void
         $resultB = GraphQL::executeQuery($schema, $query, null, null, null, null, null, null, $cache)->toArray();
 
         // ✅ Assert that validation only happened once
-        self::assertEquals(2, $cache->isValidatedCalls, 'Should check cache twice');
-        self::assertEquals(1, $cache->markValidatedCalls, 'Should mark as validated once');
+        self::assertSame(2, $cache->isValidatedCalls, 'Should check cache twice');
+        self::assertSame(1, $cache->markValidatedCalls, 'Should mark as validated once');
 
         $expected = [
             'data' => [
@@ -95,7 +95,7 @@ public function testIsValidationCachedWithAdapter(): void
             ],
         ];
 
-        self::assertEquals($expected, $resultA);
-        self::assertEquals($expected, $resultB);
+        self::assertSame($expected, $resultA);
+        self::assertSame($expected, $resultB);
     }
 }

tests/PsrValidationCacheAdapter.php

@@ -2,70 +2,74 @@
 
 namespace GraphQL\Tests;
 
+use GraphQL\Error\Error;
+use GraphQL\Error\InvariantViolation;
+use GraphQL\Error\SerializationError;
 use GraphQL\Language\AST\DocumentNode;
 use GraphQL\Type\Schema;
 use GraphQL\Utils\SchemaPrinter;
 use GraphQL\Validator\ValidationCache;
 use Psr\SimpleCache\CacheInterface;
-use Symfony\Component\String\Exception\InvalidArgumentException;
+use Psr\SimpleCache\InvalidArgumentException;
 
 class PsrValidationCacheAdapter implements ValidationCache
 {
-    private const KEY_PREFIX = 'gql_validation_';
-
-    private int $ttl;
-
     private CacheInterface $cache;
 
+    private int $ttlSeconds;
+
     public function __construct(
         CacheInterface $cache,
         int $ttlSeconds = 300
     ) {
-        $this->ttl = $ttlSeconds;
         $this->cache = $cache;
+        $this->ttlSeconds = $ttlSeconds;
     }
 
-    /** @throws InvalidArgumentException */
+    /**
+     * @throws \JsonException
+     * @throws Error
+     * @throws InvalidArgumentException&\Throwable
+     * @throws InvariantViolation
+     * @throws SerializationError
+     */
     public function isValidated(Schema $schema, DocumentNode $ast): bool
     {
-        try {
-            $key = $this->buildKey($schema, $ast);
+        $key = $this->buildKey($schema, $ast);
 
-            /** @phpstan-ignore missingType.checkedException */
-            return $this->cache->has($key);
-        } catch (\Throwable $e) {
-            return false;
-        }
+        return $this->cache->has($key); // @phpstan-ignore missingType.checkedException (annotated as a union with Throwable)
     }
 
-    /** @throws InvalidArgumentException */
+    /**
+     * @throws \JsonException
+     * @throws Error
+     * @throws InvalidArgumentException&\Throwable
+     * @throws InvariantViolation
+     * @throws SerializationError
+     */
     public function markValidated(Schema $schema, DocumentNode $ast): void
     {
-        try {
-            $key = $this->buildKey($schema, $ast);
-            /** @phpstan-ignore missingType.checkedException */
-            $this->cache->set($key, true, $this->ttl);
-        } catch (\Throwable $e) {
-            // ignore silently
-        }
+        $key = $this->buildKey($schema, $ast);
+
+        $this->cache->set($key, true, $this->ttlSeconds); // @phpstan-ignore missingType.checkedException (annotated as a union with Throwable)
     }
 
     /**
-     * @throws \GraphQL\Error\Error
-     * @throws \GraphQL\Error\InvariantViolation
-     * @throws \GraphQL\Error\SerializationError
      * @throws \JsonException
+     * @throws Error
+     * @throws InvariantViolation
+     * @throws SerializationError
      */
     private function buildKey(Schema $schema, DocumentNode $ast): string
     {
         /**
-         * NOTE: This default strategy generates a cache key by hashing the printed schema and AST.
-         * You'll likely want to replace this with a more stable or efficient method for fingerprinting
-         * the schema -- for example, a build-time hash, schema version number, or an environment-based identifier.
+         * This default strategy generates a cache key by hashing the printed schema and AST.
+         * You'll likely want to replace this with a more stable or efficient method for fingerprinting the schema.
+         * For example, you may use a build-time hash, schema version number, or an environment-based identifier.
          */
         $schemaHash = md5(SchemaPrinter::doPrint($schema));
         $astHash = md5(serialize($ast));
 
-        return self::KEY_PREFIX . $schemaHash . '_' . $astHash;
+        return "graphql_validation_{$schemaHash}_{$astHash}";
     }
 }