fix(#203): enum-like union must ignore PropertyNamePolicy when read as value

Author: Tarmil

src/FSharp.SystemTextJson/Union.fs

@@ -177,8 +177,8 @@ module private Case =
             else
                 i <- i + 1
 
-    let casesByName (fsOptions: JsonFSharpOptionsRecord) (cases: Case[]) =
-        if fsOptions.UnionTagCaseInsensitive then
+    let casesByName caseInsensitive (cases: Case[]) =
+        if caseInsensitive then
             let dict = Dictionary(JsonNameComparer(StringComparer.OrdinalIgnoreCase))
             for c in cases do
                 for name in c.Names do
@@ -221,7 +221,8 @@ module private Case =
             match reader.TryGetInt32() with
             | true, intName -> JsonName.Int intName
             | false, _ -> failExpecting "union tag" &reader ty
-        | JsonTokenType.String -> JsonName.String(reader.GetString())
+        | JsonTokenType.String
+        | JsonTokenType.PropertyName -> JsonName.String(reader.GetString())
         | _ -> failExpecting "union tag" &reader ty
 
     let isNamedFromReaderString (case: Case) (reader: byref<Utf8JsonReader>) (found: byref<ValueOption<_>>) =
@@ -367,7 +368,7 @@ type JsonUnionConverter<'T>
         else
             ValueNone
 
-    let casesByName = Case.casesByName fsOptions cases
+    let casesByName = Case.casesByName fsOptions.UnionTagCaseInsensitive cases
 
     let getCaseByPropertyName (reader: byref<Utf8JsonReader>) =
         match Case.tryGetCaseByPropertyName casesByName cases &reader with
@@ -758,15 +759,23 @@ type JsonEnumLikeUnionConverter<'T> internal (options: JsonSerializerOptions, fs
 
     let tagReader = FSharpValue.PreComputeUnionTagReader(typeof<'T>, true)
 
-    let cases =
+    let casesAsProperty =
         let namingPolicy =
             match fsOptions.UnionTagNamingPolicy with
             | null -> options.PropertyNamingPolicy
             | p -> p
         FSharpType.GetUnionCases(typeof<'T>, true)
         |> Array.map (Case.get namingPolicy fsOptions options)
 
-    let casesByName = Case.casesByName fsOptions cases
+    let casesAsValue =
+        FSharpType.GetUnionCases(typeof<'T>, true)
+        |> Array.map (Case.get fsOptions.UnionTagNamingPolicy fsOptions options)
+
+    let casesByNameAsProperty =
+        Case.casesByName (fsOptions.UnionTagCaseInsensitive || options.PropertyNameCaseInsensitive) casesAsProperty
+
+    let casesByNameAsValue =
+        Case.casesByName fsOptions.UnionTagCaseInsensitive casesAsValue
 
     let nullValue =
         tryGetNullValue fsOptions typeof<'T> |> ValueOption.map (fun x -> x :?> 'T)
@@ -783,20 +792,33 @@ type JsonEnumLikeUnionConverter<'T> internal (options: JsonSerializerOptions, fs
         | JsonTokenType.Number
         | JsonTokenType.True
         | JsonTokenType.False ->
-            let case = Case.getCaseByTagReader casesByName cases typeof<'T> &reader
+            let case =
+                Case.getCaseByTagReader casesByNameAsValue casesAsValue typeof<'T> &reader
             case.Ctor [||] :?> 'T
         | _ -> failExpecting "string" &reader typeToConvert
 
-    override this.ReadAsPropertyName(reader, typeToConvert, options) =
-        this.Read(&reader, typeToConvert, options)
+    override this.ReadAsPropertyName(reader, typeToConvert, _options) =
+        match reader.TokenType with
+        | JsonTokenType.Null ->
+            nullValue
+            |> ValueOption.defaultWith (fun () -> failf "Union %s can't be deserialized from null" typeof<'T>.FullName)
+        | JsonTokenType.PropertyName
+        | JsonTokenType.String
+        | JsonTokenType.Number
+        | JsonTokenType.True
+        | JsonTokenType.False ->
+            let case =
+                Case.getCaseByTagReader casesByNameAsProperty casesAsProperty typeof<'T> &reader
+            case.Ctor [||] :?> 'T
+        | _ -> failExpecting "string" &reader typeToConvert
 
     override this.Write(writer, value, _options) =
         let tag = tagReader value
-        Case.writeCaseNameAsValue writer cases[tag]
+        Case.writeCaseNameAsValue writer casesAsValue[tag]
 
     override this.WriteAsPropertyName(writer, value, _options) =
         let tag = tagReader value
-        writer.WritePropertyName(cases[tag].NamesAsString[0])
+        writer.WritePropertyName(casesAsProperty[tag].NamesAsString[0])
 
 type JsonUnionConverter(fsOptions: JsonFSharpOptions) =
     inherit JsonConverterFactory()

tests/FSharp.SystemTextJson.Tests/Test.Regression.fs

@@ -127,6 +127,82 @@ let ``regression #172`` () =
     Assert.Equal("{\"X\":null}", JsonSerializer.Serialize(x, options))
     Assert.Equal("{\"Y\":null}", JsonSerializer.Serialize(y, options))
 
+module ``Regression #203`` =
+    type Enum =
+        | CaseOne
+        | CaseTwo
+
+    let optionsWithPropertyPolicy =
+        JsonFSharpOptions()
+            .WithUnionUnwrapFieldlessTags()
+            .WithMapFormat(MapFormat.Object)
+            .ToJsonSerializerOptions(
+                PropertyNameCaseInsensitive = true,
+                PropertyNamingPolicy = JsonNamingPolicy.KebabCaseLower
+            )
+
+    let optionsWithTagPolicy =
+        JsonFSharpOptions()
+            .WithUnionUnwrapFieldlessTags()
+            .WithMapFormat(MapFormat.Object)
+            .WithUnionTagNamingPolicy(JsonNamingPolicy.KebabCaseLower)
+            .ToJsonSerializerOptions(PropertyNameCaseInsensitive = true)
+
+    let optionsWithBothPolicies =
+        JsonFSharpOptions()
+            .WithUnionUnwrapFieldlessTags()
+            .WithMapFormat(MapFormat.Object)
+            .WithUnionTagNamingPolicy(JsonNamingPolicy.SnakeCaseLower)
+            .ToJsonSerializerOptions(
+                PropertyNameCaseInsensitive = true,
+                PropertyNamingPolicy = JsonNamingPolicy.KebabCaseLower
+            )
+
+    module ``as value`` =
+
+        [<Fact>]
+        let ``serialize ignores property policy`` () =
+            let actual = JsonSerializer.Serialize(CaseOne, optionsWithPropertyPolicy)
+            Assert.Equal("\"CaseOne\"", actual)
+
+        [<Fact>]
+        let ``deserialize ignores property policy`` () =
+            let actual = JsonSerializer.Deserialize("\"CaseOne\"", optionsWithPropertyPolicy)
+            Assert.Equal(CaseOne, actual)
+
+        [<Fact>]
+        let ``serialize uses tag policy`` () =
+            let actual = JsonSerializer.Serialize(CaseOne, optionsWithTagPolicy)
+            Assert.Equal("\"case-one\"", actual)
+
+        [<Fact>]
+        let ``deserialize uses tag policy`` () =
+            let actual = JsonSerializer.Deserialize("\"case-one\"", optionsWithTagPolicy)
+            Assert.Equal(CaseOne, actual)
+
+    module ``as property`` =
+
+        [<Fact>]
+        let ``serialize uses property policy`` () =
+            let actual = JsonSerializer.Serialize(Map [ CaseOne, 1 ], optionsWithPropertyPolicy)
+            Assert.Equal("{\"case-one\":1}", actual)
+
+        [<Fact>]
+        let ``deserialize uses property policy`` () =
+            let actual =
+                JsonSerializer.Deserialize("{\"CAsE-one\":1}", optionsWithPropertyPolicy)
+            Assert.Equal<Map<Enum, int>>(Map [ CaseOne, 1 ], actual)
+
+        [<Fact>]
+        let ``serialize uses tag policy in priority`` () =
+            let actual = JsonSerializer.Serialize(Map [ CaseOne, 1 ], optionsWithBothPolicies)
+            Assert.Equal("{\"case_one\":1}", actual)
+
+        [<Fact>]
+        let ``deserialize uses tag policy in priority`` () =
+            let actual = JsonSerializer.Deserialize("{\"caSe_One\":1}", optionsWithBothPolicies)
+            Assert.Equal<Map<Enum, int>>(Map [ CaseOne, 1 ], actual)
+
 module ``Regression #204`` =
     type Enum =
         | Case1