Create new cloned permissive record matcher named permissive record matcher with resource api exclusion and update sql tests to use that new matcher for safety

Author: John Paul Kee

src/Sql/Sql.Test/ScenarioTests/SqlTestsBase.cs

@@ -78,7 +78,7 @@ protected void RunPowerShellTest(params string[] scripts)
                 {"Microsoft.Azure.Graph.RBAC.Version1_6.GraphRbacManagementClient", "1.42-previewInternal"},
                 {"Microsoft.Azure.Management.Resources.ResourceManagementClient", "2016-02-01"}
             };
-            HttpMockServer.Matcher = new PermissiveRecordMatcherWithApiExclusion(true, d, providersToIgnore, resourceTypesToIgnoreApiVersion);
+            HttpMockServer.Matcher = new PermissiveRecordMatcherWithResourceApiExclusion(true, d, providersToIgnore, resourceTypesToIgnoreApiVersion);
             HttpMockServer.RecordsDirectory = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "SessionRecords");
 
             // Enable undo functionality as well as mock recording

src/Sql/Sql.Test/UnitTests/PermissiveRecordMatcherWithApiExclusionUnitTests.cs renamed to src/Sql/Sql.Test/UnitTests/PermissiveRecordMatcherWithResourceApiExclusionUnitTests.cs

@@ -7,11 +7,11 @@
 
 namespace Microsoft.Azure.Commands.Sql.Test.UnitTests
 {
-    public class PermissiveRecordMatcherUnitTests
+    public class PermissiveRecordMatcherWithResourceApiExclusionUnitTests
     {
         [Fact]
         [Trait(Category.AcceptanceType, Category.CheckIn)]
-        public void PermissiveRecordMatcherWithApiExclusion_ContainsIgnoredProvider()
+        public void PermissiveRecordMatcherWithResourceApiExclusion_ContainsIgnoredProvider()
         {
             var testRequestUris = new string[]
             {
@@ -70,7 +70,7 @@ private void TestContainsIgnoredProvider(
             var numIgnored = 0;
             foreach (var testUri in requestUrisToTest)
             {
-                var result = PermissiveRecordMatcherWithApiExclusion.ContainsIgnoredProvider(
+                var result = PermissiveRecordMatcherWithResourceApiExclusion.ContainsIgnoredProvider(
                     requestUri: testUri,
                     shouldIgnoreGenericResource: false,
                     providersToIgnore: new Dictionary<string, string>(),

tools/ScenarioTest.ResourceManager/PermissiveRecordMatcherWithApiExclusion.cs

@@ -1,36 +1,33 @@
-// ----------------------------------------------------------------------------------
-//
-// Copyright Microsoft Corporation
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-// http://www.apache.org/licenses/LICENSE-2.0
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-// ----------------------------------------------------------------------------------
-
-using Microsoft.Azure.Management.Internal.Resources.Utilities.Models;
+// ---------------------------------------------------------------------------------- 
+// 
+// Copyright Microsoft Corporation 
+// Licensed under the Apache License, Version 2.0 (the "License"); 
+// you may not use this file except in compliance with the License. 
+// You may obtain a copy of the License at 
+// http://www.apache.org/licenses/LICENSE-2.0 
+// Unless required by applicable law or agreed to in writing, software 
+// distributed under the License is distributed on an "AS IS" BASIS, 
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
+// See the License for the specific language governing permissions and 
+// limitations under the License. 
+// ---------------------------------------------------------------------------------- 
+
 using Microsoft.Azure.Test.HttpRecorder;
 using System;
 using System.Collections.Generic;
-using System.Diagnostics;
 using System.Linq;
 using System.Text;
 using System.Text.RegularExpressions;
 
 namespace Microsoft.WindowsAzure.Commands.ScenarioTest
 {
-    // Excludes api version when matching mocked records.
+    // Excludes api version when matching mocked records. 
     // If alternate api version is provided, uses that to match records else removes the api-version matching.
     public class PermissiveRecordMatcherWithApiExclusion : IRecordMatcher
     {
         protected bool _ignoreGenericResource;
         protected Dictionary<string, string> _providersToIgnore;
         protected Dictionary<string, string> _userAgentsToIgnore;
-        protected string[] _resourcesToIgnore;
 
         public PermissiveRecordMatcherWithApiExclusion(bool ignoreResourcesClient, Dictionary<string, string> providers)
         {
@@ -48,30 +45,18 @@ public PermissiveRecordMatcherWithApiExclusion(
             _userAgentsToIgnore = userAgents;
         }
 
-        public PermissiveRecordMatcherWithApiExclusion(
-            bool ignoreResourcesClient,
-            Dictionary<string, string> providers,
-            Dictionary<string, string> userAgents,
-            string[] resourcesToIgnore)
-        {
-            _ignoreGenericResource = ignoreResourcesClient;
-            _providersToIgnore = providers;
-            _userAgentsToIgnore = userAgents;
-            _resourcesToIgnore = resourcesToIgnore;
-        }
-
         public virtual string GetMatchingKey(System.Net.Http.HttpRequestMessage request)
         {
-            var requestUri = request.RequestUri.PathAndQuery;
-            if (requestUri.Contains("?&"))
+            var path = request.RequestUri.PathAndQuery;
+            if (path.Contains("?&"))
             {
-                requestUri = requestUri.Replace("?&", "?");
+                path = path.Replace("?&", "?");
             }
 
             string version;
-            if (ContainsIgnoredProvider(requestUri, out version))
+            if (ContainsIgnoredProvider(path, out version))
             {
-                requestUri = RemoveOrReplaceApiVersion(requestUri, version);
+                path = RemoveOrReplaceApiVersion(path, version);
             }
             else if (_userAgentsToIgnore != null && _userAgentsToIgnore.Any())
             {
@@ -82,62 +67,46 @@ public virtual string GetMatchingKey(System.Net.Http.HttpRequestMessage request)
                     {
                         if (agent.Value.Any(v => v.StartsWith(userAgnet.Key, StringComparison.OrdinalIgnoreCase)))
                         {
-                            requestUri = RemoveOrReplaceApiVersion(requestUri, userAgnet.Value);
+                            path = RemoveOrReplaceApiVersion(path, userAgnet.Value);
                             break;
                         }
                     }
                 }
             }
 
-            var encodedPath = Convert.ToBase64String(Encoding.UTF8.GetBytes(requestUri));
+            var encodedPath = Convert.ToBase64String(Encoding.UTF8.GetBytes(path));
             return string.Format("{0} {1}", request.Method, encodedPath);
         }
 
         public virtual string GetMatchingKey(RecordEntry recordEntry)
         {
             var encodedPath = recordEntry.EncodedRequestUri;
-            var requestUri = recordEntry.RequestUri;
+            var path = recordEntry.RequestUri;
             var changed = false;
-            if (requestUri.Contains("?&"))
+            if (path.Contains("?&"))
             {
-                requestUri = recordEntry.RequestUri.Replace("?&", "?");
+                path = recordEntry.RequestUri.Replace("?&", "?");
                 changed = true;
             }
 
             string version;
-            if (ContainsIgnoredProvider(requestUri, out version))
+            if (ContainsIgnoredProvider(path, out version))
             {
-                requestUri = RemoveOrReplaceApiVersion(requestUri, version);
+                path = RemoveOrReplaceApiVersion(path, version);
                 changed = true;
             }
 
             if (changed)
             {
-                encodedPath = Convert.ToBase64String(Encoding.UTF8.GetBytes(requestUri));
+                encodedPath = Convert.ToBase64String(Encoding.UTF8.GetBytes(path));
             }
 
             return string.Format("{0} {1}", recordEntry.RequestMethod, encodedPath);
         }
 
-        public bool ContainsIgnoredProvider(string requestUri, out string version)
+        protected bool ContainsIgnoredProvider(string requestUri, out string version)
         {
-            return ContainsIgnoredProvider(requestUri, _ignoreGenericResource, _providersToIgnore, _resourcesToIgnore, apiVersion: out version);
-        }
-
-        /// <summary>
-        /// Helper method to determine whether or not this request api version should be ignored
-        /// </summary>
-        /// <param name="requestUri">The request uri</param>
-        /// <param name="apiVersion">The api verison to use</paraam>
-        /// <returns></returns>
-        public static bool ContainsIgnoredProvider(
-            string requestUri,
-            bool shouldIgnoreGenericResource,
-            Dictionary<string, string> providersToIgnore,
-            string[] resourcesToIgnore,
-            out string apiVersion)
-        {
-            if (shouldIgnoreGenericResource &&
+            if (_ignoreGenericResource &&
                 !requestUri.Contains("providers/") &&
                 !requestUri.StartsWith("/certificates?", StringComparison.InvariantCultureIgnoreCase) &&
                 !requestUri.StartsWith("/pools", StringComparison.InvariantCultureIgnoreCase) &&
@@ -147,68 +116,22 @@ public static bool ContainsIgnoredProvider(
                 !requestUri.Contains("/servicePrincipals?") &&
                 !requestUri.StartsWith("/webhdfs/v1/?aclspec", StringComparison.InvariantCultureIgnoreCase))
             {
-                apiVersion = String.Empty;
+                version = String.Empty;
                 return true;
             }
 
-            // Ignore resource providers
-            foreach (var provider in providersToIgnore)
+            foreach (var provider in _providersToIgnore)
             {
                 var providerString = string.Format("providers/{0}", provider.Key);
                 if (requestUri.Contains(providerString))
                 {
-                    apiVersion = provider.Value;
+                    version = provider.Value;
                     return true;
                 }
             }
 
-            if (resourcesToIgnore != null && resourcesToIgnore.Any())
-            {
-                // If we're looking at a specific provider and we have top level resource from this provider to ignore
-                foreach (var resourceToIgnore in resourcesToIgnore)
-                {
-                    string[] segments = requestUri.Split(new char[] { '/' }, options: StringSplitOptions.RemoveEmptyEntries);
-
-                    // /subscriptions/.../resourceGroups/.../providers/Microsoft.X/resourceType...?api-version=Y
-                    var regex = new Regex(@"\/subscriptions\/[0-9A-Fa-f-]*\/resourceGroups\/[a-zA-Z0-9_-]*\/providers\/[a-zA-Z0-9_-]*.[a-zA-Z0-9_-]*\/.*[?api-version=[0-9-]*]?");
-                    if (regex.IsMatch(requestUri))
-                    {
-                        if (segments.Length > 7)
-                        {
-                            var resourceIdentifier = new ResourceIdentifier(requestUri);
-                            if (resourceIdentifier.ResourceType == resourceToIgnore)
-                            {
-                                apiVersion = String.Empty;
-                                return true;
-                            }
-                        }
-                        else if (segments.Length == 7)
-                        {
-                            var resourceType = $"{segments[5]}/{segments[6]}";
-                            if (resourceType.Contains(resourceToIgnore))
-                            {
-                                apiVersion = String.Empty;
-                                return true;
-                            }
-                        }
-                    }
-
-                    // /subscriptions/.../providers/Microsoft.Provider/resourceType
-                    regex = new Regex(@"\/subscriptions\/[0-9A-Fa-f-]*\/providers\/[a-zA-Z0-9_-]*.[a-zA-Z0-9_-]*\/.*?[api-version=[0-9-]*]?");
-                    if (regex.IsMatch(requestUri))
-                    {
-                        var resourceType = $"{segments[3]}/{segments[4]}";
-                        if (resourceType.Contains(resourceToIgnore))
-                        {
-                            apiVersion = String.Empty;
-                            return true;
-                        }
-                    }
-                }
-            }
-
 
-            apiVersion = string.Empty;
+            version = string.Empty;
             return false;
         }