TPU tests for enum-mapping.

Author: rspeele

src/TypeProviderUsers/TypeProviderUser.SQLite/TestUserPrimitiveEnum.fs

@@ -0,0 +1,126 @@
+module TypeProviderUser.SQLite.TestUserPrimitiveEnum
+open NUnit.Framework
+open System
+open Rezoom.SQL
+open TypeProviderUser.UserTypes
+
+// End-to-end coverage for mapping CLR enums via the user-type pipeline.
+// Two flavors:
+//   * FavoriteColor — F# enum (System.Enum subtype) mapped to string via
+//     ToString / Enum.Parse. Underlying storage is human-readable.
+//   * DateTimeKind — BCL enum mapped to int via the cast operator.
+//     Underlying storage is the raw enum integer value.
+//
+// Each flavor gets the same three-test shape used for FileHash in
+// TestUserPrimitiveByteArray: roundtrip, parameter equality, and optional
+// parameter equality. Together that exercises the parameter-binding path,
+// the result-set materialization path, and the option-wrapping path.
+
+// --- FavoriteColor (ToString / Enum.Parse, string-underlying) ------------
+
+type InsertAndSelectColors = SQL<"""
+insert into ColorRows(Color) values(@c1);
+insert into ColorRows(Color) values(@c2);
+select Color from ColorRows order by Id;
+""">
+
+[<Test>]
+let ``select roundtrips FavoriteColor values via ToString/Enum.Parse mapping`` () =
+    let results =
+        InsertAndSelectColors.Command(FavoriteColor.Red, FavoriteColor.Blue)
+        |> runOnTestData
+    Assert.AreEqual(2, results.Count)
+    Assert.AreEqual(FavoriteColor.Red, results.[0].Color)
+    Assert.AreEqual(FavoriteColor.Blue, results.[1].Color)
+
+type FindColorByParameter = SQL<"""
+insert into ColorRows(Color) values(@seed1);
+insert into ColorRows(Color) values(@seed2);
+select Color from ColorRows where Color = @needle;
+""">
+
+[<Test>]
+let ``select with FavoriteColor parameter equality returns the matching row only`` () =
+    let target = FavoriteColor.Red
+    let other = FavoriteColor.Blue
+    // Rezoom orders Command args alphabetically by name: needle, seed1, seed2.
+    let results = FindColorByParameter.Command(target, other, target) |> runOnTestData
+    Assert.AreEqual(1, results.Count)
+    Assert.AreEqual(target, results.[0].Color)
+
+type FindColorByOptionalParameter = SQL<"""
+insert into ColorRows(Color) values(@seed1);
+insert into ColorRows(Color) values(@seed2);
+select Color from ColorRows where Color = @needle or @needle is null;
+""">
+
+[<Test>]
+let ``select with optional FavoriteColor parameter filters when Some and returns all when None`` () =
+    let target = FavoriteColor.Red
+    let other = FavoriteColor.Blue
+    // Command args alphabetical: needle, seed1, seed2.
+    let withSome =
+        FindColorByOptionalParameter.Command(Some target, target, other)
+        |> runOnTestData
+    Assert.AreEqual(1, withSome.Count)
+    Assert.AreEqual(target, withSome.[0].Color)
+    let withNone =
+        FindColorByOptionalParameter.Command(None, target, other)
+        |> runOnTestData
+    Assert.AreEqual(2, withNone.Count)
+
+// --- DateTimeKind (int unwrap, int-underlying) ---------------------------
+
+type InsertAndSelectKinds = SQL<"""
+insert into KindRows(Kind) values(@k1);
+insert into KindRows(Kind) values(@k2);
+insert into KindRows(Kind) values(@k3);
+select Kind from KindRows order by Id;
+""">
+
+[<Test>]
+let ``select roundtrips DateTimeKind values via raw int mapping`` () =
+    let results =
+        InsertAndSelectKinds.Command
+            (DateTimeKind.Utc, DateTimeKind.Local, DateTimeKind.Unspecified)
+        |> runOnTestData
+    Assert.AreEqual(3, results.Count)
+    Assert.AreEqual(DateTimeKind.Utc, results.[0].Kind)
+    Assert.AreEqual(DateTimeKind.Local, results.[1].Kind)
+    Assert.AreEqual(DateTimeKind.Unspecified, results.[2].Kind)
+
+type FindKindByParameter = SQL<"""
+insert into KindRows(Kind) values(@seed1);
+insert into KindRows(Kind) values(@seed2);
+select Kind from KindRows where Kind = @needle;
+""">
+
+[<Test>]
+let ``select with DateTimeKind parameter equality returns the matching row only`` () =
+    let target = DateTimeKind.Utc
+    let other = DateTimeKind.Local
+    // Command args alphabetical: needle, seed1, seed2.
+    let results = FindKindByParameter.Command(target, other, target) |> runOnTestData
+    Assert.AreEqual(1, results.Count)
+    Assert.AreEqual(target, results.[0].Kind)
+
+type FindKindByOptionalParameter = SQL<"""
+insert into KindRows(Kind) values(@seed1);
+insert into KindRows(Kind) values(@seed2);
+select Kind from KindRows where Kind = @needle or @needle is null;
+""">
+
+[<Test>]
+let ``select with optional DateTimeKind parameter filters when Some and returns all when None`` () =
+    let target = DateTimeKind.Utc
+    let other = DateTimeKind.Local
+    // Command args alphabetical: needle, seed1, seed2.
+    let withSome =
+        FindKindByOptionalParameter.Command(Some target, target, other)
+        |> runOnTestData
+    Assert.AreEqual(1, withSome.Count)
+    Assert.AreEqual(target, withSome.[0].Kind)
+    let withNone =
+        FindKindByOptionalParameter.Command(None, target, other)
+        |> runOnTestData
+    Assert.AreEqual(2, withNone.Count)

src/TypeProviderUsers/TypeProviderUser.SQLite/TypeProviderUser.SQLite.fsproj

@@ -17,6 +17,7 @@
     <Compile Include="TestRowTypeInterfaces.fs" />
     <Compile Include="TestUserTypeAnnotations.fs" />
     <Compile Include="TestUserPrimitiveByteArray.fs" />
+    <Compile Include="TestUserPrimitiveEnum.fs" />
     <Compile Include="TestPickles.fs" />
     <Compile Include="TestMigrateConnectionString.fs" />
     <Compile Include="Program.fs" />

src/TypeProviderUsers/TypeProviderUser.SQLite/V1.model.sql

@@ -38,3 +38,13 @@ create table HashedBlobs
 , Hash FileHash
 );
 
+create table ColorRows
+( Id int primary key autoincrement
+, Color FavoriteColor
+);
+
+create table KindRows
+( Id int primary key autoincrement
+, Kind DateTimeKind
+);
+

src/TypeProviderUsers/TypeProviderUser.UserTypes/Library.fs

@@ -11,6 +11,36 @@ module Extensions =
         static member FromPrimitive(s : string) =
             System.TimeOnly.ParseExact(s, "o")
 
+// --- Enum fixtures -------------------------------------------------------
+//
+// Two different ways of routing a CLR enum through the user-type pipeline:
+//   FavoriteColor   — user-defined F# enum, mapped to string via ToString /
+//                     Enum.Parse so storage is human-readable ("Red", "Blue").
+//   DateTimeKind    — BCL enum we cannot edit, mapped to its underlying int
+//                     value via the cast operator. Demonstrates that the same
+//                     external-static-class pattern that handles BCL classes
+//                     also handles BCL enums.
+//
+// F# enums compile to CLR enums (System.Enum subtypes), distinct from F#
+// single-case DUs which compile to class hierarchies. So findSingleCaseDU
+// will return None for these and the loader falls through to the explicit
+// ToPrimitive/FromPrimitive static-class path.
+
+type FavoriteColor =
+    | Red = 0
+    | Green = 1
+    | Blue = 2
+
+type FavoriteColorMapping() =
+    static member ToPrimitive(c : FavoriteColor) : string = c.ToString()
+    static member FromPrimitive(s : string) : FavoriteColor =
+        System.Enum.Parse<FavoriteColor>(s)
+
+type DateTimeKindMapping() =
+    static member ToPrimitive(k : System.DateTimeKind) : int = int k
+    static member FromPrimitive(i : int) : System.DateTimeKind =
+        enum<System.DateTimeKind> i
+
 // --- Fixtures for the Rezoom.SQL.Annotations attribute pipeline ----------
 
 /// Single-case DU with a type-level RawBackendSQLType attribute. The