Merge pull request #14 from IvanMurzak/feature/json-schema-enum-types

feat: add enum handling in MethodWrapper and enhance tests

Author: IvanMurzak

.claude/settings.local.json

@@ -1,7 +1,9 @@
 {
   "permissions": {
     "allow": [
-      "Bash(git log:*)"
+      "Bash(git log:*)",
+      "Bash(dotnet test:*)",
+      "Bash(dotnet build:*)"
     ],
     "deny": [],
     "ask": []

ReflectorNet.Tests/SchemaTests/MethodWrapperTests.cs

@@ -272,5 +272,92 @@ public void Async_Method_Invocation_Support()
                 _output.WriteLine("Async method testing skipped - no suitable method found");
             }
         }
+
+        [Fact]
+        public async Task MethodWrapper_Enum_Parameter_String_Input()
+        {
+            // Arrange
+            var reflector = new Reflector();
+            var methodInfo = typeof(com.IvanMurzak.ReflectorNet.Tests.Utils.MethodHelper).GetMethod(nameof(com.IvanMurzak.ReflectorNet.Tests.Utils.MethodHelper.ProcessEnum))!;
+            var wrapper = MethodWrapper.Create(reflector, null, methodInfo);
+
+            // Act & Assert - Test with string representation of enum
+            var parameters = new Dictionary<string, object?> 
+            { 
+                { "enumValue", "Option2" } 
+            };
+
+            var result = await wrapper.InvokeDict(parameters);
+            
+            // Assert
+            Assert.NotNull(result);
+            Assert.Equal("Processed enum: Option2", result.ToString());
+            _output.WriteLine($"Enum parameter test with string input: {result}");
+        }
+
+        [Fact]
+        public async Task MethodWrapper_Enum_Parameter_JsonElement_Input()
+        {
+            // Arrange
+            var reflector = new Reflector();
+            var methodInfo = typeof(com.IvanMurzak.ReflectorNet.Tests.Utils.MethodHelper).GetMethod(nameof(com.IvanMurzak.ReflectorNet.Tests.Utils.MethodHelper.ProcessEnum))!;
+            var wrapper = MethodWrapper.Create(reflector, null, methodInfo);
+
+            // Act & Assert - Test with JsonElement containing enum string
+            var jsonDocument = JsonDocument.Parse("\"Option3\"");
+            var jsonElement = jsonDocument.RootElement;
+            
+            var parameters = new Dictionary<string, object?> 
+            { 
+                { "enumValue", jsonElement } 
+            };
+
+            var result = await wrapper.InvokeDict(parameters);
+            
+            // Assert
+            Assert.NotNull(result);
+            Assert.Equal("Processed enum: Option3", result.ToString());
+            _output.WriteLine($"Enum parameter test with JsonElement input: {result}");
+        }
+
+        [Fact]
+        public async Task MethodWrapper_Enum_Parameter_Default_Value()
+        {
+            // Arrange
+            var reflector = new Reflector();
+            var methodInfo = typeof(com.IvanMurzak.ReflectorNet.Tests.Utils.MethodHelper).GetMethod(nameof(com.IvanMurzak.ReflectorNet.Tests.Utils.MethodHelper.ProcessEnumWithDefault))!;
+            var wrapper = MethodWrapper.Create(reflector, null, methodInfo);
+
+            // Act & Assert - Test with no parameter (should use default value Option2)
+            var result = await wrapper.InvokeDict(null);
+            
+            // Assert
+            Assert.NotNull(result);
+            Assert.Equal("Processed enum with default: Option2", result.ToString());
+            _output.WriteLine($"Enum parameter test with default value: {result}");
+        }
+
+        [Fact]
+        public async Task MethodWrapper_Enum_Parameter_Mixed_Types()
+        {
+            // Arrange
+            var reflector = new Reflector();
+            var methodInfo = typeof(com.IvanMurzak.ReflectorNet.Tests.Utils.MethodHelper).GetMethod(nameof(com.IvanMurzak.ReflectorNet.Tests.Utils.MethodHelper.ProcessStringAndEnum))!;
+            var wrapper = MethodWrapper.Create(reflector, null, methodInfo);
+
+            // Act & Assert - Test with string and enum parameters
+            var parameters = new Dictionary<string, object?> 
+            { 
+                { "text", "Hello" },
+                { "enumValue", "Option4" } 
+            };
+
+            var result = await wrapper.InvokeDict(parameters);
+            
+            // Assert
+            Assert.NotNull(result);
+            Assert.Equal("Text: Hello, Enum: Option4", result.ToString());
+            _output.WriteLine($"Mixed parameters test with enum: {result}");
+        }
     }
 }

ReflectorNet.Tests/SchemaTests/SchemaTests.cs

@@ -161,5 +161,42 @@ private static void ValidatePropertyNotExists(JsonNode properties, string proper
             Assert.False(properties.AsObject().ContainsKey(propertyName),
                 $"Properties should NOT contain '{propertyName}' property (it should be ignored). Available properties: {string.Join(", ", properties.AsObject().Select(x => x.Key))}");
         }
+
+        [Fact]
+        public void Enum_Schema_Should_Include_All_Enum_Values()
+        {
+            var reflector = new Reflector();
+            var schema = JsonSchemaValidation(typeof(TestEnumWithDescriptions), reflector);
+
+            // Validate that the schema has the correct structure for enums
+            Assert.NotNull(schema);
+            Assert.True(schema.AsObject().ContainsKey(JsonSchema.Type),
+                $"Enum schema should contain '{JsonSchema.Type}' property. Available properties: {string.Join(", ", schema.AsObject().Select(x => x.Key))}");
+
+            // Validate that type is "string"
+            var schemaType = schema[JsonSchema.Type];
+            Assert.NotNull(schemaType);
+            Assert.Equal(JsonSchema.String, schemaType.ToString());
+
+            // Validate that the schema contains an "enum" property
+            Assert.True(schema.AsObject().ContainsKey("enum"),
+                $"Enum schema should contain 'enum' property. Available properties: {string.Join(", ", schema.AsObject().Select(x => x.Key))}");
+
+            var enumValues = schema["enum"];
+            Assert.NotNull(enumValues);
+            Assert.True(enumValues is JsonArray, "Enum values should be a JSON array");
+
+            var enumArray = enumValues.AsArray();
+            
+            // Validate that all enum values are present
+            var expectedValues = new[] { "Option1", "Option2", "Option3", "Option4" };
+            Assert.Equal(expectedValues.Length, enumArray.Count);
+
+            foreach (var expectedValue in expectedValues)
+            {
+                var hasValue = enumArray.Any(v => v?.ToString() == expectedValue);
+                Assert.True(hasValue, $"Enum schema should contain value '{expectedValue}'. Actual values: {string.Join(", ", enumArray.Select(v => v?.ToString()))}");
+            }
+        }
     }
 }

ReflectorNet.Tests/Utils/Method/MethodHelper.Enum.cs

@@ -0,0 +1,40 @@
+using System.ComponentModel;
+using com.IvanMurzak.ReflectorNet.Tests.Model;
+
+namespace com.IvanMurzak.ReflectorNet.Tests.Utils
+{
+    public static partial class MethodHelper
+    {
+        [Description("Test method that accepts an enum parameter.")]
+        public static string ProcessEnum
+        (
+            [Description("An enum value to process.")]
+            TestEnumWithDescriptions enumValue
+        )
+        {
+            return $"Processed enum: {enumValue}";
+        }
+
+        [Description("Test method that accepts an enum parameter with default value.")]
+        public static string ProcessEnumWithDefault
+        (
+            [Description("An enum value to process with default.")]
+            TestEnumWithDescriptions enumValue = TestEnumWithDescriptions.Option2
+        )
+        {
+            return $"Processed enum with default: {enumValue}";
+        }
+
+        [Description("Test method that accepts both string and enum parameters.")]
+        public static string ProcessStringAndEnum
+        (
+            [Description("A string parameter.")]
+            string text,
+            [Description("An enum parameter.")]
+            TestEnumWithDescriptions enumValue
+        )
+        {
+            return $"Text: {text}, Enum: {enumValue}";
+        }
+    }
+}

ReflectorNet/ReflectorNet.csproj

@@ -9,7 +9,7 @@
 
     <!-- NuGet Package Information -->
     <PackageId>com.IvanMurzak.ReflectorNet</PackageId>
-    <Version>1.0.6</Version>
+    <Version>1.1.0</Version>
     <Authors>Ivan Murzak</Authors>
     <Copyright>Copyright © Ivan Murzak 2025</Copyright>
     <Description>ReflectorNet is an advanced .NET reflection toolkit designed for AI-driven scenarios. Effortlessly search for C# methods using natural language queries, invoke any method by supplying arguments as JSON, and receive results as JSON. The library also provides a powerful API to inspect, modify, and manage in-memory object instances dynamically via JSON data. Ideal for automation, testing, and AI integration workflows.</Description>

ReflectorNet/src/Reflector/MethodWrapper.cs

@@ -286,8 +286,8 @@ public virtual bool VerifyParameters(IReadOnlyDictionary<string, object?>? named
             }
             else
             {
-                // Use the provided parameter value
-                return parameter;
+                // Handle enum conversion for string values and return the provided parameter value
+                return TryConvertStringToEnum(parameter, methodParameter.ParameterType, methodParameter.Name!);
             }
         }
 
@@ -351,8 +351,8 @@ public virtual bool VerifyParameters(IReadOnlyDictionary<string, object?>? named
                 }
                 else
                 {
-                    // Use the provided parameter value
-                    return value;
+                    // Handle enum conversion for string values and return the provided parameter value
+                    return TryConvertStringToEnum(value, parameter.ParameterType, parameter.Name!);
                 }
             }
             else if (parameter.HasDefaultValue)
@@ -369,6 +369,22 @@ public virtual bool VerifyParameters(IReadOnlyDictionary<string, object?>? named
             }
         }
 
+        private static object? TryConvertStringToEnum(object? value, Type parameterType, string parameterName)
+        {
+            if (value is string stringValue && parameterType.IsEnum)
+            {
+                try
+                {
+                    return Enum.Parse(parameterType, stringValue, ignoreCase: true);
+                }
+                catch (ArgumentException)
+                {
+                    throw new ArgumentException($"Invalid value '{stringValue}' for parameter '{parameterName}'. Valid values are: {string.Join(", ", Enum.GetNames(parameterType))}");
+                }
+            }
+            return value;
+        }
+
         protected virtual void PrintParameters(object?[]? parameters)
         {
             if (!(_logger?.IsEnabled(LogLevel.Debug) ?? false))

ReflectorNet/src/Utils/Json/JsonSchema.Internal.cs

@@ -217,6 +217,22 @@ JsonNode GeneratePrimitiveSchema(Type type)
             if (underlyingType == typeof(Guid))
                 return new JsonObject { [Type] = String, ["format"] = "uuid" };
 
+            // Handle enum types
+            if (underlyingType.IsEnum)
+            {
+                var enumValues = new JsonArray();
+                foreach (var enumValue in Enum.GetValues(underlyingType))
+                {
+                    enumValues.Add(JsonValue.Create(enumValue.ToString()));
+                }
+
+                return new JsonObject 
+                { 
+                    [Type] = String,
+                    ["enum"] = enumValues
+                };
+            }
+
             // Default for unknown primitives
             return new JsonObject { [Type] = String };
         }