Merge pull request #822 from microsoft/fix/warnings

darrelmiller · web-flow · commit 962b971403e3 · 2022-04-11T13:04:16.000-04:00
Added support for Validation to produce warnings as well as errors
diff --git a/src/Microsoft.OpenApi.Readers/OpenApiDiagnostic.cs b/src/Microsoft.OpenApi.Readers/OpenApiDiagnostic.cs
@@ -17,6 +17,11 @@ public class OpenApiDiagnostic : IDiagnostic
         /// </summary>
         public IList<OpenApiError> Errors { get; set; } = new List<OpenApiError>();
 
+        /// <summary>
+        /// List of all warnings
+        /// </summary>
+        public IList<OpenApiError> Warnings { get; set; } = new List<OpenApiError>();
+
         /// <summary>
         /// Open API specification version of the document parsed.
         /// </summary>
diff --git a/src/Microsoft.OpenApi.Readers/OpenApiYamlDocumentReader.cs b/src/Microsoft.OpenApi.Readers/OpenApiYamlDocumentReader.cs
@@ -4,6 +4,7 @@
 using System;
 using System.Collections.Generic;
 using System.IO;
+using System.Linq;
 using System.Threading.Tasks;
 using Microsoft.OpenApi.Exceptions;
 using Microsoft.OpenApi.Extensions;
@@ -12,6 +13,7 @@
 using Microsoft.OpenApi.Readers.Interface;
 using Microsoft.OpenApi.Readers.Services;
 using Microsoft.OpenApi.Services;
+using Microsoft.OpenApi.Validations;
 using SharpYaml.Serialization;
 
 namespace Microsoft.OpenApi.Readers
@@ -68,11 +70,16 @@ public OpenApiDocument Read(YamlDocument input, out OpenApiDiagnostic diagnostic
             // Validate the document
             if (_settings.RuleSet != null && _settings.RuleSet.Rules.Count > 0)
             {
-                var errors = document.Validate(_settings.RuleSet);
-                foreach (var item in errors)
+                var openApiErrors = document.Validate(_settings.RuleSet);
+                foreach (var item in openApiErrors.Where(e => e is OpenApiValidatorError))
                 {
                     diagnostic.Errors.Add(item);
                 }
+                foreach (var item in openApiErrors.Where(e => e is OpenApiValidatorWarning))
+                {
+                    diagnostic.Warnings.Add(item);
+                }
+
             }
 
             return document;
diff --git a/src/Microsoft.OpenApi/Extensions/OpenApiElementExtensions.cs b/src/Microsoft.OpenApi/Extensions/OpenApiElementExtensions.cs
@@ -2,6 +2,7 @@
 // Licensed under the MIT license. 
 
 using System.Collections.Generic;
+using System.Linq;
 using Microsoft.OpenApi.Interfaces;
 using Microsoft.OpenApi.Models;
 using Microsoft.OpenApi.Services;
@@ -25,7 +26,7 @@ public static IEnumerable<OpenApiError> Validate(this IOpenApiElement element, V
             var validator = new OpenApiValidator(ruleSet);
             var walker = new OpenApiWalker(validator);
             walker.Walk(element);
-            return validator.Errors;
+            return validator.Errors.Cast<OpenApiError>().Union(validator.Warnings);
         }
     }
 }
diff --git a/src/Microsoft.OpenApi/Validations/IValidationContext.cs b/src/Microsoft.OpenApi/Validations/IValidationContext.cs
@@ -14,6 +14,12 @@ public interface IValidationContext
         /// <param name="error">Error to register.</param>
         void AddError(OpenApiValidatorError error);
 
+        /// <summary>
+        /// Register a warning with the validation context.
+        /// </summary>
+        /// <param name="warning">Warning to register.</param>
+        void AddWarning(OpenApiValidatorWarning warning);
+
         /// <summary>
         /// Allow Rule to indicate validation error occured at a deeper context level.  
         /// </summary>
diff --git a/src/Microsoft.OpenApi/Validations/OpenApiValidatiorWarning.cs b/src/Microsoft.OpenApi/Validations/OpenApiValidatiorWarning.cs
@@ -0,0 +1,28 @@
+﻿using System;
+using System.Collections.Generic;
+using System.Text;
+using Microsoft.OpenApi.Exceptions;
+using Microsoft.OpenApi.Models;
+
+namespace Microsoft.OpenApi.Validations
+{    
+    /// <summary>
+     /// Warnings detected when validating an OpenAPI Element
+     /// </summary>
+    public class OpenApiValidatorWarning : OpenApiError
+    {
+        /// <summary>
+        /// Initializes the <see cref="OpenApiError"/> class.
+        /// </summary>
+        public OpenApiValidatorWarning(string ruleName, string pointer, string message) : base(pointer, message)
+        {
+            RuleName = ruleName;
+        }
+
+        /// <summary>
+        /// Name of rule that detected the error.
+        /// </summary>
+        public string RuleName { get; set; }
+    }
+
+}
diff --git a/src/Microsoft.OpenApi/Validations/OpenApiValidator.cs b/src/Microsoft.OpenApi/Validations/OpenApiValidator.cs
@@ -17,6 +17,7 @@ public class OpenApiValidator : OpenApiVisitorBase, IValidationContext
     {
         private readonly ValidationRuleSet _ruleSet;
         private readonly IList<OpenApiValidatorError> _errors = new List<OpenApiValidatorError>();
+        private readonly IList<OpenApiValidatorWarning> _warnings = new List<OpenApiValidatorWarning>();
 
         /// <summary>
         /// Create a vistor that will validate an OpenAPIDocument
@@ -38,6 +39,17 @@ public IEnumerable<OpenApiValidatorError> Errors
             }
         }
 
+        /// <summary>
+        /// Gets the validation warnings.
+        /// </summary>
+        public IEnumerable<OpenApiValidatorWarning> Warnings
+        {
+            get
+            {
+                return _warnings;
+            }
+        }
+
         /// <summary>
         /// Register an error with the validation context.
         /// </summary>
@@ -52,6 +64,19 @@ public void AddError(OpenApiValidatorError error)
             _errors.Add(error);
         }
 
+        /// <summary>
+        /// Register an error with the validation context.
+        /// </summary>
+        /// <param name="warning">Error to register.</param>
+        public void AddWarning(OpenApiValidatorWarning warning)
+        {
+            if (warning == null)
+            {
+                throw Error.ArgumentNull(nameof(warning));
+            }
+
+            _warnings.Add(warning);
+        }
 
         /// <summary>
         /// Execute validation rules against an <see cref="OpenApiDocument"/>
diff --git a/src/Microsoft.OpenApi/Validations/Rules/OpenApiHeaderRules.cs b/src/Microsoft.OpenApi/Validations/Rules/OpenApiHeaderRules.cs
@@ -10,6 +10,7 @@ namespace Microsoft.OpenApi.Validations.Rules
     /// <summary>
     /// The validation rules for <see cref="OpenApiHeader"/>.
     /// </summary>
+    //Removed from Default Rules as this is not a MUST in OpenAPI
     [OpenApiRule]
     public static class OpenApiHeaderRules
     {
diff --git a/src/Microsoft.OpenApi/Validations/Rules/OpenApiMediaTypeRules.cs b/src/Microsoft.OpenApi/Validations/Rules/OpenApiMediaTypeRules.cs
@@ -17,7 +17,7 @@ namespace Microsoft.OpenApi.Validations.Rules
     /// Future versions of the example parsers should not try an infer types.
     /// Example validation should be done as a separate post reading step so all schemas can be fully available.
     /// </remarks>
-    //[OpenApiRule]
+    [OpenApiRule]
     public static class OpenApiMediaTypeRules
     {
         /// <summary>
diff --git a/src/Microsoft.OpenApi/Validations/Rules/OpenApiSchemaRules.cs b/src/Microsoft.OpenApi/Validations/Rules/OpenApiSchemaRules.cs
@@ -11,6 +11,7 @@ namespace Microsoft.OpenApi.Validations.Rules
     /// <summary>
     /// The validation rules for <see cref="OpenApiSchema"/>.
     /// </summary>
+    
     [OpenApiRule]
     public static class OpenApiSchemaRules
     {
diff --git a/src/Microsoft.OpenApi/Validations/Rules/RuleHelpers.cs b/src/Microsoft.OpenApi/Validations/Rules/RuleHelpers.cs
@@ -77,7 +77,7 @@ public static void ValidateDataTypeMismatch(
                 // If value is not a string and also not an object, there is a data mismatch.
                 if (!(value is OpenApiObject))
                 {
-                    context.CreateError(
+                    context.CreateWarning(
                         ruleName,
                         DataTypeMismatchedErrorMessage);
                     return;
@@ -117,7 +117,7 @@ public static void ValidateDataTypeMismatch(
                 // If value is not a string and also not an array, there is a data mismatch.
                 if (!(value is OpenApiArray))
                 {
-                    context.CreateError(
+                    context.CreateWarning(
                         ruleName,
                         DataTypeMismatchedErrorMessage);
                     return;
@@ -141,7 +141,7 @@ public static void ValidateDataTypeMismatch(
             {
                 if (!(value is OpenApiInteger))
                 {
-                    context.CreateError(
+                    context.CreateWarning(
                         ruleName,
                         DataTypeMismatchedErrorMessage);
                 }
@@ -153,7 +153,7 @@ public static void ValidateDataTypeMismatch(
             {
                 if (!(value is OpenApiLong))
                 {
-                    context.CreateError(
+                    context.CreateWarning(
                        ruleName,
                        DataTypeMismatchedErrorMessage);
                 }
@@ -165,7 +165,7 @@ public static void ValidateDataTypeMismatch(
             {
                 if (!(value is OpenApiInteger))
                 {
-                    context.CreateError(
+                    context.CreateWarning(
                         ruleName,
                         DataTypeMismatchedErrorMessage);
                 }
@@ -177,7 +177,7 @@ public static void ValidateDataTypeMismatch(
             {
                 if (!(value is OpenApiFloat))
                 {
-                    context.CreateError(
+                    context.CreateWarning(
                         ruleName,
                         DataTypeMismatchedErrorMessage);
                 }
@@ -189,7 +189,7 @@ public static void ValidateDataTypeMismatch(
             {
                 if (!(value is OpenApiDouble))
                 {
-                    context.CreateError(
+                    context.CreateWarning(
                         ruleName,
                         DataTypeMismatchedErrorMessage);
                 }
@@ -201,7 +201,7 @@ public static void ValidateDataTypeMismatch(
             {
                 if (!(value is OpenApiDouble))
                 {
-                    context.CreateError(
+                    context.CreateWarning(
                         ruleName,
                         DataTypeMismatchedErrorMessage);
                 }
@@ -213,7 +213,7 @@ public static void ValidateDataTypeMismatch(
             {
                 if (!(value is OpenApiByte))
                 {
-                    context.CreateError(
+                    context.CreateWarning(
                         ruleName,
                         DataTypeMismatchedErrorMessage);
                 }
@@ -225,7 +225,7 @@ public static void ValidateDataTypeMismatch(
             {
                 if (!(value is OpenApiDate))
                 {
-                    context.CreateError(
+                    context.CreateWarning(
                         ruleName,
                         DataTypeMismatchedErrorMessage);
                 }
@@ -237,7 +237,7 @@ public static void ValidateDataTypeMismatch(
             {
                 if (!(value is OpenApiDateTime))
                 {
-                    context.CreateError(
+                    context.CreateWarning(
                         ruleName,
                         DataTypeMismatchedErrorMessage);
                 }
@@ -249,7 +249,7 @@ public static void ValidateDataTypeMismatch(
             {
                 if (!(value is OpenApiPassword))
                 {
-                    context.CreateError(
+                    context.CreateWarning(
                         ruleName,
                         DataTypeMismatchedErrorMessage);
                 }
@@ -261,7 +261,7 @@ public static void ValidateDataTypeMismatch(
             {
                 if (!(value is OpenApiString))
                 {
-                    context.CreateError(
+                    context.CreateWarning(
                         ruleName,
                         DataTypeMismatchedErrorMessage);
                 }
@@ -273,7 +273,7 @@ public static void ValidateDataTypeMismatch(
             {
                 if (!(value is OpenApiBoolean))
                 {
-                    context.CreateError(
+                    context.CreateWarning(
                         ruleName,
                         DataTypeMismatchedErrorMessage);
                 }
diff --git a/src/Microsoft.OpenApi/Validations/ValidationExtensions.cs b/src/Microsoft.OpenApi/Validations/ValidationExtensions.cs
@@ -23,5 +23,15 @@ public static void CreateError(this IValidationContext context, string ruleName,
             OpenApiValidatorError error = new OpenApiValidatorError(ruleName, context.PathString, message);
             context.AddError(error);
         }
+
+        /// <summary>
+        /// Helper method to simplify validation rules
+        /// </summary>
+        public static void CreateWarning(this IValidationContext context, string ruleName, string message)
+        {
+            OpenApiValidatorWarning warning = new OpenApiValidatorWarning(ruleName, context.PathString, message);
+            context.AddWarning(warning);
+        }
+
     }
 }
diff --git a/test/Microsoft.OpenApi.Tests/PublicApi/PublicApi.approved.txt b/test/Microsoft.OpenApi.Tests/PublicApi/PublicApi.approved.txt
@@ -1086,14 +1086,17 @@ namespace Microsoft.OpenApi.Validations
     {
         string PathString { get; }
         void AddError(Microsoft.OpenApi.Validations.OpenApiValidatorError error);
+        void AddWarning(Microsoft.OpenApi.Validations.OpenApiValidatorWarning warning);
         void Enter(string segment);
         void Exit();
     }
     public class OpenApiValidator : Microsoft.OpenApi.Services.OpenApiVisitorBase, Microsoft.OpenApi.Validations.IValidationContext
     {
         public OpenApiValidator(Microsoft.OpenApi.Validations.ValidationRuleSet ruleSet) { }
         public System.Collections.Generic.IEnumerable<Microsoft.OpenApi.Validations.OpenApiValidatorError> Errors { get; }
+        public System.Collections.Generic.IEnumerable<Microsoft.OpenApi.Validations.OpenApiValidatorWarning> Warnings { get; }
         public void AddError(Microsoft.OpenApi.Validations.OpenApiValidatorError error) { }
+        public void AddWarning(Microsoft.OpenApi.Validations.OpenApiValidatorWarning warning) { }
         public override void Visit(Microsoft.OpenApi.Interfaces.IOpenApiExtensible item) { }
         public override void Visit(Microsoft.OpenApi.Interfaces.IOpenApiExtension item) { }
         public override void Visit(Microsoft.OpenApi.Models.OpenApiCallback item) { }
@@ -1120,9 +1123,15 @@ namespace Microsoft.OpenApi.Validations
         public OpenApiValidatorError(string ruleName, string pointer, string message) { }
         public string RuleName { get; set; }
     }
+    public class OpenApiValidatorWarning : Microsoft.OpenApi.Models.OpenApiError
+    {
+        public OpenApiValidatorWarning(string ruleName, string pointer, string message) { }
+        public string RuleName { get; set; }
+    }
     public static class ValidationContextExtensions
     {
         public static void CreateError(this Microsoft.OpenApi.Validations.IValidationContext context, string ruleName, string message) { }
+        public static void CreateWarning(this Microsoft.OpenApi.Validations.IValidationContext context, string ruleName, string message) { }
     }
     public abstract class ValidationRule
     {
@@ -1189,6 +1198,7 @@ namespace Microsoft.OpenApi.Validations.Rules
     {
         public static Microsoft.OpenApi.Validations.ValidationRule<Microsoft.OpenApi.Models.OpenApiLicense> LicenseRequiredFields { get; }
     }
+    [Microsoft.OpenApi.Validations.Rules.OpenApiRule]
     public static class OpenApiMediaTypeRules
     {
         public static Microsoft.OpenApi.Validations.ValidationRule<Microsoft.OpenApi.Models.OpenApiMediaType> MediaTypeMismatchedDataType { get; }
diff --git a/test/Microsoft.OpenApi.Tests/Validations/OpenApiHeaderValidationTests.cs b/test/Microsoft.OpenApi.Tests/Validations/OpenApiHeaderValidationTests.cs
diff --git a/test/Microsoft.OpenApi.Tests/Validations/OpenApiMediaTypeValidationTests.cs b/test/Microsoft.OpenApi.Tests/Validations/OpenApiMediaTypeValidationTests.cs
diff --git a/test/Microsoft.OpenApi.Tests/Validations/OpenApiParameterValidationTests.cs b/test/Microsoft.OpenApi.Tests/Validations/OpenApiParameterValidationTests.cs
diff --git a/test/Microsoft.OpenApi.Tests/Validations/OpenApiSchemaValidationTests.cs b/test/Microsoft.OpenApi.Tests/Validations/OpenApiSchemaValidationTests.cs
diff --git a/test/Microsoft.OpenApi.Tests/Validations/ValidationRuleSetTests.cs b/test/Microsoft.OpenApi.Tests/Validations/ValidationRuleSetTests.cs

Original file line number	Diff line number	Diff line change
`@@ -2,6 +2,7 @@`
`2`	`2`	`// Licensed under the MIT license.`
`3`	`3`
`4`	`4`	`using System.Collections.Generic;`
	`5`	`+using System.Linq;`
`5`	`6`	`using Microsoft.OpenApi.Interfaces;`
`6`	`7`	`using Microsoft.OpenApi.Models;`
`7`	`8`	`using Microsoft.OpenApi.Services;`
`@@ -25,7 +26,7 @@ public static IEnumerable<OpenApiError> Validate(this IOpenApiElement element, V`
`25`	`26`	`var validator = new OpenApiValidator(ruleSet);`
`26`	`27`	`var walker = new OpenApiWalker(validator);`
`27`	`28`	`walker.Walk(element);`
`28`		`- return validator.Errors;`
	`29`	`+ return validator.Errors.Cast<OpenApiError>().Union(validator.Warnings);`
`29`	`30`	`}`
`30`	`31`	`}`
`31`	`32`	`}`
Original file line number	Diff line number	Diff line change
`@@ -10,6 +10,7 @@ namespace Microsoft.OpenApi.Validations.Rules`
`10`	`10`	`/// <summary>`
`11`	`11`	`/// The validation rules for <see cref="OpenApiHeader"/>.`
`12`	`12`	`/// </summary>`
	`13`	`+ //Removed from Default Rules as this is not a MUST in OpenAPI`
`13`	`14`	`[OpenApiRule]`
`14`	`15`	`public static class OpenApiHeaderRules`
`15`	`16`	`{`
Original file line number	Diff line number	Diff line change
`@@ -17,7 +17,7 @@ namespace Microsoft.OpenApi.Validations.Rules`
`17`	`17`	`/// Future versions of the example parsers should not try an infer types.`
`18`	`18`	`/// Example validation should be done as a separate post reading step so all schemas can be fully available.`
`19`	`19`	`/// </remarks>`
`20`		`- //[OpenApiRule]`
	`20`	`+ [OpenApiRule]`
`21`	`21`	`public static class OpenApiMediaTypeRules`
`22`	`22`	`{`
`23`	`23`	`/// <summary>`
Original file line number	Diff line number	Diff line change
`@@ -11,6 +11,7 @@ namespace Microsoft.OpenApi.Validations.Rules`
`11`	`11`	`/// <summary>`
`12`	`12`	`/// The validation rules for <see cref="OpenApiSchema"/>.`
`13`	`13`	`/// </summary>`
	`14`	`+`
`14`	`15`	`[OpenApiRule]`
`15`	`16`	`public static class OpenApiSchemaRules`
`16`	`17`	`{`
Original file line number	Diff line number	Diff line change
`@@ -77,7 +77,7 @@ public static void ValidateDataTypeMismatch(`
`77`	`77`	`// If value is not a string and also not an object, there is a data mismatch.`
`78`	`78`	`if (!(value is OpenApiObject))`
`79`	`79`	`{`
`80`		`- context.CreateError(`
	`80`	`+ context.CreateWarning(`
`81`	`81`	`ruleName,`
`82`	`82`	`DataTypeMismatchedErrorMessage);`
`83`	`83`	`return;`
`@@ -117,7 +117,7 @@ public static void ValidateDataTypeMismatch(`
`117`	`117`	`// If value is not a string and also not an array, there is a data mismatch.`
`118`	`118`	`if (!(value is OpenApiArray))`
`119`	`119`	`{`
`120`		`- context.CreateError(`
	`120`	`+ context.CreateWarning(`
`121`	`121`	`ruleName,`
`122`	`122`	`DataTypeMismatchedErrorMessage);`
`123`	`123`	`return;`
`@@ -141,7 +141,7 @@ public static void ValidateDataTypeMismatch(`
`141`	`141`	`{`
`142`	`142`	`if (!(value is OpenApiInteger))`
`143`	`143`	`{`
`144`		`- context.CreateError(`
	`144`	`+ context.CreateWarning(`
`145`	`145`	`ruleName,`
`146`	`146`	`DataTypeMismatchedErrorMessage);`
`147`	`147`	`}`
`@@ -153,7 +153,7 @@ public static void ValidateDataTypeMismatch(`
`153`	`153`	`{`
`154`	`154`	`if (!(value is OpenApiLong))`
`155`	`155`	`{`
`156`		`- context.CreateError(`
	`156`	`+ context.CreateWarning(`
`157`	`157`	`ruleName,`
`158`	`158`	`DataTypeMismatchedErrorMessage);`
`159`	`159`	`}`
`@@ -165,7 +165,7 @@ public static void ValidateDataTypeMismatch(`
`165`	`165`	`{`
`166`	`166`	`if (!(value is OpenApiInteger))`
`167`	`167`	`{`
`168`		`- context.CreateError(`
	`168`	`+ context.CreateWarning(`
`169`	`169`	`ruleName,`
`170`	`170`	`DataTypeMismatchedErrorMessage);`
`171`	`171`	`}`
`@@ -177,7 +177,7 @@ public static void ValidateDataTypeMismatch(`
`177`	`177`	`{`
`178`	`178`	`if (!(value is OpenApiFloat))`
`179`	`179`	`{`
`180`		`- context.CreateError(`
	`180`	`+ context.CreateWarning(`
`181`	`181`	`ruleName,`
`182`	`182`	`DataTypeMismatchedErrorMessage);`
`183`	`183`	`}`
`@@ -189,7 +189,7 @@ public static void ValidateDataTypeMismatch(`
`189`	`189`	`{`
`190`	`190`	`if (!(value is OpenApiDouble))`
`191`	`191`	`{`
`192`		`- context.CreateError(`
	`192`	`+ context.CreateWarning(`
`193`	`193`	`ruleName,`
`194`	`194`	`DataTypeMismatchedErrorMessage);`
`195`	`195`	`}`
`@@ -201,7 +201,7 @@ public static void ValidateDataTypeMismatch(`
`201`	`201`	`{`
`202`	`202`	`if (!(value is OpenApiDouble))`
`203`	`203`	`{`
`204`		`- context.CreateError(`
	`204`	`+ context.CreateWarning(`
`205`	`205`	`ruleName,`
`206`	`206`	`DataTypeMismatchedErrorMessage);`
`207`	`207`	`}`
`@@ -213,7 +213,7 @@ public static void ValidateDataTypeMismatch(`
`213`	`213`	`{`
`214`	`214`	`if (!(value is OpenApiByte))`
`215`	`215`	`{`
`216`		`- context.CreateError(`
	`216`	`+ context.CreateWarning(`
`217`	`217`	`ruleName,`
`218`	`218`	`DataTypeMismatchedErrorMessage);`
`219`	`219`	`}`
`@@ -225,7 +225,7 @@ public static void ValidateDataTypeMismatch(`
`225`	`225`	`{`
`226`	`226`	`if (!(value is OpenApiDate))`
`227`	`227`	`{`
`228`		`- context.CreateError(`
	`228`	`+ context.CreateWarning(`
`229`	`229`	`ruleName,`
`230`	`230`	`DataTypeMismatchedErrorMessage);`
`231`	`231`	`}`
`@@ -237,7 +237,7 @@ public static void ValidateDataTypeMismatch(`
`237`	`237`	`{`
`238`	`238`	`if (!(value is OpenApiDateTime))`
`239`	`239`	`{`
`240`		`- context.CreateError(`
	`240`	`+ context.CreateWarning(`
`241`	`241`	`ruleName,`
`242`	`242`	`DataTypeMismatchedErrorMessage);`
`243`	`243`	`}`
`@@ -249,7 +249,7 @@ public static void ValidateDataTypeMismatch(`
`249`	`249`	`{`
`250`	`250`	`if (!(value is OpenApiPassword))`
`251`	`251`	`{`
`252`		`- context.CreateError(`
	`252`	`+ context.CreateWarning(`
`253`	`253`	`ruleName,`
`254`	`254`	`DataTypeMismatchedErrorMessage);`
`255`	`255`	`}`
`@@ -261,7 +261,7 @@ public static void ValidateDataTypeMismatch(`
`261`	`261`	`{`
`262`	`262`	`if (!(value is OpenApiString))`
`263`	`263`	`{`
`264`		`- context.CreateError(`
	`264`	`+ context.CreateWarning(`
`265`	`265`	`ruleName,`
`266`	`266`	`DataTypeMismatchedErrorMessage);`
`267`	`267`	`}`
`@@ -273,7 +273,7 @@ public static void ValidateDataTypeMismatch(`
`273`	`273`	`{`
`274`	`274`	`if (!(value is OpenApiBoolean))`
`275`	`275`	`{`
`276`		`- context.CreateError(`
	`276`	`+ context.CreateWarning(`
`277`	`277`	`ruleName,`
`278`	`278`	`DataTypeMismatchedErrorMessage);`
`279`	`279`	`}`