Adding RegexInlineRouteConstraint

Author: harshgMSFT

src/Microsoft.AspNet.Routing/Constraints/RegexInlineRouteConstraint.cs

@@ -0,0 +1,20 @@
+// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+namespace Microsoft.AspNet.Routing.Constraints
+{
+    /// <summary>
+    /// Represents a regex constraint which can be used as an inlineConstraint.
+    /// </summary>
+    public class RegexInlineRouteConstraint : RegexRouteConstraint
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="RegexInlineRouteConstraint" /> class.
+        /// </summary>
+        /// <param name="regexPattern">The regular expression pattern to match.</param>
+        public RegexInlineRouteConstraint([NotNull] string regexPattern)
+            : base(regexPattern)
+        {
+        }
+    }
+}

src/Microsoft.AspNet.Routing/Microsoft.AspNet.Routing.kproj

@@ -16,5 +16,6 @@
   <PropertyGroup>
     <SchemaVersion>2.0</SchemaVersion>
   </PropertyGroup>
+    <Compile Include="Constraints\RegexInlineRouteConstraint.cs" />
   <Import Project="$(VSToolsPath)\AspNet\Microsoft.Web.AspNet.targets" Condition="'$(VSToolsPath)' != ''" />
 </Project>

src/Microsoft.AspNet.Routing/RouteOptions.cs

@@ -56,6 +56,7 @@ private static IDictionary<string, Type> GetDefaultConstraintMap()
 
                 // Regex-based constraints
                 { "alpha", typeof(AlphaRouteConstraint) },
+                { "regex", typeof(RegexInlineRouteConstraint) },
             };
         }
     }

test/Microsoft.AspNet.Routing.Tests/Constraints/RegexInlineRouteConstraintTests.cs

@@ -0,0 +1,91 @@
+// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+#if NET45
+
+using System.Globalization;
+using System.Threading;
+using Microsoft.AspNet.Http;
+using Microsoft.AspNet.Routing.Constraints;
+using Moq;
+using Xunit;
+
+namespace Microsoft.AspNet.Routing.Tests
+{
+    public class RegexInlineRouteConstraintTests
+    {
+        [Theory]
+        [InlineData("abc", "abc", true)]    // simple match
+        [InlineData("Abc", "abc", true)]    // case insensitive match
+        [InlineData("Abc ", "abc", true)]   // Extra space on input match (because we don't add ^({0})$
+        [InlineData("Abcd", "abc", true)]   // Extra char
+        [InlineData("^Abcd", "abc", true)]  // Extra special char
+        [InlineData("Abc", " abc", false)]  // Missing char
+        public void RegexInlineConstraintBuildRegexVerbatimFromInput(string routeValue,
+                                                               string constraintValue,
+                                                               bool shouldMatch)
+        {
+            // Arrange
+            var constraint = new RegexInlineRouteConstraint(constraintValue);
+            var values = new RouteValueDictionary(new {controller = routeValue});
+
+            // Assert
+            Assert.Equal(shouldMatch, EasyMatch(constraint, "controller", values));
+        }
+
+        [Fact]
+        public void RegexInlineConstraint_FailsIfKeyIsNotFoundInRouteValues()
+        {
+            // Arrange
+            var constraint = new RegexInlineRouteConstraint("^abc$");
+            var values = new RouteValueDictionary(new { action = "abc" });
+
+            // Assert
+            Assert.False(EasyMatch(constraint, "controller", values));
+        }
+
+        [Fact]
+        public void RegexInlineConstraint_IsCultureInsensitive()
+        {
+            // Arrange
+            var constraint = new RegexInlineRouteConstraint("^([a-z]+)$");
+            var values = new RouteValueDictionary(new { controller = "\u0130" }); // Turkish upper-case dotted I
+
+            var currentThread = Thread.CurrentThread;
+            var backupCulture = currentThread.CurrentCulture;
+
+            bool matchInTurkish;
+            bool matchInUsEnglish;
+
+            // Act
+            try
+            {
+                currentThread.CurrentCulture = new CultureInfo("tr-TR"); // Turkish culture
+                matchInTurkish = EasyMatch(constraint, "controller", values);
+
+                currentThread.CurrentCulture = new CultureInfo("en-US");
+                matchInUsEnglish = EasyMatch(constraint, "controller", values);
+            }
+            finally
+            {
+                currentThread.CurrentCulture = backupCulture;
+            }
+
+            // Assert
+            Assert.False(matchInUsEnglish); // this just verifies the test
+            Assert.False(matchInTurkish);
+        }
+
+        private static bool EasyMatch(IRouteConstraint constraint,
+                                      string routeKey,
+                                      RouteValueDictionary values)
+        {
+            return constraint.Match(httpContext: new Mock<HttpContext>().Object,
+                route: new Mock<IRouter>().Object,
+                routeKey: routeKey,
+                values: values,
+                routeDirection: RouteDirection.IncomingRequest);
+        }
+    }
+}
+#endif

test/Microsoft.AspNet.Routing.Tests/Constraints/RegexConstraintTests.cs renamed to test/Microsoft.AspNet.Routing.Tests/Constraints/RegexRouteConstraintTests.cs

@@ -13,7 +13,7 @@
 
 namespace Microsoft.AspNet.Routing.Tests
 {
-    public class RegexConstraintTests
+    public class RegexRouteConstraintTests
     {
         [Theory]
         [InlineData("abc", "abc", true)]    // simple match

test/Microsoft.AspNet.Routing.Tests/DefaultInlineConstraintResolverTest.cs

@@ -42,6 +42,7 @@ public void ResolveConstraint_IntConstraintWithArgument_Throws()
                          " with the following number of parameters: 1.",
                          ex.Message);
         }
+
         [Fact]
         public void ResolveConstraint_AlphaConstraint()
         {
@@ -52,6 +53,16 @@ public void ResolveConstraint_AlphaConstraint()
             Assert.IsType<AlphaRouteConstraint>(constraint);
         }
 
+        [Fact]
+        public void ResolveConstraint_RegexInlineConstraint_WithAComma_PassesAsASingleArgument()
+        {
+            // Arrange & Act
+            var constraint = _constraintResolver.ResolveConstraint("regex(ab,1)");
+
+            // Assert
+            Assert.IsType<RegexInlineRouteConstraint>(constraint);
+        }
+
         [Fact]
         public void ResolveConstraint_BoolConstraint()
         {

test/Microsoft.AspNet.Routing.Tests/Microsoft.AspNet.Routing.Tests.kproj

@@ -16,5 +16,6 @@
   <PropertyGroup>
     <SchemaVersion>2.0</SchemaVersion>
   </PropertyGroup>
+
   <Import Project="$(VSToolsPath)\AspNet\Microsoft.Web.AspNet.targets" Condition="'$(VSToolsPath)' != ''" />
 </Project>