/// <summary>
/// Generates an api dictionary with apiName/versionsetName (if exist one) as key, list of apiNames as value
/// </summary>
/// <returns></returns>
async Task <Dictionary <string, List <string> > > GetAllAPIsDictionary(ExtractorParameters extractorParameters)
{
// pull all apis from service
var apis = await this.apisClient.GetAllAsync(extractorParameters);
// Generate folders based on all apiversionset
var apiDictionary = new Dictionary <string, List <string> >();
foreach (var api in apis)
{
string apiDisplayName = api.Properties.DisplayName;
if (!apiDictionary.ContainsKey(apiDisplayName))
{
var apiVersionSet = new List <string>();
apiVersionSet.Add(api.Name);
apiDictionary[apiDisplayName] = apiVersionSet;
}
else
{
apiDictionary[apiDisplayName].Add(api.Name);
}
}
return(apiDictionary);
}
public static string GetPolicyContent(ExtractorParameters extractorParameters, PolicyTemplateResource policyTemplateResource)
{
// the backend is used in a policy if the xml contains a set-backend-service policy, which will reference the backend's url or id
string policyContent = policyTemplateResource.Properties.PolicyContent;
// check if this is a file or is it the raw policy content
if (policyContent.Contains(".xml"))
{
var key = policyContent;
//check cache
if (PolicyCache.TryGetValue(key, out string content))
{
return(content);
}
var filename = policyContent.Split(',')[1].Replace("'", string.Empty).Trim();
var policyFolder = $@"{extractorParameters.FilesGenerationRootDirectory}/policies";
var filepath = $@"{Directory.GetCurrentDirectory()}/{policyFolder}/{filename}";
if (File.Exists(filepath))
{
policyContent = File.ReadAllText(filepath);
PolicyCache.Set(key, policyContent);
}
}
return(policyContent);
}
public void ExtractorConfigValidate_NoPropertiesSet_MissingParameterException()
{
var defaultExtractorConfig = new ExtractorConsoleAppConfiguration
{
IncludeAllRevisions = true.ToString(),
ParamApiLoggerId = true.ToString(),
ParamBackend = true.ToString(),
ParamLogResourceId = true.ToString(),
ParamNamedValue = true.ToString(),
ParamNamedValuesKeyVaultSecrets = true.ToString(),
ParamServiceUrl = true.ToString(),
NotIncludeNamedValue = true.ToString(),
SplitAPIs = true.ToString(),
ExtractGateways = true.ToString()
};
var extractorParameters = new ExtractorParameters(defaultExtractorConfig);
extractorParameters = extractorParameters.OverrideConfiguration(new ExtractorConsoleAppConfiguration());
extractorParameters.IncludeAllRevisions.Should().BeTrue();
extractorParameters.ParameterizeServiceUrl.Should().BeTrue();
extractorParameters.ParameterizeNamedValue.Should().BeTrue();
extractorParameters.ParameterizeApiLoggerId.Should().BeTrue();
extractorParameters.ParameterizeLogResourceId.Should().BeTrue();
extractorParameters.NotIncludeNamedValue.Should().BeTrue();
extractorParameters.ParamNamedValuesKeyVaultSecrets.Should().BeTrue();
extractorParameters.ParameterizeBackend.Should().BeTrue();
extractorParameters.SplitApis.Should().BeTrue();
extractorParameters.IncludeAllRevisions.Should().BeTrue();
extractorParameters.ExtractGateways.Should().BeTrue();
}
public async Task <PolicyTemplateResource> GenerateApiOperationPolicyResourceAsync(
string apiName,
string operationName,
string baseFilesGenerationDirectory,
ExtractorParameters extractorParameters)
{
var apiOperationPolicy = await this.policyClient.GetPolicyLinkedToApiOperationAsync(apiName, operationName, extractorParameters);
if (apiOperationPolicy is null)
{
this.logger.LogWarning("Policy for api '{0}' and operation '{1}' not found", apiName, operationName);
return(apiOperationPolicy);
}
apiOperationPolicy.Name = $"[concat(parameters('{ParameterNames.ApimServiceName}'), '/{apiName}/{operationName}/policy')]";
apiOperationPolicy.ApiVersion = GlobalConstants.ApiVersion;
apiOperationPolicy.Scale = null;
apiOperationPolicy.DependsOn = new string[] { $"[resourceId('Microsoft.ApiManagement/service/apis/operations', parameters('{ParameterNames.ApimServiceName}'), '{apiName}', '{operationName}')]" };
// write policy xml content to file and point to it if policyXMLBaseUrl is provided
if (extractorParameters.PolicyXMLBaseUrl is not null)
{
var policyFileName = string.Format(ApiOperationPolicyFileNameFormat, apiName, operationName);
await this.SavePolicyXmlAsync(apiOperationPolicy, baseFilesGenerationDirectory, policyFileName);
this.SetPolicyTemplateResourcePolicyContentWithArmPresetValues(extractorParameters, apiOperationPolicy, policyFileName);
}
return(apiOperationPolicy);
}
public async Task <Template <ApiVersionSetTemplateResources> > GenerateApiVersionSetTemplateAsync(
string singleApiName,
List <ApiTemplateResource> apiTemplateResources,
ExtractorParameters extractorParameters)
{
var apiVersionSetTemplate = this.templateBuilder
.GenerateTemplateWithApimServiceNameProperty()
.Build <ApiVersionSetTemplateResources>();
var apiVersionSets = await this.apiVersionSetClient.GetAllAsync(extractorParameters);
foreach (var apiVersionSet in apiVersionSets)
{
// only extract the product if this is a full extraction, or in the case of a single api, if it is found in products associated with the api
if (string.IsNullOrEmpty(singleApiName) || apiTemplateResources.SingleOrDefault(api =>
api.Properties.ApiVersionSetId != null &&
api.Properties.ApiVersionSetId.Contains(apiVersionSet.Name)) != null)
{
this.logger.LogDebug("Found '{0}' api-version-set", apiVersionSet.Name);
apiVersionSet.Name = $"[concat(parameters('{ParameterNames.ApimServiceName}'), '/{apiVersionSet.Name}')]";
apiVersionSet.Type = ResourceTypeConstants.ApiVersionSet;
apiVersionSet.ApiVersion = GlobalConstants.ApiVersion;
apiVersionSetTemplate.TypedResources.ApiVersionSets.Add(apiVersionSet);
}
}
return(apiVersionSetTemplate);
}
public async Task <List <ProductApiTemplateResource> > GenerateSingleApiTemplateAsync(
string singleApiName,
ExtractorParameters extractorParameters,
bool addDependsOnParameter = false)
{
try
{
var serviceApi = await this.apisClient.GetSingleAsync(singleApiName, extractorParameters);
if (serviceApi is null)
{
throw new ServiceApiNotFoundException($"ServiceApi with name '{singleApiName}' not found");
}
this.logger.LogInformation("{0} Product API found ...", singleApiName);
var dependsOnParameter = addDependsOnParameter
? new string[] { $"[resourceId('Microsoft.ApiManagement/service/apis', parameters('{ParameterNames.ApimServiceName}'), '{singleApiName}')]" }
: Array.Empty <string>();
return(await this.GenerateProductApiTemplateResourcesAsync(singleApiName, extractorParameters, dependsOnParameter));
}
catch (Exception ex)
{
this.logger.LogError(ex, $"Exception occured while generating service api products template for {singleApiName}.");
throw;
}
}
public async Task <Template <ProductTemplateResources> > GenerateProductsTemplateAsync(
string singleApiName,
List <ProductApiTemplateResource> productApiTemplateResources,
string baseFilesGenerationDirectory,
ExtractorParameters extractorParameters)
{
var productsTemplate = this.templateBuilder
.GenerateTemplateWithPresetProperties(extractorParameters)
.Build <ProductTemplateResources>();
var products = await this.productsClient.GetAllAsync(extractorParameters);
foreach (var productTemplateResource in products)
{
var productOriginalName = productTemplateResource.Name;
productTemplateResource.Name = $"[concat(parameters('{ParameterNames.ApimServiceName}'), '/{productOriginalName}')]";
productTemplateResource.ApiVersion = GlobalConstants.ApiVersion;
// only extract the product if this is a full extraction, or in the case of a single api, if it is found in products associated with the api
if (singleApiName == null || productApiTemplateResources.SingleOrDefault(p => p.Name.Contains($"/{productOriginalName}/")) != null)
{
this.logger.LogDebug("'{0}' product found", productOriginalName);
productsTemplate.TypedResources.Products.Add(productTemplateResource);
await this.AddProductPolicyToTemplateResources(extractorParameters, productOriginalName, productsTemplate.TypedResources, baseFilesGenerationDirectory);
await this.AddProductTagsToTemplateResources(extractorParameters, productOriginalName, productsTemplate.TypedResources);
}
}
return(productsTemplate);
}
async Task AddProductTagsToTemplateResources(
ExtractorParameters extractorParameters,
string productName,
ProductTemplateResources productTemplateResources)
{
try
{
var productTags = await this.tagClient.GetAllTagsLinkedToProductAsync(productName, extractorParameters);
if (productTags.IsNullOrEmpty())
{
this.logger.LogWarning($"No tags found for product {productName}");
return;
}
foreach (var productTag in productTags)
{
string originalTagName = productTag.Name;
this.logger.LogDebug("'{0}' tag association found for {1} product", originalTagName, productName);
productTag.Name = $"[concat(parameters('{ParameterNames.ApimServiceName}'), '/{productName}/{originalTagName}')]";
productTag.Type = ResourceTypeConstants.ProductTag;
productTag.ApiVersion = GlobalConstants.ApiVersion;
productTag.Scale = null;
productTag.DependsOn = new string[] { $"[resourceId('Microsoft.ApiManagement/service/products', parameters('{ParameterNames.ApimServiceName}'), '{productName}')]" };
productTemplateResources.Tags.Add(productTag);
}
}
catch (Exception ex)
{
this.logger.LogError(ex, "Exception occured while product tags template generation");
throw;
}
}
public async Task <Template <ApiTemplateResources> > GenerateApiRevisionTemplateAsync(
string currentRevision,
List <string> revList,
string baseFilesGenerationDirectory,
ExtractorParameters extractorParameters)
{
var apiRevisionTemplate = this.templateBuilder
.GenerateTemplateWithPresetProperties(extractorParameters)
.Build <ApiTemplateResources>();
foreach (string curApi in revList)
{
// should add current api to dependsOn to those revisions that are not "current"
if (curApi.Equals(currentRevision))
{
var apiResources = await this.apiExtractor.GenerateSingleApiTemplateResourcesAsync(currentRevision, baseFilesGenerationDirectory, extractorParameters);
apiRevisionTemplate.TypedResources.AddResourcesData(apiResources);
}
else
{
var apiResources = await this.apiExtractor.GenerateSingleApiTemplateResourcesAsync(curApi, baseFilesGenerationDirectory, extractorParameters);
var apiResource = apiResources.Apis.FirstOrDefault();
apiResource.DependsOn = new[] { $"[resourceId('Microsoft.ApiManagement/service/apis', parameters('{ParameterNames.ApimServiceName}'), '{extractorParameters.SingleApiName}')]" };
apiRevisionTemplate.TypedResources.AddResourcesData(apiResources);
}
}
return(apiRevisionTemplate);
}
public async Task <PolicyTemplateResource> GenerateProductPolicyTemplateAsync(
ExtractorParameters extractorParameters,
string productName,
string[] productResourceId,
string baseFilesGenerationDirectory)
{
var productPolicy = await this.policyClient.GetPolicyLinkedToProductAsync(productName, extractorParameters);
if (productPolicy is null)
{
this.logger.LogWarning($"Policy not found for product '{productName}'");
return(productPolicy);
}
this.logger.LogDebug($"Policy linked to {productName} product found successfuly");
productPolicy.Name = $"[concat(parameters('{ParameterNames.ApimServiceName}'), '/{productName}/policy')]";
productPolicy.ApiVersion = GlobalConstants.ApiVersion;
productPolicy.Scale = null;
productPolicy.DependsOn = productResourceId;
// due to legacy reasons, providing empty `policyXmlBaseUrl = ""` is recognized as a boolean parameter
// telling that it is needed to provide a policy Xml file
if (extractorParameters.PolicyXMLBaseUrl is not null)
{
var policyFileName = string.Format(ProductPolicyFileNameFormat, productName);
await this.SavePolicyXmlAsync(productPolicy, baseFilesGenerationDirectory, policyFileName);
this.SetPolicyTemplateResourcePolicyContentWithArmPresetValues(extractorParameters, productPolicy, policyFileName);
}
return(productPolicy);
}
public async Task <Template <TagApiTemplateResources> > GenerateApiTagsTemplateAsync(
string singleApiName,
List <string> multipleApiNames,
ExtractorParameters extractorParameters)
{
var tagApiTemplate = this.templateBuilder
.GenerateTemplateWithApimServiceNameProperty()
.Build <TagApiTemplateResources>();
if (!string.IsNullOrEmpty(singleApiName))
{
tagApiTemplate.TypedResources = await this.GenerateSingleApiTagResourceAsync(singleApiName, extractorParameters, Array.Empty <string>());
}
else if (!multipleApiNames.IsNullOrEmpty())
{
tagApiTemplate.TypedResources = await this.GenerateMultipleApisTemplateAsync(multipleApiNames, extractorParameters);
}
else
{
var serviceApis = await this.apisClient.GetAllAsync(extractorParameters);
this.logger.LogDebug("{0} APIs found ...", serviceApis.Count);
var serviceApiNames = serviceApis.Select(api => api.Name).ToList();
tagApiTemplate.TypedResources = await this.GenerateMultipleApisTemplateAsync(serviceApiNames, extractorParameters);
}
return(tagApiTemplate);
}
public async Task <Template <GatewayApiTemplateResources> > GenerateGatewayApiTemplateAsync(
string singleApiName,
List <string> multipleApiNames,
ExtractorParameters extractorParameters)
{
var gatewayApiTemplate = this.templateBuilder
.GenerateTemplateWithApimServiceNameProperty()
.Build <GatewayApiTemplateResources>();
var gateways = await this.gatewayClient.GetAllAsync(extractorParameters);
if (gateways.IsNullOrEmpty())
{
this.logger.LogWarning("No Gateways data was found for {0}", extractorParameters.SourceApimName);
return(gatewayApiTemplate);
}
var multipleApiNamesSet = multipleApiNames?.ToHashSet();
foreach (var gateway in gateways)
{
var gatewayApis = await this.apisClient.GetAllLinkedToGatewayAsync(gateway.Name, extractorParameters);
if (gatewayApis.IsNullOrEmpty())
{
this.logger.LogWarning("No gateway apis were found for gateway '{0}'", gateway.Name);
continue;
}
if (!string.IsNullOrEmpty(singleApiName))
{
// inluding only apis with singleApiName
var apis = gatewayApis.Where(x => x.Name == singleApiName);
if (!apis.IsNullOrEmpty())
{
var gatewayApiResources = this.GenerateGatewayApiTemplateResources(gateway.Name, apis);
gatewayApiTemplate.TypedResources.GatewayApis.AddRange(gatewayApiResources);
}
}
else if (!multipleApiNames.IsNullOrEmpty())
{
// including only apis existing in multipleApiNames
var apis = gatewayApis.Where(x => multipleApiNamesSet.Contains(x.Name));
if (!apis.IsNullOrEmpty())
{
var gatewayApiResources = this.GenerateGatewayApiTemplateResources(gateway.Name, apis);
gatewayApiTemplate.TypedResources.GatewayApis.AddRange(gatewayApiResources);
}
}
else
{
// including every api in response
var gatewayApiResources = this.GenerateGatewayApiTemplateResources(gateway.Name, gatewayApis);
gatewayApiTemplate.TypedResources.GatewayApis.AddRange(gatewayApiResources);
}
}
return(gatewayApiTemplate);
}
public async Task <PolicyTemplateResource> GetGlobalServicePolicyAsync(ExtractorParameters extractorParameters)
{
var(azToken, azSubId) = await this.Auth.GetAccessToken();
string requestUrl = string.Format(GetGlobalServicePolicyRequest,
this.BaseUrl, azSubId, extractorParameters.ResourceGroup, extractorParameters.SourceApimName, GlobalConstants.ApiVersion);
return(await this.CallApiManagementAsync <PolicyTemplateResource>(azToken, requestUrl));
}
public void SetExtractorParameters(ExtractorConsoleAppConfiguration extractorConfiguration)
{
this.extractorParameters = new ExtractorParameters(extractorConfiguration);
if (!string.IsNullOrEmpty(extractorConfiguration.ServiceBaseUrl))
{
GlobalConstants.BaseManagementAzureUrl = extractorConfiguration.ServiceBaseUrl;
}
}
public void SetExtractorParameters(ExtractorConsoleAppConfiguration extractorConfiguration)
{
this.extractorParameters = new ExtractorParameters(extractorConfiguration);
if (!string.IsNullOrEmpty(extractorConfiguration.ServiceBaseUrl))
{
EntityExtractorBase.BaseUrl = extractorConfiguration.ServiceBaseUrl;
}
}
public void ExtractorConfigValidate_NoPropertiesSet_MissingParameterException()
{
var extractorConfig = new ExtractorConsoleAppConfiguration();
var extractorParameters = new ExtractorParameters(extractorConfig);
var expectedException = Assert.Throws <ArgumentException>(() => extractorParameters.Validate());
Assert.Contains("Missing parameter", expectedException.Message);
}
public async Task GenerateProductApisTemplates_ProperlyLaysTheInformation()
{
// arrange
var currentTestDirectory = Path.Combine(this.OutputDirectory, nameof(GenerateProductApisTemplates_ProperlyLaysTheInformation));
var extractorConfig = this.GetMockedExtractorConsoleAppConfiguration(
splitApis: false,
apiVersionSetName: string.Empty,
multipleApiNames: string.Empty,
includeAllRevisions: false);
var extractorParameters = new ExtractorParameters(extractorConfig);
var mockedServiceApisApiClient = MockApisClient.GetMockedApiClientWithDefaultValues();
var mockedServiceApisProductsApiClient = MockProductsClient.GetMockedApiClientWithDefaultValues();
var productApisExtractor = new ProductApisExtractor(
this.GetTestLogger <ProductApisExtractor>(),
mockedServiceApisProductsApiClient,
mockedServiceApisApiClient,
new TemplateBuilder());
var extractorExecutor = ExtractorExecutor.BuildExtractorExecutor(
this.GetTestLogger <ExtractorExecutor>(),
productApisExtractor: productApisExtractor);
extractorExecutor.SetExtractorParameters(extractorParameters);
// act
var productApisTemplate = await extractorExecutor.GenerateProductApisTemplateAsync(
singleApiName : It.IsAny <string>(),
multipleApiNames : It.IsAny <List <string> >(),
currentTestDirectory);
// assert
File.Exists(Path.Combine(currentTestDirectory, extractorParameters.FileNames.ProductAPIs)).Should().BeTrue();
productApisTemplate.Parameters.Should().ContainKey(ParameterNames.ApimServiceName);
productApisTemplate.TypedResources.ProductApis.Count().Should().Be(2);
productApisTemplate.Resources.Count().Should().Be(2);
var productApi1 = productApisTemplate.TypedResources.ProductApis.First();
productApi1.ApiVersion.Should().Be(GlobalConstants.ApiVersion);
productApi1.Name.Should().NotBeNullOrEmpty();
productApi1.Type.Should().Be(ResourceTypeConstants.ProductApi);
productApi1.Properties.DisplayName.Should().NotBeNullOrEmpty();
productApi1.Properties.Description.Should().NotBeNullOrEmpty();
var productApi2 = productApisTemplate.TypedResources.ProductApis.Last();
productApi2.ApiVersion.Should().Be(GlobalConstants.ApiVersion);
productApi2.Name.Should().NotBeNullOrEmpty();
productApi2.Type.Should().Be(ResourceTypeConstants.ProductApi);
productApi2.Properties.DisplayName.Should().NotBeNullOrEmpty();
productApi2.Properties.Description.Should().NotBeNullOrEmpty();
productApi2.DependsOn.Should().NotBeNullOrEmpty();
}
public async Task <bool> IsNamedValueUsedInBackends(
string singleApiName,
List <PolicyTemplateResource> apiPolicies,
string propertyName,
string propertyDisplayName,
ExtractorParameters extractorParameters,
string baseFilesGenerationDirectory)
{
var backends = await this.backendClient.GetAllAsync(extractorParameters);
if (backends.IsNullOrEmpty())
{
this.logger.LogWarning("No backends found for apim instance '{0}'", extractorParameters.SourceApimName);
return(false);
}
foreach (var backendResource in backends)
{
var backendContent = backendResource.Serialize();
// check if backend references the named value, credentials for example
if (backendContent.Contains(string.Concat("{{", propertyName, "}}")) ||
backendContent.Contains(string.Concat("{{", propertyDisplayName, "}}")))
{
//only true if this is a full extraction, or in the case of a single api, if it is referenced by one of the API policies
if (string.IsNullOrEmpty(singleApiName))
{
return(true);
}
else
{
// is this backend related to the single api?
// is backend used in the extracted policies for this API
// if backend id is referenced in policy
// or a named value is referenced in policy to a backend, we have already checked the policy for named value.
// check if this backend is used by any of the policies extracted
var backendName = backendResource.Name;
// we have already checked if the named value is used in a policy, we just need to confirm if the backend is referenced by this single api within the policy file
// this is why an empty named values must be passed to this method for validation
foreach (var policyTemplateResource in apiPolicies)
{
var policyContent = this.policyExtractor.GetCachedPolicyContent(policyTemplateResource, baseFilesGenerationDirectory);
if (this.DoesPolicyReferenceBackend(policyContent, Array.Empty <NamedValueTemplateResource>(), backendName, backendResource))
{
// don't need to go through all policies and backends if the named values has already been found
return(true);
}
}
}
}
}
return(false);
}
public async Task GenerateBackendTemplates_ProperlyLaysTheInformation()
{
// arrange
var currentTestDirectory = Path.Combine(this.OutputDirectory, nameof(GenerateBackendTemplates_ProperlyLaysTheInformation));
var extractorConfig = this.GetMockedExtractorConsoleAppConfiguration(
splitApis: false,
apiVersionSetName: string.Empty,
multipleApiNames: string.Empty,
includeAllRevisions: false);
var extractorParameters = new ExtractorParameters(extractorConfig);
var mockPolicyExtractor = new Mock <IPolicyExtractor>(MockBehavior.Strict);
mockPolicyExtractor
.Setup(x => x.GetCachedPolicyContent(It.IsAny <PolicyTemplateResource>(), It.IsAny <string>()))
.Returns((PolicyTemplateResource policy, string _) => $"mock-response-from-policy-{policy.Name}");
var mockBackendClient = MockBackendClient.GetMockedApiClientWithDefaultValues();
var backendExtractor = new BackendExtractor(
this.GetTestLogger <BackendExtractor>(),
new TemplateBuilder(),
mockPolicyExtractor.Object,
mockBackendClient);
var extractorExecutor = ExtractorExecutor.BuildExtractorExecutor(
this.GetTestLogger <ExtractorExecutor>(),
backendExtractor: backendExtractor);
extractorExecutor.SetExtractorParameters(extractorParameters);
// act
var backendTemplate = await extractorExecutor.GenerateBackendTemplateAsync(
singleApiName : null,
new List <PolicyTemplateResource>(),
new List <NamedValueTemplateResource>(),
currentTestDirectory);
// assert
File.Exists(Path.Combine(currentTestDirectory, extractorParameters.FileNames.Backends)).Should().BeTrue();
backendTemplate.Parameters.Should().ContainKey(ParameterNames.ApimServiceName);
backendTemplate.Parameters.Should().ContainKey(ParameterNames.BackendSettings);
backendTemplate.TypedResources.Backends.Should().HaveCount(1);
backendTemplate.Resources.Should().HaveCount(1);
backendTemplate.TypedResources.Backends.First().Type.Should().Be(ResourceTypeConstants.Backend);
backendTemplate.TypedResources.Backends.First().Name.Should().Contain(MockBackendClient.BackendName);
var backendProperties = backendTemplate.TypedResources.Backends.First().Properties;
backendProperties.Should().NotBeNull();
backendProperties.Url.Should().Contain(ParameterNames.BackendSettings);
backendProperties.Protocol.Should().Contain(ParameterNames.BackendSettings);
}
string GenerateLinkedTemplateUri(string fileName, ExtractorParameters extractorParameters)
{
var linkedTemplateUri = !string.IsNullOrEmpty(extractorParameters.LinkedTemplatesSasToken)
? $"parameters('{ParameterNames.LinkedTemplatesBaseUrl}'), '{fileName}', parameters('{ParameterNames.LinkedTemplatesSasToken}')"
: $"parameters('{ParameterNames.LinkedTemplatesBaseUrl}'), '{fileName}'";
return(!string.IsNullOrEmpty(extractorParameters.LinkedTemplatesUrlQueryString)
? $"[concat({linkedTemplateUri}, parameters('{ParameterNames.LinkedTemplatesUrlQueryString}'))]"
: $"[concat({linkedTemplateUri})]");
}
public async Task GenerateApiVersionSetTemplates_ProperlyLaysTheInformation()
{
// arrange
var currentTestDirectory = Path.Combine(this.OutputDirectory, nameof(GenerateApiVersionSetTemplates_ProperlyLaysTheInformation));
var extractorConfig = this.GetMockedExtractorConsoleAppConfiguration(
splitApis: false,
apiVersionSetName: string.Empty,
multipleApiNames: string.Empty,
includeAllRevisions: false);
var extractorParameters = new ExtractorParameters(extractorConfig);
var mockedApiVersionSetClient = MockApiVersionSetClient.GetMockedApiClientWithDefaultValues();
var apiVersionSetExtractor = new ApiVersionSetExtractor(
this.GetTestLogger <ApiVersionSetExtractor>(),
new TemplateBuilder(),
mockedApiVersionSetClient);
var extractorExecutor = ExtractorExecutor.BuildExtractorExecutor(
this.GetTestLogger <ExtractorExecutor>(),
apiVersionSetExtractor: apiVersionSetExtractor);
extractorExecutor.SetExtractorParameters(extractorParameters);
// act
var apiVersionSetTemplate = await extractorExecutor.GenerateApiVersionSetTemplateAsync(
singleApiName : It.IsAny <string>(),
currentTestDirectory,
apiTemplateResources : It.IsAny <List <ApiTemplateResource> >());
// assert
File.Exists(Path.Combine(currentTestDirectory, extractorParameters.FileNames.ApiVersionSets)).Should().BeTrue();
apiVersionSetTemplate.Parameters.Should().ContainKey(ParameterNames.ApimServiceName);
apiVersionSetTemplate.TypedResources.ApiVersionSets.Count().Should().Be(2);
apiVersionSetTemplate.Resources.Count().Should().Be(2);
(apiVersionSetTemplate.Resources[0].Name.Contains(MockApiVersionSetClient.ApiVersionSetName1) ||
apiVersionSetTemplate.Resources[1].Name.Contains(MockApiVersionSetClient.ApiVersionSetName1)).Should().BeTrue();
(apiVersionSetTemplate.Resources[0].Name.Contains(MockApiVersionSetClient.ApiVersionSetName2) ||
apiVersionSetTemplate.Resources[1].Name.Contains(MockApiVersionSetClient.ApiVersionSetName2)).Should().BeTrue();
foreach (var templateResource in apiVersionSetTemplate.TypedResources.ApiVersionSets)
{
templateResource.Type.Should().Be(ResourceTypeConstants.ApiVersionSet);
templateResource.Properties.Should().NotBeNull();
templateResource.Properties.DisplayName.Should().NotBeNullOrEmpty();
templateResource.Properties.Description.Should().NotBeNullOrEmpty();
templateResource.Properties.VersionHeaderName.Should().NotBeNullOrEmpty();
templateResource.Properties.VersioningScheme.Should().NotBeNullOrEmpty();
templateResource.Properties.VersionQueryName.Should().NotBeNullOrEmpty();
}
}
public async Task <List <TagTemplateResource> > GetAllAsync(ExtractorParameters extractorParameters, int skipAmountOfRecords = 0)
{
var(azToken, azSubId) = await this.Auth.GetAccessToken();
var requestUrl = string.Format(GetAllTagsRequest,
this.BaseUrl, azSubId, extractorParameters.ResourceGroup, extractorParameters.SourceApimName, skipAmountOfRecords, GlobalConstants.ApiVersion);
var response = await this.CallApiManagementAsync <GetTagsResponse>(azToken, requestUrl);
return(response.Tags);
}
public async Task <List <DiagnosticTemplateResource> > GetAllAsync(ExtractorParameters extractorParameters)
{
var(azToken, azSubId) = await this.Auth.GetAccessToken();
var requestUrl = string.Format(GetAllDiagnosticsRequest,
this.BaseUrl, azSubId, extractorParameters.ResourceGroup, extractorParameters.SourceApimName, GlobalConstants.ApiVersion);
var response = await this.CallApiManagementAsync <GetDiagnosticsResponse>(azToken, requestUrl);
return(response.Diagnostics);
}
public async Task GenerateAuthorizationServerTemplates_ProperlyLaysTheInformation()
{
// arrange
var currentTestDirectory = Path.Combine(this.OutputDirectory, nameof(GenerateAuthorizationServerTemplates_ProperlyLaysTheInformation));
var extractorConfig = this.GetMockedExtractorConsoleAppConfiguration(
splitApis: false,
apiVersionSetName: string.Empty,
multipleApiNames: string.Empty,
includeAllRevisions: false);
var extractorParameters = new ExtractorParameters(extractorConfig);
var mockedAuthorizationServerClient = MockAuthorizationServerClient.GetMockedApiClientWithDefaultValues();
var authorizationServerExtractor = new AuthorizationServerExtractor(
this.GetTestLogger <AuthorizationServerExtractor>(),
new TemplateBuilder(),
mockedAuthorizationServerClient);
var extractorExecutor = ExtractorExecutor.BuildExtractorExecutor(
this.GetTestLogger <ExtractorExecutor>(),
authorizationServerExtractor: authorizationServerExtractor);
extractorExecutor.SetExtractorParameters(extractorParameters);
// act
var authorizationServerTemplate = await extractorExecutor.GenerateAuthorizationServerTemplateAsync(
singleApiName : It.IsAny <string>(),
currentTestDirectory,
apiTemplateResources : It.IsAny <List <ApiTemplateResource> >());
// assert
File.Exists(Path.Combine(currentTestDirectory, extractorParameters.FileNames.AuthorizationServers)).Should().BeTrue();
authorizationServerTemplate.Parameters.Should().ContainKey(ParameterNames.ApimServiceName);
authorizationServerTemplate.TypedResources.AuthorizationServers.Count().Should().Be(1);
authorizationServerTemplate.Resources.Count().Should().Be(1);
var authorizationResource = authorizationServerTemplate.TypedResources.AuthorizationServers.First();
authorizationResource.Name.Should().Contain(MockAuthorizationServerClient.AuthorizationServerName1);
authorizationResource.Type.Should().Contain(ResourceTypeConstants.AuthorizationServer);
authorizationResource.Properties.Should().NotBeNull();
authorizationResource.Properties.AuthorizationMethods.Any(x => x.Contains(MockAuthorizationServerClient.AuthorizationServerName1)).Should().BeTrue();
authorizationResource.Properties.ClientAuthenticationMethod.Any(x => x.Contains(MockAuthorizationServerClient.AuthorizationServerName1)).Should().BeTrue();
authorizationResource.Properties.DisplayName.Should().Contain(MockAuthorizationServerClient.AuthorizationServerName1);
authorizationResource.Properties.TokenBodyParameters.Should().NotBeNull();
authorizationResource.Properties.TokenEndpoint.Should().NotBeNull();
authorizationResource.Properties.ClientRegistrationEndpoint.Should().NotBeNull();
authorizationResource.Properties.AuthorizationEndpoint.Should().NotBeNull();
authorizationResource.Properties.GrantTypes.Should().NotBeNullOrEmpty();
authorizationResource.Properties.ClientId.Should().NotBeNullOrEmpty();
}
public void ExtractorConfigValidate_MultipleApisNoStringPassed_DoesntThrowAnyException()
{
// arrange
var defaultExtractorConfig = this.GetMockedExtractorConsoleAppConfiguration();
defaultExtractorConfig.MultipleAPIs = string.Empty;
// act
Action createExtractorParameters = () => { _ = new ExtractorParameters(defaultExtractorConfig); };
createExtractorParameters.Should().NotThrow();
}
async Task LoadAllReferencedLoggers(
List <string> apisToExtract,
ExtractorParameters extractorParameters)
{
var serviceDiagnostics = await this.diagnosticClient.GetAllAsync(extractorParameters);
foreach (var serviceDiagnostic in serviceDiagnostics)
{
string loggerId = serviceDiagnostic.Properties.LoggerId;
var serviceDiagnosticsKey = ParameterNamingHelper.GenerateValidParameterName(serviceDiagnostic.Name, ParameterPrefix.Diagnostic);
if (!this.Cache.ServiceLevelDiagnosticLoggerBindings.ContainsKey(serviceDiagnosticsKey))
{
this.Cache.ServiceLevelDiagnosticLoggerBindings.Add(serviceDiagnosticsKey, loggerId);
}
}
if (apisToExtract.IsNullOrEmpty())
{
this.logger.LogWarning("No apis to extract are passed to {0}", nameof(LoggerExtractor));
return;
}
foreach (string curApiName in apisToExtract)
{
var diagnostics = await this.diagnosticClient.GetApiDiagnosticsAsync(curApiName, extractorParameters);
if (diagnostics.IsNullOrEmpty())
{
this.logger.LogWarning("No diagnostics found for '{0}' api", curApiName);
continue;
}
var diagnosticLoggerBindings = new HashSet <DiagnosticLoggerBinding>();
foreach (var diagnostic in diagnostics)
{
diagnosticLoggerBindings.Add(new DiagnosticLoggerBinding
{
DiagnosticName = ParameterNamingHelper.GenerateValidParameterName(diagnostic.Name, ParameterPrefix.Diagnostic),
LoggerId = diagnostic.Properties.LoggerId
});
}
if (!diagnosticLoggerBindings.IsNullOrEmpty())
{
this.Cache.ApiDiagnosticLoggerBindings.Add(
ParameterNamingHelper.GenerateValidParameterName(curApiName, ParameterPrefix.Api),
diagnosticLoggerBindings);
}
}
}
public TemplateBuilder AddParameterizeBackendProperty(ExtractorParameters extractorParameters)
{
if (extractorParameters.ParameterizeBackend)
{
TemplateParameterProperties extractBackendParametersProperties = new TemplateParameterProperties()
{
Type = "object"
};
this.template.Parameters.Add(ParameterNames.BackendSettings, extractBackendParametersProperties);
}
return(this);
}
public void ExtractorConfigValidate_MinimumPropertiesSet_IsValid()
{
var extractorConfig = new ExtractorConsoleAppConfiguration
{
SourceApimName = "source-apim",
DestinationApimName = "destination-apim",
ResourceGroup = "resource-group",
FileFolder = "c:/my/folder"
};
var extractorParameters = new ExtractorParameters(extractorConfig);
extractorParameters.Validate();
}
public TemplateBuilder AddParameterizeServiceUrlProperty(ExtractorParameters extractorParameters)
{
if (extractorParameters.ParameterizeServiceUrl || extractorParameters.ServiceUrlParameters != null && extractorParameters.ServiceUrlParameters.Length > 0)
{
TemplateParameterProperties serviceUrlParamProperty = new TemplateParameterProperties()
{
type = "object"
};
this.template.Parameters.Add(ParameterNames.ServiceUrl, serviceUrlParamProperty);
}
return(this);
}
public TemplateBuilder AddParameterizeApiLoggerIdProperty(ExtractorParameters extractorParameters)
{
if (extractorParameters.ParameterizeApiLoggerId)
{
TemplateParameterProperties apiLoggerProperty = new TemplateParameterProperties()
{
type = "object"
};
this.template.Parameters.Add(ParameterNames.ApiLoggerId, apiLoggerProperty);
}
return(this);
}
