Add comprehensive test coverage for documentId and validation cache

Agent-Logs-Url: https://github.com/fsprojects/FSharp.Data.GraphQL/sessions/fec46b15-afce-40da-85b4-306eae430ce0

Co-authored-by: xperiandri <2365592+xperiandri@users.noreply.github.com>

Author: Copilot

src/FSharp.Data.GraphQL.Shared/ValidationResultCache.fs

@@ -42,11 +42,10 @@ module SchemaId =
     let fromIntrospectionSchema (introspectionSchema : IntrospectionSchema) =
         use stream = new MemoryStream()
         JsonSerializer.Serialize(stream, introspectionSchema, jsonOptions)
-        stream.Position <- 0L
         // Note: Creating SHA256 instance per call is acceptable since schema ID computation
         // happens infrequently (typically once per schema during validation cache key creation)
         use sha256 = SHA256.Create()
-        let hash = sha256.ComputeHash stream
+        let hash = sha256.ComputeHash(stream.ToArray())
         hash
         |> Seq.map formatByteAsLowerHex
         |> String.concat ""

tests/FSharp.Data.GraphQL.Tests/DocumentIdTests.fs

@@ -0,0 +1,65 @@
+// The MIT License (MIT)
+// Copyright (c) 2016 Bazinga Technologies Inc
+
+module FSharp.Data.GraphQL.Tests.DocumentIdTests
+
+open Xunit
+open FSharp.Data.GraphQL
+
+[<Fact>]
+let ``DocumentId.fromCanonicalQuery produces deterministic hash`` () =
+    let query = "query Example { a b }"
+    let hash1 = DocumentId.fromCanonicalQuery query
+    let hash2 = DocumentId.fromCanonicalQuery query
+    equals hash1 hash2
+    equals 64 hash1.Length  // SHA-256 hex string is 64 chars
+
+[<Fact>]
+let ``DocumentId.fromCanonicalQuery produces different hashes for different queries`` () =
+    let query1 = "query Example1 { a }"
+    let query2 = "query Example2 { b }"
+    let hash1 = DocumentId.fromCanonicalQuery query1
+    let hash2 = DocumentId.fromCanonicalQuery query2
+    notEquals hash1 hash2
+
+[<Fact>]
+let ``DocumentId.fromCanonicalQuery handles empty string`` () =
+    let query = ""
+    let hash = DocumentId.fromCanonicalQuery query
+    equals 64 hash.Length
+    // SHA-256 of empty string
+    equals "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" hash
+
+[<Fact>]
+let ``DocumentId.fromCanonicalQuery produces lowercase hex`` () =
+    let query = "query Test { field }"
+    let hash = DocumentId.fromCanonicalQuery query
+    equals hash (hash.ToLowerInvariant())
+    Assert.True(hash |> Seq.forall (fun c -> (c >= '0' && c <= '9') || (c >= 'a' && c <= 'f')))
+
+[<Fact>]
+let ``DocumentId.fromCanonicalQuery handles special characters in strings`` () =
+    // Test with escaped characters that should be in the canonical form
+    let query1 = """query Test { field(arg: "test\"quote") }"""
+    let query2 = """query Test { field(arg: "test\nline") }"""
+    let query3 = """query Test { field(arg: "test\ttab") }"""
+    let hash1 = DocumentId.fromCanonicalQuery query1
+    let hash2 = DocumentId.fromCanonicalQuery query2
+    let hash3 = DocumentId.fromCanonicalQuery query3
+    // All should produce valid hashes
+    equals 64 hash1.Length
+    equals 64 hash2.Length
+    equals 64 hash3.Length
+    // All should be different
+    notEquals hash1 hash2
+    notEquals hash2 hash3
+    notEquals hash1 hash3
+
+[<Fact>]
+let ``DocumentId.fromCanonicalQuery is consistent with known SHA-256 values`` () =
+    // Test a simple known case
+    let query = "test"
+    let hash = DocumentId.fromCanonicalQuery query
+    // SHA-256 of "test"
+    equals "9f86d081884c7d659a2feaa0c55ad015a3bf4f1b2b0b822cd15d6c15b0f00a08" hash
+

tests/FSharp.Data.GraphQL.Tests/ExecutionTests.fs

@@ -399,6 +399,54 @@ let ``Execution when querying returns unique document id with response`` () =
         equals errors1 errors2
     | response -> fail $"Expected a 'Direct' GQLResponse but got\n{response}"
 
+[<Fact>]
+let ``Execution documentId handles escaped string values correctly`` () =
+    let schema =
+      Schema(Define.Object<TwiceTest>(
+                "Type", [
+                    Define.Field("a", StringType, fun _ x -> x.A)
+                    Define.Field("b", IntType, fun _ x -> x.B)
+                ]))
+    // Query with string containing special characters that need escaping
+    let query = """query Example { a(arg: "test\"quote\nline\ttab\\backslash") }"""
+    let result = sync <| Executor(schema).AsyncExecute(query, getMockInputContext, { A = "test"; B = 1 })
+    // DocumentId should be deterministic and not empty
+    result.DocumentId |> notEquals Unchecked.defaultof<string>
+    result.DocumentId.Length |> equals 64  // SHA-256 hex string is always 64 chars
+
+[<Fact>]
+let ``Execution documentId is different for different queries`` () =
+    let schema =
+      Schema(Define.Object<TwiceTest>(
+                "Type", [
+                    Define.Field("a", StringType, fun _ x -> x.A)
+                    Define.Field("b", IntType, fun _ x -> x.B)
+                ]))
+    let query1 = "query Example1 { a }"
+    let query2 = "query Example2 { b }"
+    let result1 = sync <| Executor(schema).AsyncExecute(query1, getMockInputContext, { A = "aa"; B = 2 })
+    let result2 = sync <| Executor(schema).AsyncExecute(query2, getMockInputContext, { A = "aa"; B = 2 })
+    result1.DocumentId |> notEquals result2.DocumentId
+
+[<Fact>]
+let ``Execution documentId is same for semantically identical queries`` () =
+    let schema =
+      Schema(Define.Object<TwiceTest>(
+                "Type", [
+                    Define.Field("a", StringType, fun _ x -> x.A)
+                    Define.Field("b", IntType, fun _ x -> x.B)
+                ]))
+    // Same query with different whitespace/formatting
+    let query1 = "query Example { a b }"
+    let query2 = "query Example{a b}"
+    let query3 = "query Example { a, b }"
+    let result1 = sync <| Executor(schema).AsyncExecute(query1, getMockInputContext, { A = "aa"; B = 2 })
+    let result2 = sync <| Executor(schema).AsyncExecute(query2, getMockInputContext, { A = "aa"; B = 2 })
+    let result3 = sync <| Executor(schema).AsyncExecute(query3, getMockInputContext, { A = "aa"; B = 2 })
+    // All should produce the same documentId since they parse to the same AST
+    result1.DocumentId |> equals result2.DocumentId
+    result1.DocumentId |> equals result3.DocumentId
+
 type InnerNullableTest = { Kaboom : string }
 type NullableTest = {
     Inner : InnerNullableTest

tests/FSharp.Data.GraphQL.Tests/FSharp.Data.GraphQL.Tests.fsproj

@@ -30,6 +30,8 @@
     <Compile Include="Helpers.fs" />
     <Compile Include="ErrorHelpers.fs" />
     <Compile Include="Literals.fs" />
+    <Compile Include="DocumentIdTests.fs" />
+    <Compile Include="ValidationCacheTests.fs" />
     <Compile Include="Relay\NodeTests.fs" />
     <Compile Include="Relay\CursorTests.fs" />
     <Compile Include="Relay\ConnectionTests.fs" />

tests/FSharp.Data.GraphQL.Tests/ValidationCacheTests.fs

@@ -0,0 +1,142 @@
+// The MIT License (MIT)
+// Copyright (c) 2016 Bazinga Technologies Inc
+
+module FSharp.Data.GraphQL.Tests.ValidationCacheTests
+
+open Xunit
+open FSharp.Data.GraphQL
+open FSharp.Data.GraphQL.Validation
+open System.Threading
+
+[<Fact>]
+let ``MemoryValidationResultCache caches results for same key`` () =
+    let cache = MemoryValidationResultCache() :> IValidationResultCache
+    let mutable callCount = 0
+    let producer () =
+        Interlocked.Increment(&callCount) |> ignore
+        Success
+    
+    let key = { DocumentId = "doc1"; SchemaId = "schema1" }
+    
+    // First call should invoke producer
+    let result1 = cache.GetOrAdd producer key
+    equals 1 callCount
+    equals Success result1
+    
+    // Second call with same key should NOT invoke producer (cached)
+    let result2 = cache.GetOrAdd producer key
+    equals 1 callCount  // Still 1, not 2
+    equals Success result2
+
+[<Fact>]
+let ``MemoryValidationResultCache uses different cache entries for different DocumentIds`` () =
+    let cache = MemoryValidationResultCache() :> IValidationResultCache
+    let mutable callCount = 0
+    let producer () =
+        Interlocked.Increment(&callCount) |> ignore
+        Success
+    
+    let key1 = { DocumentId = "doc1"; SchemaId = "schema1" }
+    let key2 = { DocumentId = "doc2"; SchemaId = "schema1" }
+    
+    // First call
+    let result1 = cache.GetOrAdd producer key1
+    equals 1 callCount
+    
+    // Second call with different DocumentId should invoke producer again
+    let result2 = cache.GetOrAdd producer key2
+    equals 2 callCount  // Should be 2 now
+
+[<Fact>]
+let ``MemoryValidationResultCache uses different cache entries for different SchemaIds`` () =
+    let cache = MemoryValidationResultCache() :> IValidationResultCache
+    let mutable callCount = 0
+    let producer () =
+        Interlocked.Increment(&callCount) |> ignore
+        Success
+    
+    let key1 = { DocumentId = "doc1"; SchemaId = "schema1" }
+    let key2 = { DocumentId = "doc1"; SchemaId = "schema2" }
+    
+    // First call
+    let result1 = cache.GetOrAdd producer key1
+    equals 1 callCount
+    
+    // Second call with different SchemaId should invoke producer again
+    let result2 = cache.GetOrAdd producer key2
+    equals 2 callCount  // Should be 2 now
+
+[<Fact>]
+let ``MemoryValidationResultCache distinguishes keys with same hash code`` () =
+    let cache = MemoryValidationResultCache() :> IValidationResultCache
+    
+    // Create two different keys that might have hash collisions
+    // Using very similar but different strings
+    let key1 = { DocumentId = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"; SchemaId = "schema1" }
+    let key2 = { DocumentId = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaab"; SchemaId = "schema1" }
+    
+    let mutable callCount = 0
+    let producer () =
+        Interlocked.Increment(&callCount) |> ignore
+        Success
+    
+    // First call
+    let result1 = cache.GetOrAdd producer key1
+    equals 1 callCount
+    
+    // Second call with different key should invoke producer even if hash codes collide
+    let result2 = cache.GetOrAdd producer key2
+    equals 2 callCount  // Should be 2, proving we use full key not just hash
+
+[<Fact>]
+let ``MemoryValidationResultCache caches error results`` () =
+    let cache = MemoryValidationResultCache() :> IValidationResultCache
+    let mutable callCount = 0
+    let error = GQLProblemDetails.Create("Test error")
+    let producer () =
+        Interlocked.Increment(&callCount) |> ignore
+        ValidationError [error]
+    
+    let key = { DocumentId = "doc1"; SchemaId = "schema1" }
+    
+    // First call should invoke producer
+    let result1 = cache.GetOrAdd producer key
+    equals 1 callCount
+    match result1 with
+    | ValidationError errors -> equals 1 (Seq.length errors)
+    | Success -> fail "Expected ValidationError"
+    
+    // Second call with same key should NOT invoke producer (cached)
+    let result2 = cache.GetOrAdd producer key
+    equals 1 callCount  // Still 1, not 2
+    match result2 with
+    | ValidationError errors -> equals 1 (Seq.length errors)
+    | Success -> fail "Expected ValidationError"
+
+[<Fact>]
+let ``MemoryValidationResultCache handles concurrent access`` () =
+    let cache = MemoryValidationResultCache() :> IValidationResultCache
+    let mutable callCount = 0
+    let producer () =
+        Interlocked.Increment(&callCount) |> ignore
+        Thread.Sleep(10)  // Simulate some work
+        Success
+    
+    let key = { DocumentId = "doc1"; SchemaId = "schema1" }
+    
+    // Call cache from multiple threads simultaneously
+    let tasks = 
+        [1..10]
+        |> List.map (fun _ -> 
+            async {
+                return cache.GetOrAdd producer key
+            })
+    
+    let results = tasks |> Async.Parallel |> Async.RunSynchronously
+    
+    // All results should be Success
+    results |> Array.iter (fun r -> equals Success r)
+    
+    // Producer should be called at least once, but possibly more due to race conditions
+    // The important thing is it's not called 10 times
+    Assert.True(callCount >= 1 && callCount < 10, $"Expected callCount between 1 and 9, got {callCount}")