Merge pull request #1888 from microsoft/mk/remove-validation-rule

Remove DataTypeMismatch validation rule from the default ruleset
microsoft · Oct 29, 2024 · 34b81ce · 34b81ce
2 parents 6987f7b + a478bd2
commit 34b81ce
Show file tree

Hide file tree

Showing 13 changed files with 151 additions and 341 deletions.
diff --git a/src/Microsoft.OpenApi/Validations/Rules/OpenApiHeaderRules.cs b/src/Microsoft.OpenApi/Validations/Rules/OpenApiHeaderRules.cs
diff --git a/src/Microsoft.OpenApi/Validations/Rules/OpenApiMediaTypeRules.cs b/src/Microsoft.OpenApi/Validations/Rules/OpenApiMediaTypeRules.cs
diff --git a/src/Microsoft.OpenApi/Validations/Rules/OpenApiNonDefaultRules.cs b/src/Microsoft.OpenApi/Validations/Rules/OpenApiNonDefaultRules.cs
@@ -0,0 +1,123 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT license.
+
+using System.Collections.Generic;
+using System.Linq;
+using System.Text.Json.Nodes;
+using Microsoft.OpenApi.Models;
+
+namespace Microsoft.OpenApi.Validations.Rules
+{
+    /// <summary>
+    /// Defines a non-default set of rules for validating examples in header, media type and parameter objects against the schema
+    /// </summary>
+    public static class OpenApiNonDefaultRules
+    {
+        /// <summary>
+        /// Validate the data matches with the given data type.
+        /// </summary>
+        public static ValidationRule<OpenApiHeader> HeaderMismatchedDataType =>
+            new(nameof(HeaderMismatchedDataType),
+                (context, header) =>
+                {
+                    ValidateMismatchedDataType(context, nameof(HeaderMismatchedDataType), header.Example, header.Examples, header.Schema);
+                });
+
+        /// <summary>
+        /// Validate the data matches with the given data type.
+        /// </summary>
+        public static ValidationRule<OpenApiMediaType> MediaTypeMismatchedDataType =>
+            new(nameof(MediaTypeMismatchedDataType),
+                (context, mediaType) =>
+                {
+                    ValidateMismatchedDataType(context, nameof(MediaTypeMismatchedDataType), mediaType.Example, mediaType.Examples, mediaType.Schema);
+                });
+
+        /// <summary>
+        /// Validate the data matches with the given data type.
+        /// </summary>
+        public static ValidationRule<OpenApiParameter> ParameterMismatchedDataType =>
+        new(nameof(ParameterMismatchedDataType),
+                (context, parameter) =>
+                {
+                    ValidateMismatchedDataType(context, nameof(ParameterMismatchedDataType), parameter.Example, parameter.Examples, parameter.Schema);
+                });
+
+        /// <summary>
+        /// Validate the data matches with the given data type.
+        /// </summary>
+        public static ValidationRule<OpenApiSchema> SchemaMismatchedDataType =>
+            new(nameof(SchemaMismatchedDataType),
+                (context, schema) =>
+                {
+                    // default
+                    context.Enter("default");
+
+                    if (schema.Default != null)
+                    {
+                        RuleHelpers.ValidateDataTypeMismatch(context, nameof(SchemaMismatchedDataType), schema.Default, schema);
+                    }
+
+                    context.Exit();
+
+                    // example
+                    context.Enter("example");
+
+                    if (schema.Example != null)
+                    {
+                        RuleHelpers.ValidateDataTypeMismatch(context, nameof(SchemaMismatchedDataType), schema.Example, schema);
+                    }
+
+                    context.Exit();
+
+                    // enum
+                    context.Enter("enum");
+
+                    if (schema.Enum != null)
+                    {
+                        for (var i = 0; i < schema.Enum.Count; i++)
+                        {
+                            context.Enter(i.ToString());
+                            RuleHelpers.ValidateDataTypeMismatch(context, nameof(SchemaMismatchedDataType), schema.Enum[i], schema);
+                            context.Exit();
+                        }
+                    }
+
+                    context.Exit();
+                });
+
+        private static void ValidateMismatchedDataType(IValidationContext context,
+                                                      string ruleName,
+                                                      JsonNode example,
+                                                      IDictionary<string, OpenApiExample> examples,
+                                                      OpenApiSchema schema)
+        {
+            // example
+            context.Enter("example");
+
+            if (example != null)
+            {
+                RuleHelpers.ValidateDataTypeMismatch(context, ruleName, example, schema);
+            }
+
+            context.Exit();
+
+            // enum
+            context.Enter("examples");
+
+            if (examples != null)
+            {
+                foreach (var key in examples.Keys.Where(k => examples[k] != null))
+                {
+                    context.Enter(key);
+                    context.Enter("value");
+                    RuleHelpers.ValidateDataTypeMismatch(context, ruleName, examples[key]?.Value, schema);
+                    context.Exit();
+                    context.Exit();
+                }
+            }
+
+            context.Exit();
+        }
+    }
+}
diff --git a/src/Microsoft.OpenApi/Validations/Rules/OpenApiParameterRules.cs b/src/Microsoft.OpenApi/Validations/Rules/OpenApiParameterRules.cs
@@ -58,45 +58,6 @@ public static class OpenApiParameterRules
                     context.Exit();
                 });
 
-        /// <summary>
-        /// Validate the data matches with the given data type.
-        /// </summary>
-        public static ValidationRule<OpenApiParameter> ParameterMismatchedDataType =>
-            new(nameof(ParameterMismatchedDataType),
-                (context, parameter) =>
-                {
-                    // example
-                    context.Enter("example");
-
-                    if (parameter.Example != null)
-                    {
-                        RuleHelpers.ValidateDataTypeMismatch(context, nameof(ParameterMismatchedDataType), parameter.Example, parameter.Schema);
-                    }
-
-                    context.Exit();
-
-                    // examples
-                    context.Enter("examples");
-
-                    if (parameter.Examples != null)
-                    {
-                        foreach (var key in parameter.Examples.Keys)
-                        {
-                            if (parameter.Examples[key] != null)
-                            {
-                                context.Enter(key);
-                                context.Enter("value");
-                                RuleHelpers.ValidateDataTypeMismatch(context, 
-                                    nameof(ParameterMismatchedDataType), parameter.Examples[key]?.Value, parameter.Schema);
-                                context.Exit();
-                                context.Exit();
-                            }
-                        }
-                    }
-
-                    context.Exit();
-                });
-
         /// <summary>
         /// Validate that a path parameter should always appear in the path
         /// </summary>

diff --git a/src/Microsoft.OpenApi/Validations/Rules/OpenApiSchemaRules.cs b/src/Microsoft.OpenApi/Validations/Rules/OpenApiSchemaRules.cs
@@ -13,49 +13,6 @@ namespace Microsoft.OpenApi.Validations.Rules
     [OpenApiRule]
     public static class OpenApiSchemaRules
     {
-        /// <summary>
-        /// Validate the data matches with the given data type.
-        /// </summary>
-        public static ValidationRule<OpenApiSchema> SchemaMismatchedDataType =>
-            new(nameof(SchemaMismatchedDataType),
-                (context, schema) =>
-                {
-                    // default
-                    context.Enter("default");
-
-                    if (schema.Default != null)
-                    {
-                        RuleHelpers.ValidateDataTypeMismatch(context, nameof(SchemaMismatchedDataType), schema.Default, schema);
-                    }
-
-                    context.Exit();
-
-                    // example
-                    context.Enter("example");
-
-                    if (schema.Example != null)
-                    {
-                        RuleHelpers.ValidateDataTypeMismatch(context, nameof(SchemaMismatchedDataType), schema.Example, schema);
-                    }
-
-                    context.Exit();
-
-                    // enum
-                    context.Enter("enum");
-
-                    if (schema.Enum != null)
-                    {
-                        for (var i = 0; i < schema.Enum.Count; i++)
-                        {
-                            context.Enter(i.ToString());
-                            RuleHelpers.ValidateDataTypeMismatch(context, nameof(SchemaMismatchedDataType), schema.Enum[i], schema);
-                            context.Exit();
-                        }
-                    }
-
-                    context.Exit();
-                });
-
         /// <summary>
         /// Validates Schema Discriminator
         /// </summary>

diff --git a/src/Microsoft.OpenApi/Validations/Rules/RuleHelpers.cs b/src/Microsoft.OpenApi/Validations/Rules/RuleHelpers.cs
@@ -1,10 +1,8 @@
 // Copyright (c) Microsoft Corporation. All rights reserved.
 // Licensed under the MIT license.
 
-using System;
 using System.Text.Json;
 using System.Text.Json.Nodes;
-using Microsoft.OpenApi.Any;
 using Microsoft.OpenApi.Models;
 
 namespace Microsoft.OpenApi.Validations.Rules

diff --git a/src/Microsoft.OpenApi/Validations/ValidationRuleSet.cs b/src/Microsoft.OpenApi/Validations/ValidationRuleSet.cs
@@ -1,5 +1,4 @@
-
-// Copyright (c) Microsoft Corporation. All rights reserved.
+// Copyright (c) Microsoft Corporation. All rights reserved.
 // Licensed under the MIT license.
 
 using System;
@@ -9,7 +8,6 @@
 using Microsoft.OpenApi.Exceptions;
 using Microsoft.OpenApi.Properties;
 using Microsoft.OpenApi.Validations.Rules;
-using System.Data;
 
 namespace Microsoft.OpenApi.Validations
 {
@@ -329,17 +327,15 @@ internal static PropertyInfo[] GetValidationRuleTypes()
                 ..typeof(OpenApiExternalDocsRules).GetProperties(BindingFlags.Static | BindingFlags.Public),
                 ..typeof(OpenApiInfoRules).GetProperties(BindingFlags.Static | BindingFlags.Public),
                 ..typeof(OpenApiLicenseRules).GetProperties(BindingFlags.Static | BindingFlags.Public),
-                ..typeof(OpenApiMediaTypeRules).GetProperties(BindingFlags.Static | BindingFlags.Public),
                 ..typeof(OpenApiOAuthFlowRules).GetProperties(BindingFlags.Static | BindingFlags.Public),
                 ..typeof(OpenApiServerRules).GetProperties(BindingFlags.Static | BindingFlags.Public),
                 ..typeof(OpenApiResponseRules).GetProperties(BindingFlags.Static | BindingFlags.Public),
                 ..typeof(OpenApiResponsesRules).GetProperties(BindingFlags.Static | BindingFlags.Public),
                 ..typeof(OpenApiSchemaRules).GetProperties(BindingFlags.Static | BindingFlags.Public),
-                ..typeof(OpenApiHeaderRules).GetProperties(BindingFlags.Static | BindingFlags.Public),
                 ..typeof(OpenApiTagRules).GetProperties(BindingFlags.Static | BindingFlags.Public),
                 ..typeof(OpenApiPathsRules).GetProperties(BindingFlags.Static | BindingFlags.Public),
-                ..typeof(OpenApiParameterRules).GetProperties(BindingFlags.Static | BindingFlags.Public),
-            ];
+                ..typeof(OpenApiParameterRules).GetProperties(BindingFlags.Static | BindingFlags.Public)
+                ];
         }
     }
 }