- Add rules for header (mirror parameter)

Author: PerthCharern

src/Microsoft.OpenApi/Validations/OpenApiValidator.cs

@@ -77,6 +77,12 @@ public void AddError(OpenApiValidatorError error)
         /// <param name="item">The object to be validated</param>
         public override void Visit(OpenApiComponents item) => Validate(item);
 
+        /// <summary>
+        /// Execute validation rules against an <see cref="OpenApiHeader"/>
+        /// </summary>
+        /// <param name="item">The object to be validated</param>
+        public override void Visit(OpenApiHeader item) => Validate(item);
+
         /// <summary>
         /// Execute validation rules against an <see cref="OpenApiResponse"/>
         /// </summary>

src/Microsoft.OpenApi/Validations/Rules/OpenApiHeaderRules.cs

@@ -0,0 +1,57 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT license. 
+
+using System;
+using Microsoft.OpenApi.Models;
+using Microsoft.OpenApi.Properties;
+
+namespace Microsoft.OpenApi.Validations.Rules
+{
+    /// <summary>
+    /// The validation rules for <see cref="OpenApiHeader"/>.
+    /// </summary>
+    [OpenApiRule]
+    public static class OpenApiHeaderRules
+    {
+        /// <summary>
+        /// Validate the data matches with the given data type.
+        /// </summary>
+        public static ValidationRule<OpenApiHeader> HeaderMismatchedDataType =>
+            new ValidationRule<OpenApiHeader>(
+                (context, header) =>
+                {
+                    // example
+                    context.Enter("example");
+
+                    if (header.Example != null)
+                    {
+                        RuleHelpers.ValidateDataTypeMismatch(context, nameof(HeaderMismatchedDataType), header.Example, header.Schema);
+                    }
+
+                    context.Exit();
+
+
+                    // examples
+                    context.Enter("examples");
+
+                    if (header.Examples != null)
+                    {
+                        foreach (var key in header.Examples.Keys)
+                        {
+                            if (header.Examples[key] != null)
+                            {
+                                context.Enter(key);
+                                context.Enter("value");
+                                RuleHelpers.ValidateDataTypeMismatch(context, nameof(HeaderMismatchedDataType), header.Examples[key]?.Value, header.Schema);
+                                context.Exit();
+                                context.Exit();
+                            }
+                        }
+                    }
+
+                    context.Exit();
+                });
+
+        // add more rule.
+    }
+}

src/Microsoft.OpenApi/Validations/Rules/OpenApiParameterRules.cs

@@ -76,7 +76,7 @@ public static class OpenApiParameterRules
                     context.Exit();
 
 
-                    // enum
+                    // examples
                     context.Enter("examples");
 
                     if (parameter.Examples != null)

test/Microsoft.OpenApi.Tests/Validations/OpenApiHeaderValidationTests.cs

@@ -0,0 +1,132 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT license. 
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using FluentAssertions;
+using Microsoft.OpenApi.Any;
+using Microsoft.OpenApi.Extensions;
+using Microsoft.OpenApi.Models;
+using Microsoft.OpenApi.Properties;
+using Microsoft.OpenApi.Services;
+using Microsoft.OpenApi.Validations.Rules;
+using Xunit;
+
+namespace Microsoft.OpenApi.Validations.Tests
+{
+    public class OpenApiHeaderValidationTests
+    {
+        [Fact]
+        public void ValidateExampleShouldNotHaveDataTypeMismatchForSimpleSchema()
+        {
+            // Arrange
+            IEnumerable<OpenApiError> errors;
+            var header = new OpenApiHeader()
+            {
+                Required = true,
+                Example = new OpenApiInteger(55),
+                Schema = new OpenApiSchema()
+                {
+                    Type = "string",
+                }
+            };
+
+            // Act
+            var validator = new OpenApiValidator(ValidationRuleSet.GetDefaultRuleSet());
+            var walker = new OpenApiWalker(validator);
+            walker.Walk(header);
+
+            errors = validator.Errors;
+            bool result = !errors.Any();
+
+            // Assert
+            result.Should().BeFalse();
+            errors.Select(e => e.Message).Should().BeEquivalentTo(new[]
+            {
+                RuleHelpers.DataTypeMismatchedErrorMessage
+            });
+            errors.Select(e => e.Pointer).Should().BeEquivalentTo(new[]
+            {
+                "#/example",
+            });
+        }
+
+        [Fact]
+        public void ValidateExamplesShouldNotHaveDataTypeMismatchForSimpleSchema()
+        {
+            // Arrange
+            IEnumerable<OpenApiError> errors;
+
+            var header = new OpenApiHeader()
+            {
+                Required = true,
+                Schema = new OpenApiSchema()
+                {
+                    Type = "object",
+                    AdditionalProperties = new OpenApiSchema()
+                    {
+                        Type = "integer",
+                    }
+                },
+                Examples =
+                    {
+                        ["example0"] = new OpenApiExample()
+                        {
+                            Value = new OpenApiString("1"),
+                        },
+                        ["example1"] = new OpenApiExample()
+                        {
+                           Value = new OpenApiObject()
+                            {
+                                ["x"] = new OpenApiInteger(2),
+                                ["y"] = new OpenApiString("20"),
+                                ["z"] = new OpenApiString("200")
+                            }
+                        },
+                        ["example2"] = new OpenApiExample()
+                        {
+                            Value =
+                            new OpenApiArray()
+                            {
+                                new OpenApiInteger(3)
+                            }
+                        },
+                        ["example3"] = new OpenApiExample()
+                        {
+                            Value = new OpenApiObject()
+                            {
+                                ["x"] = new OpenApiInteger(4),
+                                ["y"] = new OpenApiInteger(40),
+                            }
+                        },
+                    }
+            };
+
+            // Act
+            var validator = new OpenApiValidator(ValidationRuleSet.GetDefaultRuleSet());
+            var walker = new OpenApiWalker(validator);
+            walker.Walk(header);
+
+            errors = validator.Errors;
+            bool result = !errors.Any();
+
+            // Assert
+            result.Should().BeFalse();
+            errors.Select(e => e.Message).Should().BeEquivalentTo(new[]
+            {
+                RuleHelpers.DataTypeMismatchedErrorMessage,
+                RuleHelpers.DataTypeMismatchedErrorMessage,
+                RuleHelpers.DataTypeMismatchedErrorMessage,
+            });
+            errors.Select(e => e.Pointer).Should().BeEquivalentTo(new[]
+            {
+                // #enum/0 is not an error since the spec allows
+                // representing an object using a string.
+                "#/examples/example1/value/y",
+                "#/examples/example1/value/z",
+                "#/examples/example2/value"
+            });
+        }
+    }
+}

test/Microsoft.OpenApi.Tests/Validations/ValidationRuleSetTests.cs

@@ -43,7 +43,7 @@ public void DefaultRuleSetPropertyReturnsTheCorrectRules()
             Assert.NotEmpty(rules);
 
             // Update the number if you add new default rule(s).
-            Assert.Equal(19, rules.Count);
+            Assert.Equal(20, rules.Count);
         }
     }
 }