Improve String Enum handling for additional use cases to ensure resulting Enums are properly formed (e.g. no unnecessary underscores being inserted in various cases). And some code naming improvements, and cleanup. Added greater Unit Test coverage for Enum parsing (serialization & deserialization).

cajuncoding · cajuncoding · commit 574fc66a4fe3 · 2025-10-30T00:54:11.000-05:00
diff --git a/FlurlGraphQL.Newtonsoft/FlurlGraphQLNewtonsoftJsonScreamingCaseNamingStrategy.cs b/FlurlGraphQL.Newtonsoft/FlurlGraphQLNewtonsoftJsonScreamingCaseNamingStrategy.cs
@@ -3,5 +3,5 @@
 
 public class FlurlGraphQLNewtonsoftJsonScreamingCaseNamingStrategy : NamingStrategy
 {
-    protected override string ResolvePropertyName(string name) => name.ToScreamingCase();
+    protected override string ResolvePropertyName(string name) => name.ToScreamingSnakeCase();
 }
diff --git a/FlurlGraphQL.Tests/FlurlGraphQLMutationTests.cs b/FlurlGraphQL.Tests/FlurlGraphQLMutationTests.cs
@@ -27,9 +27,10 @@ public async Task TestMutationWithQueryResultsAsync(IFlurlRequest graphqlApiRequ
 	                    }
                     }
                 ")
-                .SetGraphQLVariable("reviewInput", new { 
+                .SetGraphQLVariable("reviewInput", new {
                     episode = "EMPIRE",
                     stars = 5,
+                    StarsEnum = StarsEnum.FiveStars,
                     commentary = "I love this Movie!"
                 })
                 .PostGraphQLQueryAsync()
@@ -48,6 +49,15 @@ public async Task TestMutationWithQueryResultsAsync(IFlurlRequest graphqlApiRequ
         }
     }
 
+    public enum StarsEnum
+    {
+        OneStar = 1,
+        TwoStars = 2,
+        ThreeStars = 3,
+        FourStars = 4,
+        FiveStars = 5
+    };
+
     public class CreateReviewPayload {
         public string Episode { get; set; }
         public ReviewResult Review {get; set;}
diff --git a/FlurlGraphQL.Tests/FlurlGraphQLParsingTests.cs b/FlurlGraphQL.Tests/FlurlGraphQLParsingTests.cs
@@ -1,3 +1,4 @@
+using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Text.Json.Serialization;
@@ -10,6 +11,9 @@
 using Microsoft.VisualStudio.TestTools.UnitTesting;
 using Newtonsoft.Json;
 using Newtonsoft.Json.Linq;
+using System.Reflection;
+using Bogus.DataSets;
+using System.Runtime.Serialization;
 
 namespace FlurlGraphQL.Tests
 {
@@ -156,6 +160,55 @@ public void TestSimpleSystemTextJsonParsingOfPreFlattenedJsonWithStringEnumDirec
             Assert.IsTrue(isEqual, "The Test Json and the Round Trip Serialized Json do not match!");
         }
 
+        [TestMethod]
+        [TestDataExecuteWithAllFlurlSerializerRequests]
+        public void TestJsonParsingForAllStringEnumTestCases(IFlurlRequest flurlRequest)
+        {
+            //The DEFAULT options for FlurlGraphQL System.Text.Json Serializer should already have the String Enum Converter added...
+            //var flurlGraphQLSystemTextJsonSerializer = new FlurlGraphQLSystemTextJsonSerializer(FlurlGraphQLSystemTextJsonSerializer.CreateDefaultSerializerOptions());
+            var graphqlApiRequest = flurlRequest.ToGraphQLRequest();
+
+            var graphqlJsonSerializer = graphqlApiRequest.GraphQLJsonSerializer;
+
+            TestContext.WriteLine($"[{graphqlJsonSerializer.GetType().Name}] Enum Test Cases Parsing ...");
+            bool isUsingSystemTextJson = graphqlJsonSerializer is FlurlGraphQLSystemTextJsonSerializer;
+
+            foreach (int enumIntValue in Enum.GetValues(typeof(EnumTestCase)))
+            {
+                var enumValue = (EnumTestCase)enumIntValue;
+                var enumField = enumValue.GetType().GetField(enumValue.ToString());
+                
+                var expectedEnumStringValue =
+                    enumField.GetCustomAttribute<EnumMemberAttribute>(true)?.Value
+                    //JsonPropertyName is ONLY supported by System.Text.Json; Newtonsoft did not support this attribute for Enums...
+                    ?? (isUsingSystemTextJson ? enumField.GetCustomAttribute<JsonPropertyNameAttribute>(true)?.Name : null)
+                    ?? enumValue.ToString().ToScreamingSnakeCase();
+
+                //Serialize the enum test case...
+                var serializedEnumValue = graphqlJsonSerializer.Serialize(enumValue);
+
+                //The serialized value should be a quoted string output from Json Serialization...
+                Assert.AreEqual($"\"{expectedEnumStringValue}\"", serializedEnumValue, $"The Enum Value [{enumValue}] did not serialize to the expected string value [{expectedEnumStringValue}]!");
+                
+                //Deserialize back to the Enum Value...
+                var deserializedEnumValue = graphqlJsonSerializer.Deserialize<EnumTestCase>(serializedEnumValue);
+                Assert.AreEqual(enumValue, deserializedEnumValue, $"The Enum Value [{enumValue}] did not deserialize back correctly from the serialized value [{serializedEnumValue}]!");
+
+                //Valdate actual values for the OVERRIDE cases using Attributes...
+                switch (enumValue)
+                {
+                    case EnumTestCase.TestPacalCaseEnumMember:
+                        Assert.AreEqual("TEST_PASCAL_CASE_ENUM_MEMBER_OVERRIDE", expectedEnumStringValue);
+                        break;
+                    case EnumTestCase.TestJsonPropertyNameSupportedBySystemTextJson when isUsingSystemTextJson:
+                        Assert.AreEqual("TEST.JsonPropertyName.Supported.By.System.Text.Json", expectedEnumStringValue);
+                        break;
+                }
+
+                TestContext.WriteLine($"Success: [{enumValue}] <==> [{serializedEnumValue}]");
+            }
+        }
+
         [TestMethod]
         public void TestSystemTextJsonParsingOfNestedPaginatedStarWarsGraphQLResults()
         {
diff --git a/FlurlGraphQL.Tests/Models/StarWarsCharacter.cs b/FlurlGraphQL.Tests/Models/StarWarsCharacter.cs
@@ -1,4 +1,5 @@
 ﻿using System.Collections.Generic;
+using System.ComponentModel;
 using System.Runtime.Serialization;
 using System.Text.Json.Serialization;
 using Newtonsoft.Json;
@@ -35,6 +36,31 @@ internal enum TheForceWithEnumMembers
         DarkSideForEvil = -1
     }
 
+    internal enum EnumTestCase
+    {
+        //Use Description to Override Behavior
+        [EnumMember(Value = "TEST_PASCAL_CASE_ENUM_MEMBER_OVERRIDE")]
+        TestPacalCaseEnumMember = 0,
+        //Use JsonPropertyName to Override Behavior
+        [JsonPropertyName("TEST.JsonPropertyName.Supported.By.System.Text.Json")]
+        TestJsonPropertyNameSupportedBySystemTextJson = 8,
+        //Auto-Coversion tests with no attribute...
+        TestPascalCaseAutoConversion = 2,
+        //Auto-Coversion tests with no attribute...
+        TestV2 = 3,
+        //Auto-Coversion tests with no attribute...
+        Test__Strange__Pascal__Snake__Case__2 = 4,
+        //Auto-Coversion tests with no attribute...
+        testCamelCase = 5,
+        //Auto-Coversion tests with no attribute...
+        test_snake_case = 6,
+        //Auto-Coversion tests with no attribute...
+        TEST_SCREAMING_SNAKE_CASE = 7,
+        //JsonPropertyAttribute Test...
+        [Description("TEST.Description.Attribute")]
+        TestDescriptionAttribute = 9
+    }
+
     internal class StarWarsCharacterWithSimpleEnum
     {
         public int PersonalIdentifier { get; set; }
diff --git a/FlurlGraphQL/CustomExtensions/StringExtensions.cs b/FlurlGraphQL/CustomExtensions/StringExtensions.cs
@@ -9,9 +9,13 @@ internal static class StringExtensions
     {
         public const string SPACE = " ";
         public const char UNDERSCORE = '_';
+        //This is a character literal representing the Unicode character with code point 0, also known as 
+        // the null terminator or NUL character. And often used to initialize a char variable to a known default or empty state.
+        public const char NULL_CHAR = '\0';
+
         private static readonly char[] _sentencePunctuationChars = { ' ', '.', ';', '?', '!' };
 
-        public static string ToScreamingCase(this string input)
+        public static string ToScreamingSnakeCase(this string input)
         {
             if (string.IsNullOrEmpty(input)) return input;
 
@@ -22,13 +26,23 @@ public static string ToScreamingCase(this string input)
             int index = 0;
             for (int i = 0; i < inputSpan.Length; i++)
             {
-                char c = inputSpan[i];
-
-                //Insert an underscore before uppercase letters (except first letter)
-                if (i > 0 && char.IsUpper(c))
+                char currentChar = inputSpan[i];
+                char previousChar = i > 0 ? inputSpan[i - 1] : NULL_CHAR;
+                char nextChar = i < inputSpan.Length - 1 ? inputSpan[i + 1] : NULL_CHAR;
+
+                //Insert an underscore before uppercase letters except when:
+                // - Currently on the first letter
+                // - When current, previous, or next character is already an Underscore
+                // - When already contiguous capital letters
+                // - When contingous lower-case (non-capital) letters; implicitly (by processing only Capital Letters)
+                if (i > 0
+                    && currentChar != UNDERSCORE && previousChar != UNDERSCORE && nextChar != UNDERSCORE
+                    && char.IsUpper(currentChar) && !char.IsUpper(previousChar)
+                ) {
                     outputSpan[index++] = UNDERSCORE;
+                }
 
-                outputSpan[index++] = char.ToUpper(c, CultureInfo.InvariantCulture);
+                outputSpan[index++] = char.ToUpper(currentChar, CultureInfo.InvariantCulture);
             }
 
             //return new string(outputSpan[..index]); // Convert the span into a string
diff --git a/FlurlGraphQL/FlurlGraphQL.csproj b/FlurlGraphQL/FlurlGraphQL.csproj
@@ -4,9 +4,9 @@
 		<!--NOTE: Just as with the base Flurl.Http.Newtonsoft library and Microsofts recommendation we now support net6 for the latest projects, but also netstandard2.1 which has proper Async streaming support, 
 				in addition to netstandard2.0 + net461 for legacy support (because netstandard2.0 it had API compatibility issues prior to .NET Framework 4.7.x -->
 		<TargetFrameworks>net461;netstandard2.0;netstandard2.1;net6.0;</TargetFrameworks>
-		<Version>2.0.5</Version>
-		<AssemblyVersion>2.0.5</AssemblyVersion>
-		<FileVersion>2.0.5</FileVersion>
+		<Version>2.0.6</Version>
+		<AssemblyVersion>2.0.6</AssemblyVersion>
+		<FileVersion>2.0.6</FileVersion>
 		<Authors>BBernard / CajunCoding</Authors>
 		<Company>CajunCoding</Company>
 		<Description>GraphQL client extensions for Flurl.Http -- lightweight, simplified, asynchronous, fluent GraphQL client API extensions for the amazing Flurl Http library!</Description>
@@ -17,9 +17,10 @@
 		<RepositoryUrl>https://github.com/cajuncoding/FlurlGraphQL</RepositoryUrl>
 		<PackageReleaseNotes>
 			Release Notes:
-			- Improve configuration support for Defeault Json Processing now with Enum Flags to make enabling/disabling the GraphQL Json Defaults much easier.
+			- Improve String Enum hanlding for additional use cases to ensure resulting Enums are properly formed (e.g. no unnecessary underscores being inserted in various cases).
 
 			Prior Release Notes:
+			- Improve configuration support for Default Json Processing now with Enum Flags to make enabling/disabling the GraphQL Json Defaults much easier.
 			- Improve handling of Enums so that automatic processing as SCREAMING_CASE is handled now without the need to have [EnumMember("")] attributes on every enum value when the names match.
 			- Improve handling of GraphQL Serialization to now automatically use CamelCase for System.Text.Json &amp; Newtonsoft.Json; it was already being handled when de-serializing but not when serializing.
 			- Added new methods to help streamline the configuration of Json Serializer options/settings; a simple action/lambda can now be used to set Json Serialization Options/Settings.
diff --git a/FlurlGraphQL/FlurlGraphQL/JsonProcessing/FlurlGraphQLSystemTextJsonScreamingCaseNamingPolicy.cs b/FlurlGraphQL/FlurlGraphQL/JsonProcessing/FlurlGraphQLSystemTextJsonScreamingCaseNamingPolicy.cs
@@ -4,6 +4,6 @@ namespace FlurlGraphQL.JsonProcessing
 {
     public class FlurlGraphQLSystemTextJsonScreamingCaseNamingPolicy : JsonNamingPolicy
     {
-        public override string ConvertName(string name) => name.ToScreamingCase();
+        public override string ConvertName(string name) => name.ToScreamingSnakeCase();
     }
 }
diff --git a/FlurlGraphQL/FlurlGraphQL/JsonProcessing/FlurlGraphQLSystemTextJsonSerializer.cs b/FlurlGraphQL/FlurlGraphQL/JsonProcessing/FlurlGraphQLSystemTextJsonSerializer.cs
@@ -49,8 +49,8 @@ public static JsonSerializerOptions CreateDefaultSerializerOptions(JsonSerialize
                 graphqlJsonOptions.PropertyNamingPolicy = JsonNamingPolicy.CamelCase;
 
             //For compatibility with FlurlGraphQL v1 behavior (using Newtonsoft.Json) we need to provide support for String to Enum conversion along with support for enum annotations
-            //  via [EnumMember(Value ="CustomName")] annotation (compatible with Newtonsoft.Json). In addition, we now also support [Description("CustomName")] annotation for
-            //  easier syntax that is arguably more intuitive to use.
+            //  via [EnumMember(Value ="CustomName")] annotation (compatible with Newtonsoft.Json). In addition, we now also inherently support [JsonPropertyName("CustomName")] annotation for
+            //  easier syntax that is arguably more intuitive to use as this is provided natively by System.Text.Json.
             if (defaultJsonConfig.IsJsonProcessingFlagEnabled(JsonDefaults.EnableStringEnumHandling))
             {
                 //NOTE: For performance we KNOW we need to add this if the original options were not provided (e.g. null)...
diff --git a/README.md b/README.md
@@ -120,6 +120,9 @@ To use this in your project, add the [FlurlGraphQL](https://www.nuget.org/packag
 To use this in your project with `Newtonsoft.Json` processing then add the add the [FlurlGraphQL.Newtonsoft](https://www.nuget.org/packages/FlurlGraphQL.Newtonsoft/) NuGet package to your project.
 
 ## Release Notes:
+### v2.0.6
+- Improve String Enum hanlding for additional use cases to ensure resulting Enums are properly formed (e.g. no unnecessary underscores being inserted in various cases).
+
 ### v2.0.5
 - Improve configuration support for Defeault Json Processing now with Enum Flags to make enabling/disabling the GraphQL Json Defaults much easier.
 

Original file line number	Diff line number	Diff line change
`@@ -3,5 +3,5 @@`
`3`	`3`
`4`	`4`	`public class FlurlGraphQLNewtonsoftJsonScreamingCaseNamingStrategy : NamingStrategy`
`5`	`5`	`{`
`6`		`- protected override string ResolvePropertyName(string name) => name.ToScreamingCase();`
	`6`	`+ protected override string ResolvePropertyName(string name) => name.ToScreamingSnakeCase();`
`7`	`7`	`}`
Original file line number	Diff line number	Diff line change
`@@ -4,6 +4,6 @@ namespace FlurlGraphQL.JsonProcessing`
`4`	`4`	`{`
`5`	`5`	`public class FlurlGraphQLSystemTextJsonScreamingCaseNamingPolicy : JsonNamingPolicy`
`6`	`6`	`{`
`7`		`- public override string ConvertName(string name) => name.ToScreamingCase();`
	`7`	`+ public override string ConvertName(string name) => name.ToScreamingSnakeCase();`
`8`	`8`	`}`
`9`	`9`	`}`