Remove namedValue search from backend extractor (#852)

f-alizada · Farhad Alizada · web-flow · commit e8694f8430f1 · 2022-12-23T15:44:23.000+01:00
* Remove namedValue search from backend extractor

Co-authored-by: Farhad Alizada &lt;falizada@microsoft.com&gt;
diff --git a/src/ArmTemplates/Commands/Executors/ExtractorExecutor.cs b/src/ArmTemplates/Commands/Executors/ExtractorExecutor.cs
@@ -663,15 +663,13 @@ await FileWriter.SaveAsJsonAsync(
         public async Task<Template<BackendTemplateResources>> GenerateBackendTemplateAsync(
             string singleApiName,
             List<PolicyTemplateResource> apiPolicies,
-            List<NamedValueTemplateResource> namedValueResources,
             string baseFilesGenerationDirectory)
         {
             this.logger.LogInformation("Started generation of backend template...");
 
             var backendTemplate = await this.backendExtractor.GenerateBackendsTemplateAsync(
                 singleApiName,
                 apiPolicies,
-                namedValueResources,
                 baseFilesGenerationDirectory,
                 this.extractorParameters);
 
@@ -1173,7 +1171,7 @@ async Task GenerateTemplates(
             var apiTagTemplate = await this.GenerateTagApiTemplateAsync(singleApiName, multipleApiNames, baseFilesGenerationDirectory);
             var loggerTemplate = await this.GenerateLoggerTemplateAsync(apisToExtract, apiTemplate.TypedResources.GetAllPolicies(), baseFilesGenerationDirectory);
             var namedValueTemplate = await this.GenerateNamedValuesTemplateAsync(singleApiName, apiTemplate.TypedResources.GetAllPolicies(), loggerTemplate.TypedResources.Loggers, baseFilesGenerationDirectory);
-            var backendTemplate = await this.GenerateBackendTemplateAsync(singleApiName, apiTemplate.TypedResources.GetAllPolicies(), namedValueTemplate.TypedResources.NamedValues, baseFilesGenerationDirectory);
+            var backendTemplate = await this.GenerateBackendTemplateAsync(singleApiName, apiTemplate.TypedResources.GetAllPolicies(), baseFilesGenerationDirectory);
             var groupTemplate = await this.GenerateGroupsTemplateAsync(baseFilesGenerationDirectory);
             var identityProviderTemplate = await this.GenerateIdentityProviderTemplateAsync(baseFilesGenerationDirectory);
             var openIdConnectProviderTemplate = await this.GenerateOpenIdConnectProviderTemplateAsync(baseFilesGenerationDirectory);
diff --git a/src/ArmTemplates/Extractor/EntityExtractors/Abstractions/IBackendExtractor.cs b/src/ArmTemplates/Extractor/EntityExtractors/Abstractions/IBackendExtractor.cs
@@ -18,7 +18,6 @@ public interface IBackendExtractor
         Task<Template<BackendTemplateResources>> GenerateBackendsTemplateAsync(
             string singleApiName,
             List<PolicyTemplateResource> apiPolicies,
-            List<NamedValueTemplateResource> namedValues,
             string baseFilesGenerationDirectory,
             ExtractorParameters extractorParameters);
 
diff --git a/src/ArmTemplates/Extractor/EntityExtractors/BackendExtractor.cs b/src/ArmTemplates/Extractor/EntityExtractors/BackendExtractor.cs
@@ -5,16 +5,13 @@
 
 using System.Threading.Tasks;
 using System.Collections.Generic;
-using System.Linq;
-using System;
 using Microsoft.Azure.Management.ApiManagement.ArmTemplates.Common.Templates.Policy;
 using Microsoft.Azure.Management.ApiManagement.ArmTemplates.Common.Extensions;
 using Microsoft.Azure.Management.ApiManagement.ArmTemplates.Common.Constants;
 using Microsoft.Azure.Management.ApiManagement.ArmTemplates.Extractor.EntityExtractors.Abstractions;
 using Microsoft.Azure.Management.ApiManagement.ArmTemplates.Common.Templates.Abstractions;
 using Microsoft.Azure.Management.ApiManagement.ArmTemplates.Extractor.Models;
 using Microsoft.Azure.Management.ApiManagement.ArmTemplates.Common.Templates.Builders.Abstractions;
-using Microsoft.Azure.Management.ApiManagement.ArmTemplates.Common.Templates.NamedValues;
 using Microsoft.Azure.Management.ApiManagement.ArmTemplates.Common.Templates.Backend;
 using Microsoft.Azure.Management.ApiManagement.ArmTemplates.Common.API.Clients.Abstractions;
 using Microsoft.Extensions.Logging;
@@ -48,7 +45,6 @@ public BackendExtractor(
         public async Task<Template<BackendTemplateResources>> GenerateBackendsTemplateAsync(
             string singleApiName,
             List<PolicyTemplateResource> apiPolicies,
-            List<NamedValueTemplateResource> namedValues,
             string baseFilesGenerationDirectory,
             ExtractorParameters extractorParameters)
         {
@@ -87,7 +83,7 @@ public async Task<Template<BackendTemplateResources>> GenerateBackendsTemplateAs
                     {
                         var policyContent = this.policyExtractor.GetCachedPolicyContent(policyTemplateResource, baseFilesGenerationDirectory);
 
-                        if (this.DoesPolicyReferenceBackend(policyContent, namedValues, backendResource.OriginalName, backendResource))
+                        if (this.DoesPolicyReferenceBackend(policyContent, backendResource.OriginalName, backendResource))
                         {
                             // backend was used in policy, extract it
                             backendTemplate.TypedResources.Backends.Add(backendResource);
@@ -161,33 +157,18 @@ void SaveBackendApiParametersToCache()
 
         bool DoesPolicyReferenceBackend(
             string policyContent,
-            IEnumerable<NamedValueTemplateResource> namedValueResources,
             string backendName,
             BackendTemplateResource backendTemplateResource)
         {
-            // a policy is referenced by a backend with the set-backend-service policy, which will reference use the backends name or url, or through referencing a named value that applies to the backend
-            var namedValueResourcesUsedByBackend = namedValueResources.Where(resource => this.DoesBackendReferenceNamedValue(resource, backendTemplateResource));
-            
-            if (backendName != null && policyContent.Contains(backendName) ||
-                backendTemplateResource.Properties.Url != null && policyContent.Contains(backendTemplateResource.Properties.Url) ||
-                backendTemplateResource.Properties.Title != null && policyContent.Contains(backendTemplateResource.Properties.Title) ||
-                backendTemplateResource.Properties.ResourceId != null && policyContent.Contains(backendTemplateResource.Properties.ResourceId))
+            if (!string.IsNullOrEmpty(backendName) && policyContent.Contains(backendName) ||
+                !string.IsNullOrEmpty(backendTemplateResource.Properties.Url) && policyContent.Contains(backendTemplateResource.Properties.Url) ||
+                !string.IsNullOrEmpty(backendTemplateResource.Properties.Title) && policyContent.Contains(backendTemplateResource.Properties.Title) ||
+                !string.IsNullOrEmpty(backendTemplateResource.Properties.ResourceId) && policyContent.Contains(backendTemplateResource.Properties.ResourceId))
             {
                 return true;
             }
 
-            return namedValueResourcesUsedByBackend.Any(x => 
-                    (x.Properties.DisplayName is not null && policyContent.Contains(x.Properties.DisplayName)) ||
-                    (x.Properties.Value is not null && policyContent.Contains(x.Properties.Value)));
-        }
-
-        public bool DoesBackendReferenceNamedValue(NamedValueTemplateResource namedValueResource, BackendTemplateResource backendTemplateResource)
-        {
-            var namedValue = namedValueResource.Properties.Value;
-            
-            return namedValue == backendTemplateResource.Properties.Url
-                || namedValue == backendTemplateResource.Properties.Description
-                || namedValue == backendTemplateResource.Properties.Title;
+            return false;
         }
 
         public async Task<bool> IsNamedValueUsedInBackends(
@@ -233,7 +214,7 @@ public async Task<bool> IsNamedValueUsedInBackends(
                         foreach (var policyTemplateResource in apiPolicies)
                         {
                             var policyContent = this.policyExtractor.GetCachedPolicyContent(policyTemplateResource, baseFilesGenerationDirectory);
-                            if (this.DoesPolicyReferenceBackend(policyContent, Array.Empty<NamedValueTemplateResource>(), backendName, backendResource))
+                            if (this.DoesPolicyReferenceBackend(policyContent, backendName, backendResource))
                             {
                                 // don't need to go through all policies and backends if the named values has already been found
                                 return true;
diff --git a/tests/ArmTemplates.Tests/Extractor/Scenarios/ApiExtractorByVersionSetNameTests.cs b/tests/ArmTemplates.Tests/Extractor/Scenarios/ApiExtractorByVersionSetNameTests.cs
@@ -159,7 +159,7 @@ public async Task GenerateAPIVersionSetTemplates_GeneratesApiTemplates()
 
             var mockedBackendExtractor = new Mock<IBackendExtractor>(MockBehavior.Strict);
             mockedBackendExtractor
-                .Setup(x => x.GenerateBackendsTemplateAsync(It.IsAny<string>(), It.IsAny<List<PolicyTemplateResource>>(), It.IsAny<List<NamedValueTemplateResource>>(), It.IsAny<string>(), It.IsAny<ExtractorParameters>()))
+                .Setup(x => x.GenerateBackendsTemplateAsync(It.IsAny<string>(), It.IsAny<List<PolicyTemplateResource>>(), It.IsAny<string>(), It.IsAny<ExtractorParameters>()))
                 .ReturnsAsync(new Template<BackendTemplateResources>()
                 {
                     TypedResources = new BackendTemplateResources()
diff --git a/tests/ArmTemplates.Tests/Extractor/Scenarios/BackendExtractorTests.cs b/tests/ArmTemplates.Tests/Extractor/Scenarios/BackendExtractorTests.cs
@@ -64,7 +64,6 @@ public async Task GenerateBackendTemplates_ProperlyLaysTheInformation()
             var backendTemplate = await extractorExecutor.GenerateBackendTemplateAsync(
                 singleApiName: null,
                 new List<PolicyTemplateResource>(),
-                new List<NamedValueTemplateResource>(),
                 currentTestDirectory);
 
             // assert
@@ -117,7 +116,7 @@ public async Task GenerateBackendTemplate_ProperlyParsesAndGeneratesTemplate()
             extractorExecutor.SetExtractorParameters(extractorParameters);
 
             // act
-            var backendTemplate = await extractorExecutor.GenerateBackendTemplateAsync(null, null, null, currentTestDirectory);
+            var backendTemplate = await extractorExecutor.GenerateBackendTemplateAsync(null, null, currentTestDirectory);
 
             // assert
             File.Exists(Path.Combine(currentTestDirectory, extractorParameters.FileNames.Backends)).Should().BeTrue();
@@ -140,5 +139,72 @@ public async Task GenerateBackendTemplate_ProperlyParsesAndGeneratesTemplate()
             proxyBackend2.Properties.Proxy.Username.Should().Contain(ParameterNames.BackendProxy);
             proxyBackend2.Properties.Proxy.Url.Should().Contain(ParameterNames.BackendProxy);
         }
+
+        [Fact]
+        public async Task GenerateBackendTemplate_GeneratesOnlyReferencedBackendInPolicy()
+        {
+            // arrange
+            var responseFileLocation = Path.Combine(MockClientUtils.ApiClientJsonResponsesPath, "ApiManagementListBackends_success_response.json");
+            var currentTestDirectory = Path.Combine(this.OutputDirectory, nameof(GenerateBackendTemplate_GeneratesOnlyReferencedBackendInPolicy));
+
+            var mockedClient = await MockBackendClient.GetMockedHttpApiClient(new MockClientConfiguration(responseFileLocation: responseFileLocation));
+            var apiName = "api-name-with-reference";
+
+            var extractorConfig = this.GetDefaultExtractorConsoleAppConfiguration(
+                apiName: apiName);
+            var extractorParameters = new ExtractorParameters(extractorConfig);
+
+            // mocked extractors
+            var policyExtractor = new PolicyExtractor(
+                this.GetTestLogger<PolicyExtractor>(),
+                null,
+                new TemplateBuilder());
+            
+            var backendExtractor = new BackendExtractor(
+               this.GetTestLogger<BackendExtractor>(),
+               new TemplateBuilder(),
+               policyExtractor,
+               mockedClient);
+
+            var extractorExecutor = ExtractorExecutor.BuildExtractorExecutor(
+                this.GetTestLogger<ExtractorExecutor>(),
+                backendExtractor: backendExtractor,
+                policyExtractor: policyExtractor);
+            extractorExecutor.SetExtractorParameters(extractorParameters);
+
+            var apiPolicies = new List<PolicyTemplateResource>()
+            {
+                new PolicyTemplateResource()
+                {
+                    Properties = new PolicyTemplateProperties
+                    {
+                        PolicyContent = "<set-backend-service backend-id=\"proxybackend1\" />"
+                    }
+                },
+                new PolicyTemplateResource()
+                {
+                    Properties = new PolicyTemplateProperties
+                    {
+                        PolicyContent = "<set-backend-service backend-id=\"proxybackend2\" />"
+                    }
+                }
+            };
+
+            // act
+            var backendTemplate = await extractorExecutor.GenerateBackendTemplateAsync(apiName, apiPolicies, currentTestDirectory);
+
+            // assert
+            File.Exists(Path.Combine(currentTestDirectory, extractorParameters.FileNames.Backends)).Should().BeTrue();
+
+            backendTemplate.Parameters.Should().ContainKey(ParameterNames.ApimServiceName);
+
+            backendTemplate.TypedResources.Backends.Count().Should().Be(2);
+            backendTemplate.TypedResources.Backends.All(x => x.Type.Equals(ResourceTypeConstants.Backend)).Should().BeTrue();
+
+            var proxyBackend1 = backendTemplate.TypedResources.Backends.First(x => x.Name.Contains("proxybackend1"));
+            proxyBackend1.Should().NotBeNull();
+            var proxyBackend2 = backendTemplate.TypedResources.Backends.First(x => x.Name.Contains("proxybackend2"));
+            proxyBackend2.Should().NotBeNull();
+        }
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -159,7 +159,7 @@ public async Task GenerateAPIVersionSetTemplates_GeneratesApiTemplates()`
`159`	`159`
`160`	`160`	`var mockedBackendExtractor = new Mock<IBackendExtractor>(MockBehavior.Strict);`
`161`	`161`	`mockedBackendExtractor`
`162`		`- .Setup(x => x.GenerateBackendsTemplateAsync(It.IsAny<string>(), It.IsAny<List<PolicyTemplateResource>>(), It.IsAny<List<NamedValueTemplateResource>>(), It.IsAny<string>(), It.IsAny<ExtractorParameters>()))`
	`162`	`+ .Setup(x => x.GenerateBackendsTemplateAsync(It.IsAny<string>(), It.IsAny<List<PolicyTemplateResource>>(), It.IsAny<string>(), It.IsAny<ExtractorParameters>()))`
`163`	`163`	`.ReturnsAsync(new Template<BackendTemplateResources>()`
`164`	`164`	`{`
`165`	`165`	`TypedResources = new BackendTemplateResources()`