add unit tests for creator

lucashuet93 · lucashuet93 · commit d638add386bc · 2019-05-07T11:19:38.000-04:00
diff --git a/src/APIM_ARMTemplate/apimtemplate.test/Creator/TemplateCreatorTests/APITemplateCreatorTests.cs b/src/APIM_ARMTemplate/apimtemplate.test/Creator/TemplateCreatorTests/APITemplateCreatorTests.cs
@@ -84,6 +84,62 @@ public async void ShouldCreateSubsequentlAPITemplateResourceFromCreatorConfigWit
             Assert.Equal(api.openApiSpec, apiTemplateResource.properties.contentValue);
         }
 
+        [Fact]
+        public async void ShouldCreateUnifiedAPITemplateResourceFromCreatorConfig()
+        {
+            // arrange
+            APITemplateCreator apiTemplateCreator = APITemplateCreatorFactory.GenerateAPITemplateCreator();
+            CreatorConfig creatorConfig = new CreatorConfig() { apis = new List<APIConfig>() };
+            APIConfig api = new APIConfig()
+            {
+                name = "name",
+                apiVersion = "apiVersion",
+                apiVersionDescription = "apiVersionDescription",
+                apiVersionSetId = "apiVersionSetId",
+                revision = "revision",
+                revisionDescription = "revisionDescription",
+                suffix = "suffix",
+                subscriptionRequired = true,
+                authenticationSettings = new APITemplateAuthenticationSettings()
+                {
+                    oAuth2 = new APITemplateOAuth2()
+                    {
+                        authorizationServerId = "",
+                        scope = ""
+                    },
+                    openid = new APITemplateOpenID()
+                    {
+                        openidProviderId = "",
+                        bearerTokenSendingMethods = new string[] { }
+                    },
+                    subscriptionKeyRequired = true
+                },
+                openApiSpec = "https://petstore.swagger.io/v2/swagger.json",
+            };
+            creatorConfig.apis.Add(api);
+
+            // act
+            APITemplateResource apiTemplateResource = await apiTemplateCreator.CreateAPITemplateResourceAsync(api, false, true);
+
+            // assert
+            Assert.Equal($"[concat(parameters('ApimServiceName'), '/{api.name}')]", apiTemplateResource.name);
+            Assert.Equal(api.name, apiTemplateResource.properties.displayName);
+            Assert.Equal(api.apiVersion, apiTemplateResource.properties.apiVersion);
+            Assert.Equal(api.apiVersionDescription, apiTemplateResource.properties.apiVersionDescription);
+            Assert.Equal($"[resourceId('Microsoft.ApiManagement/service/api-version-sets', parameters('ApimServiceName'), '{api.apiVersionSetId}')]", apiTemplateResource.properties.apiVersionSetId);
+            Assert.Equal(api.revision, apiTemplateResource.properties.apiRevision);
+            Assert.Equal(api.revisionDescription, apiTemplateResource.properties.apiRevisionDescription);
+            Assert.Equal(api.suffix, apiTemplateResource.properties.path);
+            Assert.Equal(api.subscriptionRequired, apiTemplateResource.properties.subscriptionRequired);
+            Assert.Equal(api.authenticationSettings.oAuth2.authorizationServerId, apiTemplateResource.properties.authenticationSettings.oAuth2.authorizationServerId);
+            Assert.Equal(api.authenticationSettings.oAuth2.scope, apiTemplateResource.properties.authenticationSettings.oAuth2.scope);
+            Assert.Equal(api.authenticationSettings.openid.openidProviderId, apiTemplateResource.properties.authenticationSettings.openid.openidProviderId);
+            Assert.Equal(api.authenticationSettings.openid.bearerTokenSendingMethods, apiTemplateResource.properties.authenticationSettings.openid.bearerTokenSendingMethods);
+            Assert.Equal(api.authenticationSettings.subscriptionKeyRequired, apiTemplateResource.properties.authenticationSettings.subscriptionKeyRequired);
+            Assert.Equal("swagger-link-json", apiTemplateResource.properties.contentFormat);
+            Assert.Equal(api.openApiSpec, apiTemplateResource.properties.contentValue);
+        }
+
         [Fact]
         public void ShouldCreateProtocolsFromOpenApiDocument()
         {
diff --git a/src/APIM_ARMTemplate/apimtemplate.test/Creator/TemplateCreatorTests/AuthorizationServerTemplateCreatorTests.cs b/src/APIM_ARMTemplate/apimtemplate.test/Creator/TemplateCreatorTests/AuthorizationServerTemplateCreatorTests.cs
@@ -0,0 +1,64 @@
+﻿using Xunit;
+using Microsoft.Azure.Management.ApiManagement.ArmTemplates.Common;
+using Microsoft.Azure.Management.ApiManagement.ArmTemplates.Create;
+using System.Collections.Generic;
+
+namespace Microsoft.Azure.Management.ApiManagement.ArmTemplates.Test
+{
+    public class AuthorizationServerTemplateCreatorTests
+    {
+        [Fact]
+        public void ShouldCreateAuthorizationServerTemplateFromCreatorConfig()
+        {
+            // arrange
+            AuthorizationServerTemplateCreator authorizationServerTemplateCreator = new AuthorizationServerTemplateCreator();
+            CreatorConfig creatorConfig = new CreatorConfig() { authorizationServers = new List<AuthorizationServerTemplateProperties>() };
+            AuthorizationServerTemplateProperties authorizationServer = new AuthorizationServerTemplateProperties()
+            {
+                description = "description",
+                displayName = "displayName",
+                authorizationEndpoint = "endpoint.com",
+                authorizationMethods = new string[] { "GET" },
+                tokenBodyParameters = new AuthorizationServerTokenBodyParameter[] { new AuthorizationServerTokenBodyParameter() {
+                    name = "name",
+                    value = "value"
+                } },
+                clientAuthenticationMethod = new string[] { "GET" },
+                tokenEndpoint = "endpoint.com",
+                supportState = true,
+                defaultScope = "defaultScope",
+                bearerTokenSendingMethods = new string[] { "GET" },
+                clientId = "id",
+                clientSecret = "secret",
+                clientRegistrationEndpoint = "endpoint.com",
+                resourceOwnerPassword = "pass",
+                resourceOwnerUsername = "user",
+                grantTypes = new string[] { }
+            };
+            creatorConfig.authorizationServers.Add(authorizationServer);
+
+            // act
+            Template authorizationServerTemplate = authorizationServerTemplateCreator.CreateAuthorizationServerTemplate(creatorConfig);
+            AuthorizationServerTemplateResource authorizationServerTemplateResource = (AuthorizationServerTemplateResource)authorizationServerTemplate.resources[0];
+
+            // assert
+            Assert.Equal($"[concat(parameters('ApimServiceName'), '/{authorizationServer.displayName}')]", authorizationServerTemplateResource.name);
+            Assert.Equal(authorizationServer.description, authorizationServerTemplateResource.properties.description);
+            Assert.Equal(authorizationServer.displayName, authorizationServerTemplateResource.properties.displayName);
+            Assert.Equal(authorizationServer.authorizationEndpoint, authorizationServerTemplateResource.properties.authorizationEndpoint);
+            Assert.Equal(authorizationServer.authorizationMethods, authorizationServerTemplateResource.properties.authorizationMethods);
+            Assert.Equal(authorizationServer.clientAuthenticationMethod, authorizationServerTemplateResource.properties.clientAuthenticationMethod);
+            Assert.Equal(authorizationServer.clientId, authorizationServerTemplateResource.properties.clientId);
+            Assert.Equal(authorizationServer.clientRegistrationEndpoint, authorizationServerTemplateResource.properties.clientRegistrationEndpoint);
+            Assert.Equal(authorizationServer.clientSecret, authorizationServerTemplateResource.properties.clientSecret);
+            Assert.Equal(authorizationServer.bearerTokenSendingMethods, authorizationServerTemplateResource.properties.bearerTokenSendingMethods);
+            Assert.Equal(authorizationServer.grantTypes, authorizationServerTemplateResource.properties.grantTypes);
+            Assert.Equal(authorizationServer.resourceOwnerPassword, authorizationServerTemplateResource.properties.resourceOwnerPassword);
+            Assert.Equal(authorizationServer.resourceOwnerUsername, authorizationServerTemplateResource.properties.resourceOwnerUsername);
+            Assert.Equal(authorizationServer.defaultScope, authorizationServerTemplateResource.properties.defaultScope);
+            Assert.Equal(authorizationServer.supportState, authorizationServerTemplateResource.properties.supportState);
+            Assert.Equal(authorizationServer.tokenBodyParameters[0].name, authorizationServerTemplateResource.properties.tokenBodyParameters[0].name);
+            Assert.Equal(authorizationServer.tokenBodyParameters[0].value, authorizationServerTemplateResource.properties.tokenBodyParameters[0].value);
+        }
+    }
+}
diff --git a/src/APIM_ARMTemplate/apimtemplate.test/Creator/TemplateCreatorTests/BackendTemplateCreatorTests.cs b/src/APIM_ARMTemplate/apimtemplate.test/Creator/TemplateCreatorTests/BackendTemplateCreatorTests.cs
@@ -0,0 +1,93 @@
+﻿using Xunit;
+using Microsoft.Azure.Management.ApiManagement.ArmTemplates.Common;
+using Microsoft.Azure.Management.ApiManagement.ArmTemplates.Create;
+using System.Collections.Generic;
+
+namespace Microsoft.Azure.Management.ApiManagement.ArmTemplates.Test
+{
+    public class BackendTemplateCreatorTests
+    {
+        [Fact]
+        public void ShouldCreateBackendTemplateFromCreatorConfig()
+        {
+            // arrange
+            BackendTemplateCreator backendTemplateCreator = new BackendTemplateCreator();
+            CreatorConfig creatorConfig = new CreatorConfig() { backends = new List<BackendTemplateProperties>() };
+            BackendTemplateProperties backend = new BackendTemplateProperties()
+            {
+                title = "title",
+                description = "description",
+                resourceId = "resourceId",
+                url = "url",
+                protocol = "protocol",
+                proxy = new BackendProxy()
+                {
+                    url = "url",
+                    username = "user",
+                    password = "pass"
+                },
+                tls = new BackendTLS()
+                {
+                    validateCertificateChain = true,
+                    validateCertificateName = true
+                },
+                credentials = new BackendCredentials()
+                {
+                    certificate = new string[] { "cert1" },
+                    query = new object(),
+                    header = new object(),
+                    authorization = new BackendCredentialsAuthorization()
+                    {
+                        scheme = "scheme",
+                        parameter = "parameter"
+                    }
+                },
+                properties = new BackendSubProperties()
+                {
+                    serviceFabricCluster = new BackendServiceFabricCluster()
+                    {
+                        clientCertificatethumbprint = "",
+                        managementEndpoints = new string[] { "endpoint" },
+                        maxPartitionResolutionRetries = 1,
+                        serverCertificateThumbprints = new string[] { "thumbprint" },
+                        serverX509Names = new ServerX509Names[]{
+                        new ServerX509Names(){
+                            name = "name",
+                            issuerCertificateThumbprint = "thumbprint"
+                        } }
+                    }
+                }
+
+            };
+            creatorConfig.backends.Add(backend);
+
+            // act
+            Template backendTemplate = backendTemplateCreator.CreateBackendTemplate(creatorConfig);
+            BackendTemplateResource backendTemplateResource = (BackendTemplateResource)backendTemplate.resources[0];
+
+            // assert
+            Assert.Equal($"[concat(parameters('ApimServiceName'), '/{backend.title}')]", backendTemplateResource.name);
+            Assert.Equal(backend.title, backendTemplateResource.properties.title);
+            Assert.Equal(backend.description, backendTemplateResource.properties.description);
+            Assert.Equal(backend.resourceId, backendTemplateResource.properties.resourceId);
+            Assert.Equal(backend.url, backendTemplateResource.properties.url);
+            Assert.Equal(backend.protocol, backendTemplateResource.properties.protocol);
+            Assert.Equal(backend.proxy.url, backendTemplateResource.properties.proxy.url);
+            Assert.Equal(backend.proxy.username, backendTemplateResource.properties.proxy.username);
+            Assert.Equal(backend.proxy.password, backendTemplateResource.properties.proxy.password);
+            Assert.Equal(backend.tls.validateCertificateChain, backendTemplateResource.properties.tls.validateCertificateChain);
+            Assert.Equal(backend.tls.validateCertificateName, backendTemplateResource.properties.tls.validateCertificateName);
+            Assert.Equal(backend.credentials.certificate, backendTemplateResource.properties.credentials.certificate);
+            Assert.Equal(backend.credentials.query, backendTemplateResource.properties.credentials.query);
+            Assert.Equal(backend.credentials.header, backendTemplateResource.properties.credentials.header);
+            Assert.Equal(backend.credentials.authorization.scheme, backendTemplateResource.properties.credentials.authorization.scheme);
+            Assert.Equal(backend.credentials.authorization.parameter, backendTemplateResource.properties.credentials.authorization.parameter);
+            Assert.Equal(backend.properties.serviceFabricCluster.clientCertificatethumbprint, backendTemplateResource.properties.properties.serviceFabricCluster.clientCertificatethumbprint);
+            Assert.Equal(backend.properties.serviceFabricCluster.managementEndpoints, backendTemplateResource.properties.properties.serviceFabricCluster.managementEndpoints);
+            Assert.Equal(backend.properties.serviceFabricCluster.maxPartitionResolutionRetries, backendTemplateResource.properties.properties.serviceFabricCluster.maxPartitionResolutionRetries);
+            Assert.Equal(backend.properties.serviceFabricCluster.serverCertificateThumbprints, backendTemplateResource.properties.properties.serviceFabricCluster.serverCertificateThumbprints);
+            Assert.Equal(backend.properties.serviceFabricCluster.serverX509Names[0].issuerCertificateThumbprint, backendTemplateResource.properties.properties.serviceFabricCluster.serverX509Names[0].issuerCertificateThumbprint);
+            Assert.Equal(backend.properties.serviceFabricCluster.serverX509Names[0].name, backendTemplateResource.properties.properties.serviceFabricCluster.serverX509Names[0].name);
+        }
+    }
+}
diff --git a/src/APIM_ARMTemplate/apimtemplate.test/Creator/TemplateCreatorTests/LoggerTemplateCreatorTests.cs b/src/APIM_ARMTemplate/apimtemplate.test/Creator/TemplateCreatorTests/LoggerTemplateCreatorTests.cs
@@ -0,0 +1,48 @@
+﻿using Xunit;
+using Microsoft.Azure.Management.ApiManagement.ArmTemplates.Common;
+using Microsoft.Azure.Management.ApiManagement.ArmTemplates.Create;
+using System.Collections.Generic;
+
+namespace Microsoft.Azure.Management.ApiManagement.ArmTemplates.Test
+{
+    public class LoggerTemplateCreatorTests
+    {
+        [Fact]
+        public void ShouldCreateLoggerTemplateFromCreatorConfig()
+        {
+            // arrange
+            LoggerTemplateCreator loggerTemplateCreator = new LoggerTemplateCreator();
+            CreatorConfig creatorConfig = new CreatorConfig() { loggers = new List<LoggerConfig>() };
+            LoggerConfig logger = new LoggerConfig()
+            {
+                name = "name",
+                loggerType = "applicationinsights",
+                description = "description",
+                isBuffered = true,
+                resourceId = "resourceId",
+                credentials = new LoggerCredentials()
+                {
+                    connectionString = "connString",
+                    instrumentationKey = "iKey",
+                    name = "credName"
+                }
+
+            };
+            creatorConfig.loggers.Add(logger);
+
+            // act
+            Template loggerTemplate = loggerTemplateCreator.CreateLoggerTemplate(creatorConfig);
+            LoggerTemplateResource loggerTemplateResource = (LoggerTemplateResource)loggerTemplate.resources[0];
+
+            // assert
+            Assert.Equal($"[concat(parameters('ApimServiceName'), '/{logger.name}')]", loggerTemplateResource.name);
+            Assert.Equal(logger.loggerType, loggerTemplateResource.properties.loggerType);
+            Assert.Equal(logger.description, loggerTemplateResource.properties.description);
+            Assert.Equal(logger.isBuffered, loggerTemplateResource.properties.isBuffered);
+            Assert.Equal(logger.resourceId, loggerTemplateResource.properties.resourceId);
+            Assert.Equal(logger.credentials.connectionString, loggerTemplateResource.properties.credentials.connectionString);
+            Assert.Equal(logger.credentials.instrumentationKey, loggerTemplateResource.properties.credentials.instrumentationKey);
+            Assert.Equal(logger.credentials.name, loggerTemplateResource.properties.credentials.name);
+        }
+    }
+}
diff --git a/src/APIM_ARMTemplate/apimtemplate.test/Creator/TemplateCreatorTests/MasterTemplateCreatorTests.cs b/src/APIM_ARMTemplate/apimtemplate.test/Creator/TemplateCreatorTests/MasterTemplateCreatorTests.cs
@@ -7,6 +7,28 @@ namespace Microsoft.Azure.Management.ApiManagement.ArmTemplates.Test
 {
     public class MasterTemplateCreatorTests
     {
+        [Fact]
+        public void ShouldCreateCorrectNumberOfDeploymentResources()
+        {
+            // arrange
+            MasterTemplateCreator masterTemplateCreator = new MasterTemplateCreator();
+            Template apiVersionSetsTemplate = new Template();
+            Template productsTemplate = new Template();
+            Template loggersTemplate = new Template();
+            List<LinkedMasterTemplateAPIInformation> apiInfoList = new List<LinkedMasterTemplateAPIInformation>() { new LinkedMasterTemplateAPIInformation() { name = "api", isSplit = true } };
+            FileNameGenerator fileNameGenerator = new FileNameGenerator();
+            CreatorFileNames creatorFileNames = fileNameGenerator.GenerateCreatorLinkedFileNames();
+
+            // should create 5 resources (apiVersionSet, product, logger, both api templates)
+            int count = 5;
+
+            // act
+            Template masterTemplate = masterTemplateCreator.CreateLinkedMasterTemplate(apiVersionSetsTemplate, productsTemplate, loggersTemplate, null, null, apiInfoList, creatorFileNames, fileNameGenerator);
+
+            // assert
+            Assert.Equal(count, masterTemplate.resources.Length);
+        }
+
         [Fact]
         public void ShouldCreateCorrectNumberOfParameterValuesWhenLinked()
         {
diff --git a/src/APIM_ARMTemplate/apimtemplate.test/Creator/TemplateCreatorTests/PolicyTemplateCreatorTests.cs b/src/APIM_ARMTemplate/apimtemplate.test/Creator/TemplateCreatorTests/PolicyTemplateCreatorTests.cs
@@ -21,7 +21,6 @@ public void ShouldCreateAPIPolicyTemplateResourceFromCreatorConfigWithCorrectCon
             creatorConfig.apis.Add(api);
             string[] dependsOn = new string[] { "dependsOn" };
 
-
             // act
             PolicyTemplateResource policyTemplateResource = policyTemplateCreator.CreateAPIPolicyTemplateResource(api, dependsOn);
 
@@ -41,7 +40,6 @@ public void ShouldCreateOperationPolicyTemplateResourceFromPairWithCorrectConten
             string apiName = "apiName";
             string[] dependsOn = new string[] { "dependsOn" };
 
-
             // act
             PolicyTemplateResource policyTemplateResource = policyTemplateCreator.CreateOperationPolicyTemplateResource(policyPair, apiName, dependsOn);
 
diff --git a/src/APIM_ARMTemplate/apimtemplate.test/Creator/TemplateCreatorTests/ProductTemplateCreatorTests.cs b/src/APIM_ARMTemplate/apimtemplate.test/Creator/TemplateCreatorTests/ProductTemplateCreatorTests.cs
diff --git a/src/APIM_ARMTemplate/apimtemplate/Commands/Create.cs b/src/APIM_ARMTemplate/apimtemplate/Commands/Create.cs
diff --git a/src/APIM_ARMTemplate/apimtemplate/Common/FileHandlers/FileNameGenerator.cs b/src/APIM_ARMTemplate/apimtemplate/Common/FileHandlers/FileNameGenerator.cs
