added validation & renabled OpenApiPaths validators

Author: Fabian Niederer

src/Microsoft.OpenApi/Properties/SRResource.Designer.cs

@@ -207,6 +207,9 @@
   <data name="Validation_PathItemMustBeginWithSlash" xml:space="preserve">
     <value>The path item name '{0}' MUST begin with a slash.</value>
   </data>
+  <data name="Validation_PathSignatureMustBeUnique" xml:space="preserve">
+    <value>The path signature '{0}' MUST begin be unique.</value>
+  </data>
   <data name="Validation_RuleAddTwice" xml:space="preserve">
     <value>The same rule cannot be in the same rule set twice.</value>
   </data>

src/Microsoft.OpenApi/Properties/SRResource.resx

@@ -219,6 +219,7 @@ internal void Walk(OpenApiPaths paths)
                     _visitor.CurrentKeys.Path = null;
                 }
             }
+
         }
 
         /// <summary>
@@ -1036,6 +1037,7 @@ internal void Walk(IOpenApiElement element)
                 case OpenApiOAuthFlow e: Walk(e); break;
                 case OpenApiOperation e: Walk(e); break;
                 case OpenApiParameter e: Walk(e); break;
+                case OpenApiPaths e: Walk(e); break;
                 case OpenApiRequestBody e: Walk(e); break;
                 case OpenApiResponse e: Walk(e); break;
                 case OpenApiSchema e: Walk(e); break;

src/Microsoft.OpenApi/Services/OpenApiWalker.cs

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

src/Microsoft.OpenApi/Validations/OpenApiValidator.cs

@@ -1,6 +1,8 @@
 // Copyright (c) Microsoft Corporation. All rights reserved.
 // Licensed under the MIT license. 
 
+using System.Collections.Generic;
+using System.Text.RegularExpressions;
 using Microsoft.OpenApi.Models;
 using Microsoft.OpenApi.Properties;
 
@@ -34,6 +36,30 @@ public static class OpenApiPathsRules
                     }
                 });
 
+        /// <summary>
+        /// A relative path to an individual endpoint. The field name MUST begin with a slash.
+        /// </summary>
+        public static ValidationRule<OpenApiPaths> PathMustBeUnique =>
+            new ValidationRule<OpenApiPaths>(
+                (context, item) =>
+                {
+                    const string regexPath = "\\{([^/]+)\\}";
+                    var hashSet = new HashSet<string>();
+
+                    foreach (var path in item.Keys)
+                    {
+                        context.Enter(path);
+
+                        var pathSignature = Regex.Replace(path, regexPath, "{}");
+                        
+                        if (!hashSet.Add(pathSignature))
+                            context.CreateError(nameof(PathMustBeUnique),
+                                string.Format(SRResource.Validation_PathSignatureMustBeUnique, pathSignature));
+
+                        context.Exit();
+                    }
+                });
+
         // add more rules
     }
 }

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

@@ -0,0 +1,49 @@
+using System.Linq;
+using FluentAssertions;
+using Microsoft.OpenApi.Extensions;
+using Microsoft.OpenApi.Models;
+using Microsoft.OpenApi.Properties;
+using Xunit;
+
+namespace Microsoft.OpenApi.Validations.Tests
+{
+    public class OpenApiPathsValidationTests
+    {
+        [Fact]
+        public void ValidatePathsMustBeginWithSlash()
+        {
+            // Arrange
+            var error = string.Format(SRResource.Validation_PathItemMustBeginWithSlash, "pets/{petId}");
+            var paths = new OpenApiPaths
+            {
+                {"pets/{petId}",new OpenApiPathItem() }
+            };
+
+            // Act
+            var errors = paths.Validate(ValidationRuleSet.GetDefaultRuleSet());
+
+            // Assert
+            errors.Should().NotBeEmpty();
+            errors.Select(e => e.Message).Should().BeEquivalentTo(error);
+        }
+
+        [Fact]
+        public void ValidatePathsAreUnique()
+        {
+            // Arrange
+            var error = string.Format(SRResource.Validation_PathSignatureMustBeUnique, "/pets/{}");
+            var paths = new OpenApiPaths
+            {
+                {"/pets/{petId}",new OpenApiPathItem() },
+                {"/pets/{name}",new OpenApiPathItem() }
+            };
+
+            // Act
+            var errors = paths.Validate(ValidationRuleSet.GetDefaultRuleSet());
+
+            // Assert
+            errors.Should().NotBeEmpty();
+            errors.Select(e => e.Message).Should().BeEquivalentTo(error);
+        }
+    }
+}

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

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