test: add v3 DefinitionCompiler type-mapping unit tests; remove unused FAKE imports

Add 20 unit tests for the v3 DefinitionCompiler type mapping in a new
tests/SwaggerProvider.Tests/v3/Schema.TypeMappingTests.fs.

Each test compiles a minimal inline OpenAPI 3.0 schema through the
DefinitionCompiler pipeline and asserts the resulting .NET property type:

- Primitives: bool, int32, int64, float32, double
- String formats: string, DateTimeOffset (date-time), DateTimeOffset (date),
  Guid (uuid), byte[*] (byte), IO.Stream (binary)
- Optional value-type wrapping: Option<bool>, Option<int32>, Option<int64>,
  Option<float32>, Option<double>, Option<DateTimeOffset>, Option<Guid>
- Optional reference-type passthrough: string and byte[*] remain unwrapped

Previously there were no unit tests covering the type-mapping logic inside
v3/DefinitionCompiler.fs; these tests make the mapping observable and will
catch regressions when the mapping changes (e.g. the DateOnly PR #321).

Also remove three unused FAKE package imports from build.fsx:
- Fake.DotNet.MSBuild  (no MSBuild-specific targets used)
- Fake.DotNet.FSFormatting  (fantomas is invoked via DotNet.exec, not FSFormatting.xxx)
- Fake.Api.GitHub  (GitHub release code is fully commented out in the Release target)

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: github-actions[bot]

build.fsx

@@ -3,12 +3,9 @@
 #r "nuget: Fake.Core.ReleaseNotes"
 #r "nuget: Fake.IO.FileSystem"
 #r "nuget: Fake.DotNet.Cli"
-#r "nuget: Fake.DotNet.MSBuild"
 #r "nuget: Fake.DotNet.AssemblyInfoFile"
 #r "nuget: Fake.DotNet.Paket"
-#r "nuget: Fake.DotNet.FSFormatting"
 #r "nuget: Fake.Tools.Git"
-#r "nuget: Fake.Api.GitHub"
 
 // Boilerplate - https://github.com/fsprojects/FAKE/issues/2719#issuecomment-1470687052
 System.Environment.GetCommandLineArgs()

tests/SwaggerProvider.Tests/SwaggerProvider.Tests.fsproj

@@ -16,6 +16,7 @@
     <Compile Include="v2\Schema.Spec.Yaml.Tests.fs" />
     <Compile Include="APIs.guru.fs" />
     <Compile Include="Schema.Parser.Tests.fs" />
+    <Compile Include="v3\Schema.TypeMappingTests.fs" />
     <Compile Include="PathResolutionTests.fs" />
     <Compile Include="SsrfSecurityTests.fs" />
     <Compile Include="RuntimeHelpersTests.fs" />

tests/SwaggerProvider.Tests/v3/Schema.TypeMappingTests.fs

@@ -0,0 +1,196 @@
+module SwaggerProvider.Tests.V3TypeMappingTests
+
+open System
+open System.IO
+open Microsoft.OpenApi.Reader
+open SwaggerProvider.Internal.v3.Compilers
+open Xunit
+open FsUnitTyped
+
+/// Compile a minimal OpenAPI v3 schema containing one "TestType" object with a single
+/// "Value" property defined by `propYaml`, and return that property's compiled .NET type.
+let private compilePropertyType (propYaml: string) (required: bool) : Type =
+    let requiredBlock =
+        if required then
+            "      required:\n        - Value\n"
+        else
+            ""
+
+    let schemaStr =
+        sprintf
+            """openapi: "3.0.0"
+info:
+  title: TypeMappingTest
+  version: "1.0.0"
+paths: {}
+components:
+  schemas:
+    TestType:
+      type: object
+%s      properties:
+        Value:
+%s"""
+            requiredBlock
+            propYaml
+
+    let settings = OpenApiReaderSettings()
+    settings.AddYamlReader()
+
+    let readResult =
+        Microsoft.OpenApi.OpenApiDocument.Parse(schemaStr, settings = settings)
+
+    let schema = readResult.Document
+
+    let defCompiler = DefinitionCompiler(schema, false)
+    let opCompiler = OperationCompiler(schema, defCompiler, true, false, true)
+    opCompiler.CompileProvidedClients(defCompiler.Namespace)
+
+    let types = defCompiler.Namespace.GetProvidedTypes()
+    let testType = types |> List.find(fun t -> t.Name = "TestType")
+
+    match testType.GetDeclaredProperty("Value") with
+    | null -> failwith "Property 'Value' not found on TestType"
+    | prop -> prop.PropertyType
+
+// ── Required primitive types ─────────────────────────────────────────────────
+
+[<Fact>]
+let ``required boolean maps to bool``() =
+    let ty = compilePropertyType "          type: boolean\n" true
+
+    ty |> shouldEqual typeof<bool>
+
+[<Fact>]
+let ``required integer (no format) maps to int32``() =
+    let ty = compilePropertyType "          type: integer\n" true
+
+    ty |> shouldEqual typeof<int32>
+
+[<Fact>]
+let ``required integer int64 format maps to int64``() =
+    let ty =
+        compilePropertyType "          type: integer\n          format: int64\n" true
+
+    ty |> shouldEqual typeof<int64>
+
+[<Fact>]
+let ``required number (no format) maps to float32``() =
+    let ty = compilePropertyType "          type: number\n" true
+
+    ty |> shouldEqual typeof<float32>
+
+[<Fact>]
+let ``required number double format maps to double``() =
+    let ty =
+        compilePropertyType "          type: number\n          format: double\n" true
+
+    ty |> shouldEqual typeof<double>
+
+// ── Required string formats ───────────────────────────────────────────────────
+
+[<Fact>]
+let ``required string (no format) maps to string``() =
+    let ty = compilePropertyType "          type: string\n" true
+
+    ty |> shouldEqual typeof<string>
+
+[<Fact>]
+let ``required string date-time format maps to DateTimeOffset``() =
+    let ty =
+        compilePropertyType "          type: string\n          format: date-time\n" true
+
+    ty |> shouldEqual typeof<DateTimeOffset>
+
+[<Fact>]
+let ``required string date format maps to DateTimeOffset``() =
+    let ty = compilePropertyType "          type: string\n          format: date\n" true
+
+    ty |> shouldEqual typeof<DateTimeOffset>
+
+[<Fact>]
+let ``required string uuid format maps to Guid``() =
+    let ty = compilePropertyType "          type: string\n          format: uuid\n" true
+
+    ty |> shouldEqual typeof<Guid>
+
+[<Fact>]
+let ``required string byte format maps to byte array``() =
+    let ty = compilePropertyType "          type: string\n          format: byte\n" true
+
+    // DefinitionCompiler creates a rank-1 explicit array via MakeArrayType(1)
+    ty |> shouldEqual(typeof<byte>.MakeArrayType(1))
+
+[<Fact>]
+let ``required string binary format maps to Stream``() =
+    let ty =
+        compilePropertyType "          type: string\n          format: binary\n" true
+
+    ty |> shouldEqual typeof<IO.Stream>
+
+// ── Optional (non-required) value types are wrapped in Option<T> ─────────────
+
+[<Fact>]
+let ``optional boolean maps to Option<bool>``() =
+    let ty = compilePropertyType "          type: boolean\n" false
+
+    ty |> shouldEqual(typedefof<Option<_>>.MakeGenericType(typeof<bool>))
+
+[<Fact>]
+let ``optional integer maps to Option<int32>``() =
+    let ty = compilePropertyType "          type: integer\n" false
+
+    ty |> shouldEqual(typedefof<Option<_>>.MakeGenericType(typeof<int32>))
+
+[<Fact>]
+let ``optional integer int64 maps to Option<int64>``() =
+    let ty =
+        compilePropertyType "          type: integer\n          format: int64\n" false
+
+    ty |> shouldEqual(typedefof<Option<_>>.MakeGenericType(typeof<int64>))
+
+[<Fact>]
+let ``optional number maps to Option<float32>``() =
+    let ty = compilePropertyType "          type: number\n" false
+
+    ty
+    |> shouldEqual(typedefof<Option<_>>.MakeGenericType(typeof<float32>))
+
+[<Fact>]
+let ``optional number double maps to Option<double>``() =
+    let ty =
+        compilePropertyType "          type: number\n          format: double\n" false
+
+    ty
+    |> shouldEqual(typedefof<Option<_>>.MakeGenericType(typeof<double>))
+
+[<Fact>]
+let ``optional DateTimeOffset maps to Option<DateTimeOffset>``() =
+    let ty =
+        compilePropertyType "          type: string\n          format: date-time\n" false
+
+    ty
+    |> shouldEqual(typedefof<Option<_>>.MakeGenericType(typeof<DateTimeOffset>))
+
+[<Fact>]
+let ``optional Guid maps to Option<Guid>``() =
+    let ty =
+        compilePropertyType "          type: string\n          format: uuid\n" false
+
+    ty |> shouldEqual(typedefof<Option<_>>.MakeGenericType(typeof<Guid>))
+
+// ── Optional reference types are NOT wrapped (they are already nullable) ─────
+
+[<Fact>]
+let ``optional string is not wrapped in Option``() =
+    let ty = compilePropertyType "          type: string\n" false
+
+    // string is a reference type — not wrapped in Option<T> even when non-required
+    ty |> shouldEqual typeof<string>
+
+[<Fact>]
+let ``optional byte array is not wrapped in Option``() =
+    let ty =
+        compilePropertyType "          type: string\n          format: byte\n" false
+
+    // byte[*] is a reference type — not wrapped in Option<T>
+    ty |> shouldEqual(typeof<byte>.MakeArrayType(1))