Map OpenApiSchema types to simple type and add test to validate

Author: MaggieKimani1

src/Microsoft.OpenApi/Extensions/OpenApiTypeMapper.cs

@@ -42,7 +42,7 @@ public static class OpenApiTypeMapper
             [typeof(DateTimeOffset?)] = () => new OpenApiSchema { Type = "string", Format = "date-time", Nullable = true },
             [typeof(Guid?)] = () => new OpenApiSchema { Type = "string", Format = "uuid", Nullable = true },
             [typeof(char?)] = () => new OpenApiSchema { Type = "string", Nullable = true },
-            
+
             [typeof(Uri)] = () => new OpenApiSchema { Type = "string" }, // Uri is treated as simple string
             [typeof(string)] = () => new OpenApiSchema { Type = "string" },
             [typeof(object)] = () => new OpenApiSchema { Type = "object" }
@@ -81,5 +81,50 @@ public static OpenApiSchema MapTypeToOpenApiPrimitiveType(this Type type)
                 ? result()
                 : new OpenApiSchema { Type = "string" };
         }
+
+        /// <summary>
+        /// Maps an OpenAPI data type and format to a simple type.
+        /// </summary>
+        /// <param name="schema">The OpenApi data type</param>
+        /// <returns>The simple type</returns>
+        /// <exception cref="ArgumentNullException"></exception>
+        public static Type MapOpenApiPrimitiveTypeToSimpleType(this OpenApiSchema schema)
+        {
+            if (schema == null)
+            {
+                throw new ArgumentNullException(nameof(schema));
+            }
+
+            var type = (schema.Type, schema.Format, schema.Nullable) switch
+            {
+                ("boolean", null, false) => typeof(bool),
+                ("integer", "int32", false) => typeof(int),
+                ("integer", "int64", false) => typeof(long),
+                ("number", "float", false) => typeof(float),
+                ("number", "double", false) => typeof(double),
+                ("number", "decimal", false) => typeof(decimal),
+                ("string", "byte", false) => typeof(byte),
+                ("string", "date-time", false) => typeof(DateTimeOffset),
+                ("string", "uuid", false) => typeof(Guid),
+                ("string", "duration", false) => typeof(TimeSpan),
+                ("string", "char", false) => typeof(char),
+                ("string", null, false) => typeof(string),
+                ("object", null, false) => typeof(object),
+                ("string", "uri", false) => typeof(Uri),
+                ("integer", "int32", true) => typeof(int?),
+                ("integer", "int64", true) => typeof(long?),
+                ("number", "float", true) => typeof(float?),
+                ("number", "double", true) => typeof(double?),
+                ("number", "decimal", true) => typeof(decimal?),
+                ("string", "byte", true) => typeof(byte?),
+                ("string", "date-time", true) => typeof(DateTimeOffset?),
+                ("string", "uuid", true) => typeof(Guid?),
+                ("string", "char", true) => typeof(char?),
+                ("boolean", null, true) => typeof(bool?),
+                _ => typeof(string),
+            };
+            
+            return type;
+        }
     }
 }

test/Microsoft.OpenApi.Tests/Extensions/OpenApiTypeMapperTests.cs

@@ -12,6 +12,24 @@ namespace Microsoft.OpenApi.Tests.Extensions
 {
     public class OpenApiTypeMapperTests
     {
+        public static IEnumerable<object[]> PrimitiveTypeData => new List<object[]>
+        {
+            new object[] { typeof(int), new OpenApiSchema { Type = "integer", Format = "int32" } },
+            new object[] { typeof(string), new OpenApiSchema { Type = "string" } },
+            new object[] { typeof(double), new OpenApiSchema { Type = "number", Format = "double" } },
+            new object[] { typeof(float?), new OpenApiSchema { Type = "number", Format = "float", Nullable = true } },
+            new object[] { typeof(DateTimeOffset), new OpenApiSchema { Type = "string", Format = "date-time" } }
+        };
+
+        public static IEnumerable<object[]> OpenApiDataTypes => new List<object[]>
+        {
+            new object[] { new OpenApiSchema { Type = "integer", Format = "int32"}, typeof(int) },
+            new object[] { new OpenApiSchema { Type = "string" }, typeof(string) },
+            new object[] { new OpenApiSchema { Type = "number", Format = "double" }, typeof(double) },
+            new object[] { new OpenApiSchema { Type = "number", Format = "float", Nullable = true }, typeof(float?) },
+            new object[] { new OpenApiSchema { Type = "string", Format = "date-time" }, typeof(DateTimeOffset) }
+        };
+        
         [Theory]
         [MemberData(nameof(PrimitiveTypeData))]
         public void MapTypeToOpenApiPrimitiveTypeShouldSucceed(Type type, OpenApiSchema expected)
@@ -23,13 +41,15 @@ public void MapTypeToOpenApiPrimitiveTypeShouldSucceed(Type type, OpenApiSchema
             actual.Should().BeEquivalentTo(expected);
         }
 
-        public static IEnumerable<object[]> PrimitiveTypeData => new List<object[]>
+        [Theory]
+        [MemberData(nameof(OpenApiDataTypes))]
+        public void MapOpenApiSchemaTypeToSimpleTypeShouldSucceed(OpenApiSchema schema, Type expected)
         {
-            new object[] { typeof(int), new OpenApiSchema { Type = "integer", Format = "int32" } },
-            new object[] { typeof(string), new OpenApiSchema { Type = "string" } },
-            new object[] { typeof(double), new OpenApiSchema { Type = "number", Format = "double" } },
-            new object[] { typeof(float?), new OpenApiSchema { Type = "number", Format = "float", Nullable = true } },
-            new object[] { typeof(DateTimeOffset), new OpenApiSchema { Type = "string", Format = "date-time" } }
-        };
+            // Arrange & Act
+            var actual = OpenApiTypeMapper.MapOpenApiPrimitiveTypeToSimpleType(schema);
+
+            // Assert
+            actual.Should().Be(expected);
+        }
     }
 }