Add type wrapper kind safety tests using F# scripts

Introduce a new test suite to verify compile-time enforcement of input/output directionality for ListOf, Nullable, and StructNullable wrappers. Replace previous inline tests with F# script-based checks that are executed via dotnet fsi. Update the test project to include these scripts as content files and ensure References.fsx is managed and ignored appropriately.

Author: xperiandri

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

@@ -38,10 +38,18 @@
     <Compile Include="Helpers and Extensions\ObservableExtensionsTests.fs" />
     <Compile Include="PropertyTrackingTests.fs" />
     <Compile Include="AbstractionTests.fs" />
+    <Compile Include="TypeWrappersKindSafetyTests.fs" />
     <Compile Include="UnionInterfaceTests.fs" />
     <Compile Include="DirectivesTests.fs" />
     <Compile Include="TypeValidationTests.fs" />
-    <Compile Include="TypeWrappersKindSafetyTests.fs" />
+    <None Include="TypeWrappersKindSafety\References.fsx" Condition="exists('TypeWrappersKindSafety\References.fsx')" CopyToOutputDirectory="PreserveNewest" />
+    <None Include="TypeWrappersKindSafety\ListOf.InputAsOutput.fsx" CopyToOutputDirectory="PreserveNewest" />
+    <None Include="TypeWrappersKindSafety\ListOf.OutputAsInput.fsx" CopyToOutputDirectory="PreserveNewest" />
+    <None Include="TypeWrappersKindSafety\Nullable.InputAsOutput.fsx" CopyToOutputDirectory="PreserveNewest" />
+    <None Include="TypeWrappersKindSafety\Nullable.OutputAsInput.fsx" CopyToOutputDirectory="PreserveNewest" />
+    <None Include="TypeWrappersKindSafety\StructNullable.InputAsOutput.fsx" CopyToOutputDirectory="PreserveNewest" />
+    <None Include="TypeWrappersKindSafety\StructNullable.OutputAsInput.fsx" CopyToOutputDirectory="PreserveNewest" />
+    <None Include="TypeWrappersKindSafety\Valid.fsx" CopyToOutputDirectory="PreserveNewest" />
     <Compile Include="AstValidationTests.fs" />
     <Compile Include="ParserTests.fs" />
     <Compile Include="SchemaTests.fs" />

tests/FSharp.Data.GraphQL.Tests/TypeWrappersKindSafety/.gitignore

@@ -0,0 +1 @@
+References.fsx

tests/FSharp.Data.GraphQL.Tests/TypeWrappersKindSafety/ListOf.InputAsOutput.fsx

@@ -0,0 +1,15 @@
+#load "References.fsx"
+
+open FSharp.Data.GraphQL.Types
+
+type InputOnly = { Value: int }
+type OutputOnly = { Value: int }
+
+let inputOnlyType =
+    Define.InputObject<InputOnly>(
+        name = "InputOnlyType",
+        fields = [ Define.Input("value", IntType) ]
+    )
+
+// This should fail: InputDef cannot be assigned to OutputDef
+let _ : OutputDef<InputOnly list> = ListOf inputOnlyType

tests/FSharp.Data.GraphQL.Tests/TypeWrappersKindSafety/ListOf.OutputAsInput.fsx

@@ -0,0 +1,15 @@
+#load "References.fsx"
+
+open FSharp.Data.GraphQL.Types
+
+type InputOnly = { Value: int }
+type OutputOnly = { Value: int }
+
+let outputOnlyType =
+    Define.Object<OutputOnly>(
+        name = "OutputOnlyType",
+        fields = [ Define.Field("value", IntType, fun _ x -> x.Value) ]
+    )
+
+// This should fail: OutputDef cannot be assigned to InputDef
+let _ : InputDef<OutputOnly list> = ListOf outputOnlyType

tests/FSharp.Data.GraphQL.Tests/TypeWrappersKindSafety/Nullable.InputAsOutput.fsx

@@ -0,0 +1,15 @@
+#load "References.fsx"
+
+open FSharp.Data.GraphQL.Types
+
+type InputOnly = { Value: int }
+type OutputOnly = { Value: int }
+
+let inputOnlyType =
+    Define.InputObject<InputOnly>(
+        name = "InputOnlyType",
+        fields = [ Define.Input("value", IntType) ]
+    )
+
+// This should fail: InputDef cannot be assigned to OutputDef
+let _ : OutputDef<InputOnly option> = Nullable inputOnlyType

tests/FSharp.Data.GraphQL.Tests/TypeWrappersKindSafety/Nullable.OutputAsInput.fsx

@@ -0,0 +1,15 @@
+#load "References.fsx"
+
+open FSharp.Data.GraphQL.Types
+
+type InputOnly = { Value: int }
+type OutputOnly = { Value: int }
+
+let outputOnlyType =
+    Define.Object<OutputOnly>(
+        name = "OutputOnlyType",
+        fields = [ Define.Field("value", IntType, fun _ x -> x.Value) ]
+    )
+
+// This should fail: OutputDef cannot be assigned to InputDef
+let _ : InputDef<OutputOnly option> = Nullable outputOnlyType

tests/FSharp.Data.GraphQL.Tests/TypeWrappersKindSafety/StructNullable.InputAsOutput.fsx

@@ -0,0 +1,15 @@
+#load "References.fsx"
+
+open FSharp.Data.GraphQL.Types
+
+type InputOnly = { Value: int }
+type OutputOnly = { Value: int }
+
+let inputOnlyType =
+    Define.InputObject<InputOnly>(
+        name = "InputOnlyType",
+        fields = [ Define.Input("value", IntType) ]
+    )
+
+// This should fail: InputDef cannot be assigned to OutputDef
+let _ : OutputDef<InputOnly voption> = StructNullable inputOnlyType

tests/FSharp.Data.GraphQL.Tests/TypeWrappersKindSafety/StructNullable.OutputAsInput.fsx

@@ -0,0 +1,15 @@
+#load "References.fsx"
+
+open FSharp.Data.GraphQL.Types
+
+type InputOnly = { Value: int }
+type OutputOnly = { Value: int }
+
+let outputOnlyType =
+    Define.Object<OutputOnly>(
+        name = "OutputOnlyType",
+        fields = [ Define.Field("value", IntType, fun _ x -> x.Value) ]
+    )
+
+// This should fail: OutputDef cannot be assigned to InputDef
+let _ : InputDef<OutputOnly voption> = StructNullable outputOnlyType

tests/FSharp.Data.GraphQL.Tests/TypeWrappersKindSafety/Valid.fsx

@@ -0,0 +1,26 @@
+#load "References.fsx"
+
+open FSharp.Data.GraphQL.Types
+
+type InputOnly = { Value: int }
+type OutputOnly = { Value: int }
+
+let inputOnlyType =
+    Define.InputObject<InputOnly>(
+        name = "InputOnlyType",
+        fields = [ Define.Input("value", IntType) ]
+    )
+
+let outputOnlyType =
+    Define.Object<OutputOnly>(
+        name = "OutputOnlyType",
+        fields = [ Define.Field("value", IntType, fun _ x -> x.Value) ]
+    )
+
+// These are all valid assignments and must compile successfully
+let _inputList    : InputDef<InputOnly list>    = ListOf inputOnlyType
+let _outputList   : OutputDef<OutputOnly list>  = ListOf outputOnlyType
+let _inputNullable  : InputDef<InputOnly option>  = Nullable inputOnlyType
+let _outputNullable : OutputDef<OutputOnly option> = Nullable outputOnlyType
+let _inputStruct  : InputDef<InputOnly voption>  = StructNullable inputOnlyType
+let _outputStruct : OutputDef<OutputOnly voption> = StructNullable outputOnlyType

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

@@ -1,40 +1,144 @@
 module FSharp.Data.GraphQL.Tests.TypeWrappersKindSafetyTests
 
+open System
+open System.Diagnostics
+open System.Threading.Tasks
 open FSharp.Data.GraphQL.Types
 open Xunit
 
 type private InputOnly = { Value : int }
 type private OutputOnly = { Value : int }
 
 let private InputOnlyType =
-    Define.InputObject<InputOnly>(
-        name = "InputOnlyType",
-        fields = [ Define.Input("value", IntType) ]
-    )
+    Define.InputObject<InputOnly> (name = "InputOnlyType", fields = [ Define.Input ("value", IntType) ])
 
 let private OutputOnlyType =
-    Define.Object<OutputOnly>(
-        name = "OutputOnlyType",
-        fields = [ Define.Field("value", IntType, fun _ x -> x.Value) ]
-    )
-
-[<Fact>]
-let ``ListOf keeps input-output direction`` () =
-    let inputList : InputDef<InputOnly list> = ListOf InputOnlyType
-    let outputList : OutputDef<OutputOnly list> = ListOf OutputOnlyType
-    Assert.Equal ("[InputOnlyType!]!", inputList.ToString ())
-    Assert.Equal ("[OutputOnlyType!]!", outputList.ToString ())
-
-[<Fact>]
-let ``Nullable keeps input-output direction`` () =
-    let nullableInput : InputDef<InputOnly option> = Nullable InputOnlyType
-    let nullableOutput : OutputDef<OutputOnly option> = Nullable OutputOnlyType
-    Assert.Equal ("InputOnlyType", nullableInput.ToString ())
-    Assert.Equal ("OutputOnlyType", nullableOutput.ToString ())
-
-[<Fact>]
-let ``StructNullable keeps input-output direction`` () =
-    let nullableInput : InputDef<InputOnly voption> = StructNullable InputOnlyType
-    let nullableOutput : OutputDef<OutputOnly voption> = StructNullable OutputOnlyType
-    Assert.Equal ("InputOnlyType", nullableInput.ToString ())
-    Assert.Equal ("OutputOnlyType", nullableOutput.ToString ())
+    Define.Object<OutputOnly> (name = "OutputOnlyType", fields = [ Define.Field ("value", IntType, fun _ x -> x.Value) ])
+
+type TypeWrappersKindSafetyFixture () =
+
+    let scriptsDir = IO.Path.Combine (AppContext.BaseDirectory, "TypeWrappersKindSafety")
+    let referencesPath = IO.Path.Combine (scriptsDir, "References.fsx")
+    let sourceProjectDir =
+        IO.Path.GetFullPath (IO.Path.Combine (AppContext.BaseDirectory, "..", "..", ".."))
+    let sourceScriptsDir = IO.Path.Combine (sourceProjectDir, "TypeWrappersKindSafety")
+    let sourceReferencesPath = IO.Path.Combine (sourceScriptsDir, "References.fsx")
+
+    let ensureFileContentAsync (path : string) (content : string) : Task = task {
+        if IO.File.Exists (path) then
+            let! existing = IO.File.ReadAllTextAsync (path)
+
+            if not (String.Equals (existing, content, StringComparison.Ordinal)) then
+                do! IO.File.WriteAllTextAsync (path, content)
+        else
+            do! IO.File.WriteAllTextAsync (path, content)
+    }
+
+    member _.ScriptPath (name : string) = IO.Path.Combine (scriptsDir, name)
+
+    member _.RunFsiCheckAsync (scriptPath : string) : Task<int> = task {
+        let psi =
+            ProcessStartInfo (
+                "dotnet",
+                sprintf "fsi --noninteractive \"%s\"" scriptPath,
+                UseShellExecute = false,
+                RedirectStandardOutput = true,
+                RedirectStandardError = true,
+                WorkingDirectory = AppContext.BaseDirectory
+            )
+
+        use proc = Process.Start (psi)
+        do! proc.WaitForExitAsync ()
+        return proc.ExitCode
+    }
+
+    member private _.ReferencesContent =
+        let sharedAssembly = IO.Path.Combine (AppContext.BaseDirectory, "FSharp.Data.GraphQL.Shared.dll")
+        let serverAssembly = IO.Path.Combine (AppContext.BaseDirectory, "FSharp.Data.GraphQL.Server.dll")
+
+        [ sprintf "#r @\"%s\"" sharedAssembly; sprintf "#r @\"%s\"" serverAssembly ]
+        |> String.concat "\n"
+
+    interface IAsyncLifetime with
+
+        member this.InitializeAsync () : Task =
+            task {
+                IO.Directory.CreateDirectory (scriptsDir) |> ignore
+                IO.Directory.CreateDirectory (sourceScriptsDir) |> ignore
+
+                let content = this.ReferencesContent
+
+                do! ensureFileContentAsync referencesPath content
+                do! ensureFileContentAsync sourceReferencesPath content
+            }
+
+        member _.DisposeAsync () = Task.CompletedTask
+
+type TypeWrappersKindSafetyTests (fixture : TypeWrappersKindSafetyFixture) =
+    interface IClassFixture<TypeWrappersKindSafetyFixture>
+
+    [<Fact>]
+    member _.``ListOf keeps input-output direction`` () : Task = task {
+            let inputList : InputDef<InputOnly list> = ListOf InputOnlyType
+            let outputList : OutputDef<OutputOnly list> = ListOf OutputOnlyType
+            Assert.Equal ("[InputOnlyType!]!", inputList.ToString ())
+            Assert.Equal ("[OutputOnlyType!]!", outputList.ToString ())
+        }
+
+    [<Fact>]
+    member _.``Nullable keeps input-output direction`` () : Task = task {
+            let nullableInput : InputDef<InputOnly option> = Nullable InputOnlyType
+            let nullableOutput : OutputDef<OutputOnly option> = Nullable OutputOnlyType
+            Assert.Equal ("InputOnlyType", nullableInput.ToString ())
+            Assert.Equal ("OutputOnlyType", nullableOutput.ToString ())
+        }
+
+    [<Fact>]
+    member _.``StructNullable keeps input-output direction`` () : Task = task {
+            let nullableInput : InputDef<InputOnly voption> = StructNullable InputOnlyType
+            let nullableOutput : OutputDef<OutputOnly voption> = StructNullable OutputOnlyType
+            Assert.Equal ("InputOnlyType", nullableInput.ToString ())
+            Assert.Equal ("OutputOnlyType", nullableOutput.ToString ())
+        }
+
+    [<Fact>]
+    member _.``Valid script compiles successfully`` () : Task = task {
+            let! exitCode = fixture.RunFsiCheckAsync (fixture.ScriptPath ("Valid.fsx"))
+            Assert.Equal (0, exitCode)
+        }
+
+    [<Fact>]
+    member _.``ListOf rejects output type as input at compile time`` () : Task = task {
+            let! exitCode = fixture.RunFsiCheckAsync (fixture.ScriptPath ("ListOf.OutputAsInput.fsx"))
+            Assert.NotEqual (0, exitCode)
+        }
+
+    [<Fact>]
+    member _.``ListOf rejects input type as output at compile time`` () : Task = task {
+            let! exitCode = fixture.RunFsiCheckAsync (fixture.ScriptPath ("ListOf.InputAsOutput.fsx"))
+            Assert.NotEqual (0, exitCode)
+        }
+
+    [<Fact>]
+    member _.``Nullable rejects output type as input at compile time`` () : Task = task {
+            let! exitCode = fixture.RunFsiCheckAsync (fixture.ScriptPath ("Nullable.OutputAsInput.fsx"))
+            Assert.NotEqual (0, exitCode)
+        }
+
+    [<Fact>]
+    member _.``Nullable rejects input type as output at compile time`` () : Task = task {
+            let! exitCode = fixture.RunFsiCheckAsync (fixture.ScriptPath ("Nullable.InputAsOutput.fsx"))
+            Assert.NotEqual (0, exitCode)
+        }
+
+    [<Fact>]
+    member _.``StructNullable rejects output type as input at compile time`` () : Task = task {
+            let! exitCode = fixture.RunFsiCheckAsync (fixture.ScriptPath ("StructNullable.OutputAsInput.fsx"))
+            Assert.NotEqual (0, exitCode)
+        }
+
+    [<Fact>]
+    member _.``StructNullable rejects input type as output at compile time`` () : Task = task {
+        let! exitCode = fixture.RunFsiCheckAsync (fixture.ScriptPath ("StructNullable.InputAsOutput.fsx"))
+        Assert.NotEqual (0, exitCode)
+    }