Cleaning up errors

darrelmiller · darrelmiller · commit 7c7a32a3d6a1 · 2018-04-02T15:36:40.000-04:00
diff --git a/src/Microsoft.OpenApi/Models/OpenApiError.cs b/src/Microsoft.OpenApi/Models/OpenApiError.cs
@@ -75,6 +75,11 @@ public OpenApiError(ErrorReason reason, string pointer, string message)
         /// </summary>
         public string Pointer { get; set; }
 
+        /// <summary>
+        /// Name of rule that detected the error.
+        /// </summary>
+        public string RuleName { get; set; }
+
         /// <summary>
         /// Gets the string representation of <see cref="OpenApiError"/>.
         /// </summary>
diff --git a/src/Microsoft.OpenApi/Validations/Rules/OpenApiComponentsRules.cs b/src/Microsoft.OpenApi/Validations/Rules/OpenApiComponentsRules.cs
@@ -57,9 +57,8 @@ private static void ValidateKeys(IValidationContext context, IEnumerable<string>
             {
                 if (!KeyRegex.IsMatch(key))
                 {
-                    OpenApiError error = new OpenApiError(ErrorReason.Format, context.PathString,
+                    context.CreateError(nameof(KeyMustBeRegularExpression), ErrorReason.Format, 
                         string.Format(SRResource.Validation_ComponentsKeyMustMatchRegularExpr, key, component, KeyRegex.ToString()));
-                    context.AddError(error);
                 }
             }
         }
diff --git a/src/Microsoft.OpenApi/Validations/Rules/OpenApiContactRules.cs b/src/Microsoft.OpenApi/Validations/Rules/OpenApiContactRules.cs
@@ -26,9 +26,8 @@ public static class OpenApiContactRules
                     {
                         if (!item.Email.IsEmailAddress())
                         {
-                            OpenApiError error = new OpenApiError(ErrorReason.Format, context.PathString,
+                            context.CreateError(nameof(EmailMustBeEmailFormat), ErrorReason.Format, 
                                 String.Format(SRResource.Validation_StringMustBeEmailAddress, item.Email));
-                            context.AddError(error);
                         }
                     }
                     context.Exit();
diff --git a/src/Microsoft.OpenApi/Validations/Rules/OpenApiDocumentRules.cs b/src/Microsoft.OpenApi/Validations/Rules/OpenApiDocumentRules.cs
@@ -16,27 +16,25 @@ public static class OpenApiDocumentRules
         /// <summary>
         /// The Info field is required.
         /// </summary>
-        public static ValidationRule<OpenApiDocument> FieldIsRequired =>
+        public static ValidationRule<OpenApiDocument> OpenApiDocumentFieldIsMissing =>
             new ValidationRule<OpenApiDocument>(
                 (context, item) =>
                 {
                     // info
                     context.Enter("info");
                     if (item.Info == null)
                     {
-                        OpenApiError error = new OpenApiError(ErrorReason.Required, context.PathString,
+                        context.CreateError(nameof(OpenApiDocumentFieldIsMissing),ErrorReason.Required, 
                             String.Format(SRResource.Validation_FieldIsRequired, "info", "document"));
-                        context.AddError(error);
                     }
                     context.Exit();
 
                     // paths
                     context.Enter("paths");
                     if (item.Paths == null)
                     {
-                        OpenApiError error = new OpenApiError(ErrorReason.Required, context.PathString,
+                        context.CreateError(nameof(OpenApiDocumentFieldIsMissing), ErrorReason.Required, 
                             String.Format(SRResource.Validation_FieldIsRequired, "paths", "document"));
-                        context.AddError(error);
                     }
                     context.Exit();
                 });
diff --git a/src/Microsoft.OpenApi/Validations/Rules/OpenApiExtensionRules.cs b/src/Microsoft.OpenApi/Validations/Rules/OpenApiExtensionRules.cs
@@ -26,9 +26,8 @@ public static class OpenApiExtensibleRules
                     {
                         if (!extensible.Key.StartsWith("x-"))
                         {
-                            OpenApiError error = new OpenApiError(ErrorReason.Format, context.PathString,
+                            context.CreateError(nameof(ExtensionNameMustStartWithXDash),ErrorReason.Format, 
                                 String.Format(SRResource.Validation_ExtensionNameMustBeginWithXDash, extensible.Key, context.PathString));
-                            context.AddError(error);
                         }
                     }
                     context.Exit();
diff --git a/src/Microsoft.OpenApi/Validations/Rules/OpenApiExternalDocsRules.cs b/src/Microsoft.OpenApi/Validations/Rules/OpenApiExternalDocsRules.cs
@@ -16,17 +16,16 @@ public static class OpenApiExternalDocsRules
         /// <summary>
         /// Validate the field is required.
         /// </summary>
-        public static ValidationRule<OpenApiExternalDocs> FieldIsRequired =>
+        public static ValidationRule<OpenApiExternalDocs> UrlIsRequired =>
             new ValidationRule<OpenApiExternalDocs>(
                 (context, item) =>
                 {
                     // url
                     context.Enter("url");
                     if (item.Url == null)
                     {
-                        OpenApiError error = new OpenApiError(ErrorReason.Required, context.PathString,
+                        context.CreateError(nameof(UrlIsRequired),ErrorReason.Required, 
                             String.Format(SRResource.Validation_FieldIsRequired, "url", "External Documentation"));
-                        context.AddError(error);
                     }
                     context.Exit();
                 });
diff --git a/src/Microsoft.OpenApi/Validations/Rules/OpenApiInfoRules.cs b/src/Microsoft.OpenApi/Validations/Rules/OpenApiInfoRules.cs
@@ -16,28 +16,26 @@ public static class OpenApiInfoRules
         /// <summary>
         /// Validate the field is required.
         /// </summary>
-        public static ValidationRule<OpenApiInfo> FieldIsRequired =>
+        public static ValidationRule<OpenApiInfo> InfoRequiredFields =>
             new ValidationRule<OpenApiInfo>(
                 (context, item) =>
                 {
 
                     // title
                     context.Enter("title");
-                    if (String.IsNullOrEmpty(item.Title))
+                    if (item.Title == null)
                     {
-                        OpenApiError error = new OpenApiError(ErrorReason.Required, context.PathString,
+                        context.CreateError(nameof(InfoRequiredFields),ErrorReason.Required, 
                             String.Format(SRResource.Validation_FieldIsRequired, "title", "info"));
-                        context.AddError(error);
                     }
                     context.Exit();
 
                     // version
                     context.Enter("version");
-                    if (String.IsNullOrEmpty(item.Version))
+                    if (item.Version == null)
                     {
-                        OpenApiError error = new OpenApiError(ErrorReason.Required, context.PathString,
+                        context.CreateError(nameof(InfoRequiredFields), ErrorReason.Required, 
                             String.Format(SRResource.Validation_FieldIsRequired, "version", "info"));
-                        context.AddError(error);
                     }
                     context.Exit();
 
diff --git a/src/Microsoft.OpenApi/Validations/Rules/OpenApiLicenseRules.cs b/src/Microsoft.OpenApi/Validations/Rules/OpenApiLicenseRules.cs
@@ -16,16 +16,15 @@ public static class OpenApiLicenseRules
         /// <summary>
         /// REQUIRED.
         /// </summary>
-        public static ValidationRule<OpenApiLicense> FieldIsRequired =>
+        public static ValidationRule<OpenApiLicense> LicenseRequiredFields =>
             new ValidationRule<OpenApiLicense>(
                 (context, license) =>
                 {
                     context.Enter("name");
                     if (String.IsNullOrEmpty(license.Name))
                     {
-                        OpenApiError error = new OpenApiError(ErrorReason.Required, context.PathString,
+                        context.CreateError(nameof(LicenseRequiredFields),ErrorReason.Required,
                             String.Format(SRResource.Validation_FieldIsRequired, "name", "license"));
-                        context.AddError(error);
                     }
                     context.Exit();
                 });
diff --git a/src/Microsoft.OpenApi/Validations/Rules/OpenApiOAuthFlowRules.cs b/src/Microsoft.OpenApi/Validations/Rules/OpenApiOAuthFlowRules.cs
@@ -16,37 +16,34 @@ public static class OpenApiOAuthFlowRules
         /// <summary>
         /// Validate the field is required.
         /// </summary>
-        public static ValidationRule<OpenApiOAuthFlow> FieldIsRequired =>
+        public static ValidationRule<OpenApiOAuthFlow> OAuthFlowRequiredFields =>
             new ValidationRule<OpenApiOAuthFlow>(
                 (context, flow) =>
                 {
                     // authorizationUrl
                     context.Enter("authorizationUrl");
                     if (flow.AuthorizationUrl == null)
                     {
-                        OpenApiError error = new OpenApiError(ErrorReason.Required, context.PathString,
+                        context.CreateError(nameof(OAuthFlowRequiredFields),ErrorReason.Required,
                             String.Format(SRResource.Validation_FieldIsRequired, "authorizationUrl", "OAuth Flow"));
-                        context.AddError(error);
                     }
                     context.Exit();
 
                     // tokenUrl
                     context.Enter("tokenUrl");
                     if (flow.TokenUrl == null)
                     {
-                        OpenApiError error = new OpenApiError(ErrorReason.Required, context.PathString,
+                        context.CreateError(nameof(OAuthFlowRequiredFields), ErrorReason.Required,
                             String.Format(SRResource.Validation_FieldIsRequired, "tokenUrl", "OAuth Flow"));
-                        context.AddError(error);
                     }
                     context.Exit();
 
                     // scopes
                     context.Enter("scopes");
                     if (flow.Scopes == null)
                     {
-                        OpenApiError error = new OpenApiError(ErrorReason.Required, context.PathString,
+                        context.CreateError(nameof(OAuthFlowRequiredFields), ErrorReason.Required,
                             String.Format(SRResource.Validation_FieldIsRequired, "scopes", "OAuth Flow"));
-                        context.AddError(error);
                     }
                     context.Exit();
                 });
diff --git a/src/Microsoft.OpenApi/Validations/Rules/OpenApiPathsRules.cs b/src/Microsoft.OpenApi/Validations/Rules/OpenApiPathsRules.cs
@@ -32,9 +32,8 @@ public static class OpenApiPathsRules
 
                         if (!pathName.StartsWith("/"))
                         {
-                            OpenApiError error = new OpenApiError(ErrorReason.Format, context.PathString,
+                            context.CreateError(nameof(PathNameMustBeginWithSlash),ErrorReason.Format,
                                 string.Format(SRResource.Validation_PathItemMustBeginWithSlash, pathName));
-                            context.AddError(error);
                         }
 
                         context.Exit();
diff --git a/src/Microsoft.OpenApi/Validations/Rules/OpenApiResponseRules.cs b/src/Microsoft.OpenApi/Validations/Rules/OpenApiResponseRules.cs
@@ -16,17 +16,16 @@ public static class OpenApiResponseRules
         /// <summary>
         /// Validate the field is required.
         /// </summary>
-        public static ValidationRule<OpenApiResponse> FieldIsRequired =>
+        public static ValidationRule<OpenApiResponse> ResponseRequiredFields =>
             new ValidationRule<OpenApiResponse>(
                 (context, response) =>
                 {
                     // description
                     context.Enter("description");
                     if (String.IsNullOrEmpty(response.Description))
                     {
-                        OpenApiError error = new OpenApiError(ErrorReason.Required, context.PathString,
+                        context.CreateError(nameof(ResponseRequiredFields),ErrorReason.Required,
                             String.Format(SRResource.Validation_FieldIsRequired, "description", "response"));
-                        context.AddError(error);
                     }
                     context.Exit();
                 });
diff --git a/src/Microsoft.OpenApi/Validations/Rules/OpenApiResponsesRules.cs b/src/Microsoft.OpenApi/Validations/Rules/OpenApiResponsesRules.cs
@@ -22,11 +22,8 @@ public static class OpenApiResponsesRules
                 {
                     if (!responses.Keys.Any())
                     {
-                        context.AddError(
-                            new OpenApiError(
-                                ErrorReason.Required,
-                                context.PathString,
-                                "Responses must contain at least one response"));
+                        context.CreateError(nameof(ResponsesMustContainAtLeastOneResponse),ErrorReason.Required,
+                                "Responses must contain at least one response");
                     }
                 });
 
diff --git a/src/Microsoft.OpenApi/Validations/Rules/OpenApiServerRules.cs b/src/Microsoft.OpenApi/Validations/Rules/OpenApiServerRules.cs
@@ -16,16 +16,15 @@ public static class OpenApiServerRules
         /// <summary>
         /// Validate the field is required.
         /// </summary>
-        public static ValidationRule<OpenApiServer> FieldIsRequired =>
+        public static ValidationRule<OpenApiServer> ServerRequiredFields =>
             new ValidationRule<OpenApiServer>(
                 (context, server) =>
                 {
                     context.Enter("url");
                     if (String.IsNullOrEmpty(server.Url))
                     {
-                        OpenApiError error = new OpenApiError(ErrorReason.Required, context.PathString,
+                        context.CreateError(nameof(ServerRequiredFields),ErrorReason.Required,
                             String.Format(SRResource.Validation_FieldIsRequired, "url", "server"));
-                        context.AddError(error);
                     }
                     context.Exit();
                 });
diff --git a/src/Microsoft.OpenApi/Validations/Rules/OpenApiTagRules.cs b/src/Microsoft.OpenApi/Validations/Rules/OpenApiTagRules.cs
@@ -16,16 +16,15 @@ public static class OpenApiTagRules
         /// <summary>
         /// Validate the field is required.
         /// </summary>
-        public static ValidationRule<OpenApiTag> FieldIsRequired =>
+        public static ValidationRule<OpenApiTag> TagRequiredFields =>
             new ValidationRule<OpenApiTag>(
                 (context, tag) =>
                 {
                     context.Enter("name");
                     if (String.IsNullOrEmpty(tag.Name))
                     {
-                        OpenApiError error = new OpenApiError(ErrorReason.Required, context.PathString,
+                        context.CreateError(nameof(TagRequiredFields),ErrorReason.Required,
                             String.Format(SRResource.Validation_FieldIsRequired, "name", "tag"));
-                        context.AddError(error);
                     }
                     context.Exit();
                 });
diff --git a/src/Microsoft.OpenApi/Validations/ValidationExtensions.cs b/src/Microsoft.OpenApi/Validations/ValidationExtensions.cs
@@ -0,0 +1,28 @@
+﻿// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT license. 
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Microsoft.OpenApi.Models;
+
+namespace Microsoft.OpenApi.Validations
+{
+    /// <summary>
+    /// Helper methods to simplify creating validation rules
+    /// </summary>
+    public static class ValidationExtensions
+    {
+        /// <summary>
+        /// Helper method to simplify validation rules
+        /// </summary>
+        public static void CreateError(this IValidationContext context, string ruleName, ErrorReason reason, string message)
+        {
+            OpenApiError error = new OpenApiError(reason, context.PathString,message);
+            error.RuleName = ruleName;
+            context.AddError(error);
+        }
+    }
+}
diff --git a/test/Microsoft.OpenApi.Readers.Tests/V3Tests/OpenApiDocumentTests.cs b/test/Microsoft.OpenApi.Readers.Tests/V3Tests/OpenApiDocumentTests.cs
@@ -108,6 +108,9 @@ public void ParseBrokenMinimalDocumentShouldYieldExpectedDiagnostic()
                         Errors =
                         {
                             new OpenApiError("#/info/title", "The field 'title' in 'info' object is REQUIRED.")
+                            {
+                                RuleName = "InfoRequiredFields"
+                            }
                         },
                         SpecificationVersion = OpenApiSpecVersion.OpenApi3_0
                     });
diff --git a/test/Microsoft.OpenApi.Tests/Services/OpenApiValidatorTests.cs b/test/Microsoft.OpenApi.Tests/Services/OpenApiValidatorTests.cs
@@ -59,6 +59,9 @@ public void ResponseMustHaveADescription()
                     {
                         new OpenApiError(ErrorReason.Required, "#/paths/~1test/get/responses/200/description",
                             String.Format(SRResource.Validation_FieldIsRequired, "description", "response"))
+                        {
+                            RuleName = "ResponseRequiredFields"
+                        }
         });
         }
 
@@ -91,6 +94,9 @@ public void ServersShouldBeReferencedByIndex()
                     {
                         new OpenApiError(ErrorReason.Required, "#/servers/1/url",
                             String.Format(SRResource.Validation_FieldIsRequired, "url", "server"))
+                        {
+                            RuleName = "ServerRequiredFields"
+                        }
         });
         }
 

Original file line number	Diff line number	Diff line change
`@@ -57,9 +57,8 @@ private static void ValidateKeys(IValidationContext context, IEnumerable<string>`
`57`	`57`	`{`
`58`	`58`	`if (!KeyRegex.IsMatch(key))`
`59`	`59`	`{`
`60`		`- OpenApiError error = new OpenApiError(ErrorReason.Format, context.PathString,`
	`60`	`+ context.CreateError(nameof(KeyMustBeRegularExpression), ErrorReason.Format,`
`61`	`61`	`string.Format(SRResource.Validation_ComponentsKeyMustMatchRegularExpr, key, component, KeyRegex.ToString()));`
`62`		`- context.AddError(error);`
`63`	`62`	`}`
`64`	`63`	`}`
`65`	`64`	`}`
Original file line number	Diff line number	Diff line change
`@@ -26,9 +26,8 @@ public static class OpenApiContactRules`
`26`	`26`	`{`
`27`	`27`	`if (!item.Email.IsEmailAddress())`
`28`	`28`	`{`
`29`		`- OpenApiError error = new OpenApiError(ErrorReason.Format, context.PathString,`
	`29`	`+ context.CreateError(nameof(EmailMustBeEmailFormat), ErrorReason.Format,`
`30`	`30`	`String.Format(SRResource.Validation_StringMustBeEmailAddress, item.Email));`
`31`		`- context.AddError(error);`
`32`	`31`	`}`
`33`	`32`	`}`
`34`	`33`	`context.Exit();`
Original file line number	Diff line number	Diff line change
`@@ -16,16 +16,15 @@ public static class OpenApiLicenseRules`
`16`	`16`	`/// <summary>`
`17`	`17`	`/// REQUIRED.`
`18`	`18`	`/// </summary>`
`19`		`- public static ValidationRule<OpenApiLicense> FieldIsRequired =>`
	`19`	`+ public static ValidationRule<OpenApiLicense> LicenseRequiredFields =>`
`20`	`20`	`new ValidationRule<OpenApiLicense>(`
`21`	`21`	`(context, license) =>`
`22`	`22`	`{`
`23`	`23`	`context.Enter("name");`
`24`	`24`	`if (String.IsNullOrEmpty(license.Name))`
`25`	`25`	`{`
`26`		`- OpenApiError error = new OpenApiError(ErrorReason.Required, context.PathString,`
	`26`	`+ context.CreateError(nameof(LicenseRequiredFields),ErrorReason.Required,`
`27`	`27`	`String.Format(SRResource.Validation_FieldIsRequired, "name", "license"));`
`28`		`- context.AddError(error);`
`29`	`28`	`}`
`30`	`29`	`context.Exit();`
`31`	`30`	`});`
Original file line number	Diff line number	Diff line change
`@@ -32,9 +32,8 @@ public static class OpenApiPathsRules`
`32`	`32`
`33`	`33`	`if (!pathName.StartsWith("/"))`
`34`	`34`	`{`
`35`		`- OpenApiError error = new OpenApiError(ErrorReason.Format, context.PathString,`
	`35`	`+ context.CreateError(nameof(PathNameMustBeginWithSlash),ErrorReason.Format,`
`36`	`36`	`string.Format(SRResource.Validation_PathItemMustBeginWithSlash, pathName));`
`37`		`- context.AddError(error);`
`38`	`37`	`}`
`39`	`38`
`40`	`39`	`context.Exit();`