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 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);
}
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 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 async Task GenerateGatewayApisTemplates_ProperlyLaysTheInformation()
{
// arrange
var currentTestDirectory = Path.Combine(this.OutputDirectory, nameof(GenerateGatewayApisTemplates_ProperlyLaysTheInformation));
var extractorConfig = this.GetMockedExtractorConsoleAppConfiguration(
splitApis: false,
apiVersionSetName: string.Empty,
multipleApiNames: string.Empty,
includeAllRevisions: false);
var extractorParameters = new ExtractorParameters(extractorConfig);
var mockedGatewayClient = MockGatewayClient.GetMockedApiClientWithDefaultValues();
var mockedApisClient = MockApisClient.GetMockedApiClientWithDefaultValues();
var gatewayApiExtractor = new GatewayApiExtractor(
this.GetTestLogger <GatewayApiExtractor>(),
new TemplateBuilder(),
mockedGatewayClient,
mockedApisClient);
var extractorExecutor = ExtractorExecutor.BuildExtractorExecutor(
this.GetTestLogger <ExtractorExecutor>(),
gatewayApiExtractor: gatewayApiExtractor);
extractorExecutor.SetExtractorParameters(extractorParameters);
// act
var gatewayApiTemplate = await extractorExecutor.GenerateGatewayApiTemplateAsync(
It.IsAny <string>(),
It.IsAny <List <string> >(),
currentTestDirectory);
// assert
File.Exists(Path.Combine(currentTestDirectory, extractorParameters.FileNames.GatewayApi)).Should().BeTrue();
gatewayApiTemplate.Should().NotBeNull();
gatewayApiTemplate.Parameters.Should().ContainKey(ParameterNames.ApimServiceName);
gatewayApiTemplate.TypedResources.GatewayApis.Count().Should().Be(4);
gatewayApiTemplate.Resources.Count().Should().Be(4);
var gatewayResources = gatewayApiTemplate.TypedResources.GatewayApis;
gatewayResources.Where(x => x.Name.Contains(MockGatewayClient.GatewayName1)).Count().Should().Be(2);
gatewayResources.Where(x => x.Name.Contains(MockGatewayClient.GatewayName2)).Count().Should().Be(2);
gatewayResources.All(x => x.ApiVersion == GlobalConstants.ApiVersion).Should().BeTrue();
gatewayResources.All(x => x.Type == ResourceTypeConstants.GatewayApi).Should().BeTrue();
gatewayResources.All(x => x.Properties is not null).Should().BeTrue();
}
public async Task OutputFiles_HaveProperFieldsOrder()
{
// arrange
var currentTestDirectory = Path.Combine(this.OutputDirectory, nameof(OutputFiles_HaveProperFieldsOrder));
// it doesn't matter what template to check - calling policy extractor as an example
var extractorConfig = this.GetMockedExtractorConsoleAppConfiguration(
splitApis: false,
apiVersionSetName: string.Empty,
multipleApiNames: string.Empty,
includeAllRevisions: false);
var extractorParameters = new ExtractorParameters(extractorConfig);
var mockedPolicyApiClient = MockPolicyClient.GetMockedApiClientWithDefaultValues();
var policyExtractor = new PolicyExtractor(this.GetTestLogger <PolicyExtractor>(), mockedPolicyApiClient, new TemplateBuilder());
var extractorExecutor = ExtractorExecutor.BuildExtractorExecutor(
this.GetTestLogger <ExtractorExecutor>(),
policyExtractor: policyExtractor);
extractorExecutor.SetExtractorParameters(extractorParameters);
// act
var policyTemplate = await extractorExecutor.GeneratePolicyTemplateAsync(currentTestDirectory);
// assert
var outputGlobalServicePolicyFilePath = Path.Combine(currentTestDirectory, extractorParameters.FileNames.GlobalServicePolicy);
File.Exists(outputGlobalServicePolicyFilePath).Should().BeTrue();
var policyTemplateText = await File.ReadAllTextAsync(outputGlobalServicePolicyFilePath);
var policyTemplateJson = JToken.Parse(policyTemplateText);
var resourcesSection = policyTemplateJson["resources"].First;
resourcesSection.Should().NotBeNull();
var resourcesSectionText = resourcesSection.ToString();
var apiVersionFieldPosition = resourcesSectionText.IndexOf("\"apiVersion\"");
var typeFieldPosition = resourcesSectionText.IndexOf("\"type\"");
var nameFieldPosition = resourcesSectionText.IndexOf("\"name\"");
var propertiesFieldPosition = resourcesSectionText.IndexOf("\"properties\"");
apiVersionFieldPosition.Should().BeLessThan(nameFieldPosition);
typeFieldPosition.Should().BeLessThan(nameFieldPosition);
nameFieldPosition.Should().BeLessThan(propertiesFieldPosition);
}
public async Task GenerateTagApiTemplates_ProperlyLaysTheInformation()
{
// arrange
var currentTestDirectory = Path.Combine(this.OutputDirectory, nameof(GenerateTagApiTemplates_ProperlyLaysTheInformation));
var extractorConfig = this.GetMockedExtractorConsoleAppConfiguration(
splitApis: false,
apiVersionSetName: string.Empty,
multipleApiNames: string.Empty,
includeAllRevisions: false);
var extractorParameters = new ExtractorParameters(extractorConfig);
var mockedTagClient = MockTagClient.GetMockedApiClientWithDefaultValues();
var mockedApiClient = MockApisClient.GetMockedApiClientWithDefaultValues();
var tagApiExtractor = new TagApiExtractor(
this.GetTestLogger <TagApiExtractor>(),
new TemplateBuilder(),
mockedApiClient,
mockedTagClient);
var extractorExecutor = ExtractorExecutor.BuildExtractorExecutor(
this.GetTestLogger <ExtractorExecutor>(),
tagApiExtractor: tagApiExtractor);
extractorExecutor.SetExtractorParameters(extractorParameters);
// act
var tagApiTemplate = await extractorExecutor.GenerateTagApiTemplateAsync(
It.IsAny <string>(),
It.IsAny <List <string> >(),
currentTestDirectory);
// assert
File.Exists(Path.Combine(currentTestDirectory, extractorParameters.FileNames.TagApi)).Should().BeTrue();
tagApiTemplate.Parameters.Should().ContainKey(ParameterNames.ApimServiceName);
tagApiTemplate.TypedResources.Tags.Count().Should().Be(4);
tagApiTemplate.Resources.Count().Should().Be(4);
var resources = tagApiTemplate.TypedResources;
resources.Tags.Any(x => x.Name.Contains(MockTagClient.TagName1)).Should().BeTrue();
resources.Tags.Any(x => x.Name.Contains(MockTagClient.TagName2)).Should().BeTrue();
resources.Tags.All(x => x.ApiVersion == GlobalConstants.ApiVersion).Should().BeTrue();
resources.Tags.All(x => !x.DependsOn.IsNullOrEmpty() && !string.IsNullOrEmpty(x.DependsOn.First())).Should().BeTrue();
}
public async Task GenerateLoggersTemplates_ProperlyLaysTheInformation()
{
// arrange
var currentTestDirectory = Path.Combine(this.OutputDirectory, nameof(GenerateLoggersTemplates_ProperlyLaysTheInformation));
var extractorConfig = this.GetMockedExtractorConsoleAppConfiguration(
splitApis: false,
apiVersionSetName: string.Empty,
multipleApiNames: string.Empty,
includeAllRevisions: false);
var extractorParameters = new ExtractorParameters(extractorConfig);
var mockedLoggerClient = MockLoggerClient.GetMockedClientWithDiagnosticDependentValues();
var mockedDiagnosticClient = MockDiagnosticClient.GetMockedApiClientWithDefaultValues();
var loggerExtractor = new LoggerExtractor(
this.GetTestLogger <LoggerExtractor>(),
new TemplateBuilder(),
mockedLoggerClient,
mockedDiagnosticClient);
var extractorExecutor = ExtractorExecutor.BuildExtractorExecutor(
this.GetTestLogger <ExtractorExecutor>(),
loggerExtractor: loggerExtractor);
extractorExecutor.SetExtractorParameters(extractorParameters);
// act
var loggerTemplate = await extractorExecutor.GenerateLoggerTemplateAsync(
new List <string> {
MockApiName
},
It.IsAny <List <PolicyTemplateResource> >(),
currentTestDirectory);
// assert
File.Exists(Path.Combine(currentTestDirectory, extractorParameters.FileNames.Loggers)).Should().BeTrue();
loggerTemplate.Parameters.Should().ContainKey(ParameterNames.ApimServiceName);
loggerTemplate.TypedResources.Loggers.Should().HaveCount(1);
loggerTemplate.Resources.Should().NotBeNullOrEmpty();
loggerTemplate.TypedResources.Loggers.First().Name.Should().Contain(MockLoggerClient.LoggerName);
loggerTemplate.TypedResources.Loggers.First().Properties.LoggerType.Should().Be(MockDiagnosticClient.DefaultDiagnosticName);
}
public async Task GeneratePolicyTemplates_ProperlyLaysTheInformation()
{
// arrange
var currentTestDirectory = Path.Combine(this.OutputDirectory, nameof(GeneratePolicyTemplates_ProperlyLaysTheInformation));
var extractorConfig = this.GetMockedExtractorConsoleAppConfiguration(
splitApis: false,
apiVersionSetName: string.Empty,
multipleApiNames: string.Empty,
includeAllRevisions: false);
var extractorParameters = new ExtractorParameters(extractorConfig);
var mockedPolicyApiClient = MockPolicyClient.GetMockedApiClientWithDefaultValues();
var policyExtractor = new PolicyExtractor(this.GetTestLogger <PolicyExtractor>(), mockedPolicyApiClient, new TemplateBuilder());
var extractorExecutor = ExtractorExecutor.BuildExtractorExecutor(
this.GetTestLogger <ExtractorExecutor>(),
policyExtractor: policyExtractor);
extractorExecutor.SetExtractorParameters(extractorParameters);
// act
var policyTemplate = await extractorExecutor.GeneratePolicyTemplateAsync(currentTestDirectory);
// policy template files exists
File.Exists(Path.Combine(currentTestDirectory, extractorParameters.FileNames.GlobalServicePolicy)).Should().BeTrue();
// global service policy.xml
File.Exists(Path.Combine(currentTestDirectory, PolicyExtractor.PoliciesDirectoryName, PolicyExtractor.GlobalServicePolicyFileName)).Should().BeTrue();
policyTemplate.Parameters.Should().ContainKey(ParameterNames.ApimServiceName);
policyTemplate.Parameters.Should().ContainKey(ParameterNames.PolicyXMLBaseUrl);
policyTemplate.Parameters.Should().ContainKey(ParameterNames.PolicyXMLSasToken);
policyTemplate.TypedResources.Should().NotBeNull();
policyTemplate.Resources.Count().Should().Be(1);
var policyResource = policyTemplate.TypedResources.GlobalServicePolicy;
policyResource.ApiVersion.Should().Be(GlobalConstants.ApiVersion);
policyResource.Name.Should().NotBeNullOrEmpty();
policyResource.Type.Should().Be(ResourceTypeConstants.GlobalServicePolicy);
policyResource.Properties.Format.Should().NotBeNullOrEmpty();
policyResource.Properties.PolicyContent.Should().NotBeNullOrEmpty();
}
public async Task GenerateGroupsTemplates_ProperlyLaysTheInformation()
{
// arrange
var currentTestDirectory = Path.Combine(this.OutputDirectory, nameof(GenerateGroupsTemplates_ProperlyLaysTheInformation));
var extractorConfig = this.GetMockedExtractorConsoleAppConfiguration(
splitApis: false,
apiVersionSetName: string.Empty,
multipleApiNames: string.Empty,
includeAllRevisions: false);
var extractorParameters = new ExtractorParameters(extractorConfig);
var mockedGroupsClient = MockGroupsClient.GetMockedApiClientWithDefaultValues();
var groupExtractor = new GroupExtractor(this.GetTestLogger <GroupExtractor>(), new TemplateBuilder(), mockedGroupsClient);
var extractorExecutor = ExtractorExecutor.BuildExtractorExecutor(
this.GetTestLogger <ExtractorExecutor>(),
groupExtractor: groupExtractor);
extractorExecutor.SetExtractorParameters(extractorParameters);
// act
var groupTemplate = await extractorExecutor.GenerateGroupsTemplateAsync(currentTestDirectory);
// assert
File.Exists(Path.Combine(currentTestDirectory, extractorParameters.FileNames.Groups)).Should().BeTrue();
groupTemplate.Parameters.Should().ContainKey(ParameterNames.ApimServiceName);
groupTemplate.TypedResources.Groups.Count().Should().Be(2);
groupTemplate.Resources.Count().Should().Be(2);
(groupTemplate.Resources[0].Name.Contains(MockGroupsClient.GroupName1) || groupTemplate.Resources[1].Name.Contains(MockGroupsClient.GroupName1)).Should().BeTrue();
(groupTemplate.Resources[0].Name.Contains(MockGroupsClient.GroupName2) || groupTemplate.Resources[1].Name.Contains(MockGroupsClient.GroupName2)).Should().BeTrue();
foreach (var templateResource in groupTemplate.TypedResources.Groups)
{
templateResource.Type.Should().Be(ResourceTypeConstants.Group);
templateResource.Should().NotBeNull();
templateResource.Properties.Should().NotBeNull();
}
}
public async Task GeneratePolicyTemplates_GetCachedPolicy_FoundAndReturnedCorrectly()
{
// arrange
var currentTestDirectory = Path.Combine(this.OutputDirectory, nameof(GeneratePolicyTemplates_GetCachedPolicy_FoundAndReturnedCorrectly));
var extractorConfig = this.GetMockedExtractorConsoleAppConfiguration(
splitApis: false,
apiVersionSetName: string.Empty,
multipleApiNames: string.Empty,
includeAllRevisions: false);
var extractorParameters = new ExtractorParameters(extractorConfig);
var mockedPolicyApiClient = MockPolicyClient.GetMockedApiClientWithDefaultValues();
var policyExtractor = new PolicyExtractor(this.GetTestLogger <PolicyExtractor>(), mockedPolicyApiClient, new TemplateBuilder());
var extractorExecutor = ExtractorExecutor.BuildExtractorExecutor(
this.GetTestLogger <ExtractorExecutor>(),
policyExtractor: policyExtractor);
extractorExecutor.SetExtractorParameters(extractorParameters);
var policyTemplate = await extractorExecutor.GeneratePolicyTemplateAsync(currentTestDirectory);
File.Exists(Path.Combine(currentTestDirectory, PolicyExtractor.PoliciesDirectoryName, PolicyExtractor.GlobalServicePolicyFileName)).Should().BeTrue();
// try get global service policy from cache using full path of policy stored in object
var globalServicePolicyContent1 = policyExtractor.GetCachedPolicyContent(policyTemplate.TypedResources.GlobalServicePolicy, currentTestDirectory);
globalServicePolicyContent1.Should().Be(MockPolicyClient.GlobalPolicyContent);
// try get global service policy from cache using path retrieving
policyTemplate.TypedResources.GlobalServicePolicy.Properties.PolicyContentFileFullPath = string.Empty;
var globalServicePolicyContent2 = policyExtractor.GetCachedPolicyContent(policyTemplate.TypedResources.GlobalServicePolicy, currentTestDirectory);
globalServicePolicyContent2.Should().Be(MockPolicyClient.GlobalPolicyContent);
}
public async Task GenerateProductsTemplates_ProperlyLaysTheInformation()
{
// arrange
var currentTestDirectory = Path.Combine(this.OutputDirectory, nameof(GenerateProductsTemplates_ProperlyLaysTheInformation));
var extractorConfig = this.GetMockedExtractorConsoleAppConfiguration(
splitApis: false,
apiVersionSetName: string.Empty,
multipleApiNames: string.Empty,
includeAllRevisions: false);
var extractorParameters = new ExtractorParameters(extractorConfig);
var mockedPolicyClient = MockPolicyClient.GetMockedApiClientWithDefaultValues();
var mockedPolicyExtractor = new PolicyExtractor(this.GetTestLogger <PolicyExtractor>(), mockedPolicyClient, new TemplateBuilder());
var mockedApisClient = MockApisClient.GetMockedApiClientWithDefaultValues();
var mockedProductsClient = MockProductsClient.GetMockedApiClientWithDefaultValues();
var mockedGroupsClient = MockGroupsClient.GetMockedApiClientWithDefaultValues();
var mockedTagClient = MockTagClient.GetMockedApiClientWithDefaultValues();
var productExtractor = new ProductExtractor(
this.GetTestLogger <ProductExtractor>(),
mockedPolicyExtractor,
mockedProductsClient,
mockedGroupsClient,
mockedTagClient,
new TemplateBuilder());
var extractorExecutor = ExtractorExecutor.BuildExtractorExecutor(
this.GetTestLogger <ExtractorExecutor>(),
productExtractor: productExtractor);
extractorExecutor.SetExtractorParameters(extractorParameters);
// act
var productTemplate = await extractorExecutor.GenerateProductsTemplateAsync(
singleApiName : It.IsAny <string>(),
currentTestDirectory,
productApiResources : It.IsAny <List <ProductApiTemplateResource> >());
// assert
// generated product policy files
var policyFileName = string.Format(PolicyExtractor.ProductPolicyFileNameFormat, MockProductsClient.ProductName1);
File.Exists(Path.Combine(currentTestDirectory, PolicyExtractor.PoliciesDirectoryName, policyFileName)).Should().BeTrue();
// generated product template files
File.Exists(Path.Combine(currentTestDirectory, extractorParameters.FileNames.Products)).Should().BeTrue();
var templateParameters = productTemplate.Parameters;
templateParameters.Should().ContainKey(ParameterNames.ApimServiceName);
templateParameters.Should().ContainKey(ParameterNames.PolicyXMLBaseUrl);
templateParameters.Should().ContainKey(ParameterNames.PolicyXMLSasToken);
templateParameters.Should().ContainKey(ParameterNames.ServiceUrl);
templateParameters.Should().ContainKey(ParameterNames.ApiLoggerId);
var templateResources = productTemplate.Resources;
// product resource
var productResource = templateResources.First(x => x.Type == ResourceTypeConstants.Product);
productResource.Name.Should().Contain(MockProductsClient.ProductName1);
// group resources
var groupResources = templateResources.Where(x => x.Type == ResourceTypeConstants.ProductGroup).ToList();
groupResources.Should().HaveCount(2);
(groupResources[0].Name.Contains(MockGroupsClient.GroupName1) || groupResources[1].Name.Contains(MockGroupsClient.GroupName1)).Should().BeTrue();
(groupResources[0].Name.Contains(MockGroupsClient.GroupName2) || groupResources[1].Name.Contains(MockGroupsClient.GroupName2)).Should().BeTrue();
// policy resources
var policyResource = templateResources.First(x => x.Type == ResourceTypeConstants.ProductPolicy);
policyResource.Name.Should().Contain(MockProductsClient.ProductName1);
// tag resources
var tagResources = templateResources.Where(x => x.Type == ResourceTypeConstants.ProductTag).ToList();
tagResources.Should().HaveCount(2);
(tagResources[0].Name.Contains(MockTagClient.TagName1) || tagResources[1].Name.Contains(MockTagClient.TagName1)).Should().BeTrue();
(tagResources[0].Name.Contains(MockTagClient.TagName2) || tagResources[1].Name.Contains(MockTagClient.TagName2)).Should().BeTrue();
}
public async Task GenerateMasterTemplates_ProperlyLaysTheInformation()
{
// arrange
var currentTestDirectory = Path.Combine(this.OutputDirectory, nameof(GenerateMasterTemplates_ProperlyLaysTheInformation));
var extractorConfig = this.GetMockedExtractorConsoleAppConfiguration(
splitApis: false,
apiVersionSetName: string.Empty,
multipleApiNames: string.Empty,
includeAllRevisions: false);
var extractorParameters = new ExtractorParameters(extractorConfig);
var masterTemplateExtractor = new MasterTemplateExtractor(
this.GetTestLogger <MasterTemplateExtractor>(),
new TemplateBuilder());
var extractorExecutor = ExtractorExecutor.BuildExtractorExecutor(
this.GetTestLogger <ExtractorExecutor>(),
masterTemplateExtractor: masterTemplateExtractor);
extractorExecutor.SetExtractorParameters(extractorParameters);
var tagTemplateResources = new TagTemplateResources()
{
Tags = new()
{
new TagTemplateResource()
{
Name = "my-tag",
Properties = new() { DisplayName = "my-display-tag" }
}
}
};
// act
var masterTemplate = await extractorExecutor.GenerateMasterTemplateAsync(
currentTestDirectory,
tagTemplateResources : tagTemplateResources);
File.Exists(Path.Combine(currentTestDirectory, extractorParameters.FileNames.LinkedMaster)).Should().BeTrue();
masterTemplate.Parameters.Should().ContainKey(ParameterNames.ApimServiceName);
masterTemplate.Parameters.Should().ContainKey(ParameterNames.LinkedTemplatesBaseUrl);
masterTemplate.Parameters.Should().ContainKey(ParameterNames.LinkedTemplatesSasToken);
masterTemplate.Parameters.Should().ContainKey(ParameterNames.LinkedTemplatesUrlQueryString);
masterTemplate.Parameters.Should().ContainKey(ParameterNames.ServiceUrl);
masterTemplate.Parameters.Should().ContainKey(ParameterNames.NamedValues);
masterTemplate.Parameters.Should().ContainKey(ParameterNames.ApiLoggerId);
masterTemplate.Parameters.Should().ContainKey(ParameterNames.LoggerResourceId);
masterTemplate.Parameters.Should().ContainKey(ParameterNames.NamedValueKeyVaultSecrets);
masterTemplate.Parameters.Should().ContainKey(ParameterNames.BackendSettings);
masterTemplate.TypedResources.DeploymentResources.Should().HaveCount(1);
masterTemplate.Resources.Should().HaveCount(1);
var tagDeployment = masterTemplate.TypedResources.DeploymentResources.First();
tagDeployment.Type.Should().Be(ResourceTypeConstants.ArmDeployments);
tagDeployment.Properties.Should().NotBeNull();
}
}
public ExtractApplicationCommand(ILogger <ExtractApplicationCommand> logger, ExtractorExecutor extractorExecutor) : base()
{
this.logger = logger;
this.extractorExecutor = extractorExecutor;
}
public async Task GenerateNamedValuesTemplates_ProperlyLaysTheInformation()
{
// arrange
var currentTestDirectory = Path.Combine(this.OutputDirectory, nameof(GenerateNamedValuesTemplates_ProperlyLaysTheInformation));
var extractorConfig = this.GetMockedExtractorConsoleAppConfiguration(
splitApis: false,
apiVersionSetName: string.Empty,
multipleApiNames: string.Empty,
includeAllRevisions: false,
toNotIncludeNamedValue: 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 mockBackendExtractor = new Mock <IBackendExtractor>(MockBehavior.Strict);
mockBackendExtractor
.Setup(x => x.IsNamedValueUsedInBackends(
It.IsAny <string>(),
It.IsAny <List <PolicyTemplateResource> >(),
It.IsAny <string>(),
It.IsAny <string>(),
It.IsAny <ExtractorParameters>(),
It.IsAny <string>()))
.ReturnsAsync(false);
var mockedNamedValuesClient = MockNamedValuesClient.GetMockedApiClientWithDefaultValues();
var namedValuesExtractor = new NamedValuesExtractor(
this.GetTestLogger <NamedValuesExtractor>(),
new TemplateBuilder(),
mockedNamedValuesClient,
mockPolicyExtractor.Object,
mockBackendExtractor.Object);
var extractorExecutor = ExtractorExecutor.BuildExtractorExecutor(
this.GetTestLogger <ExtractorExecutor>(),
namedValuesExtractor: namedValuesExtractor);
extractorExecutor.SetExtractorParameters(extractorParameters);
// act
var namedValuesTemplate = await extractorExecutor.GenerateNamedValuesTemplateAsync(
"some-single-api",
new List <PolicyTemplateResource>()
{
new PolicyTemplateResource {
Name = MockNamedValuesClient.NamedValueName
},
new PolicyTemplateResource {
Name = MockNamedValuesClient.NamedValueDisplayName
}
},
It.IsAny <List <LoggerTemplateResource> >(),
currentTestDirectory);
// assert
File.Exists(Path.Combine(currentTestDirectory, extractorParameters.FileNames.NamedValues)).Should().BeTrue();
namedValuesTemplate.Parameters.Should().ContainKey(ParameterNames.ApimServiceName);
namedValuesTemplate.Parameters.Should().ContainKey(ParameterNames.NamedValues);
namedValuesTemplate.Parameters.Should().ContainKey(ParameterNames.NamedValueKeyVaultSecrets);
namedValuesTemplate.TypedResources.NamedValues.Should().HaveCount(1);
namedValuesTemplate.Resources.Should().HaveCount(1);
namedValuesTemplate.TypedResources.NamedValues.First().Type.Should().Be(ResourceTypeConstants.NamedValues);
namedValuesTemplate.TypedResources.NamedValues.First().Name.Should().Contain(MockNamedValuesClient.NamedValueName);
namedValuesTemplate.TypedResources.NamedValues.First().Properties.DisplayName.Should().Contain(MockNamedValuesClient.NamedValueDisplayName);
}
public async Task GenerateApiTemplates_ProperlyLaysTheInformation()
{
// arrange
var currentTestDirectory = Path.Combine(this.OutputDirectory, nameof(GenerateApiTemplates_ProperlyLaysTheInformation));
var extractorConfig = this.GetMockedExtractorConsoleAppConfiguration(
splitApis: false,
apiVersionSetName: string.Empty,
multipleApiNames: string.Empty,
includeAllRevisions: false);
var extractorParameters = new ExtractorParameters(extractorConfig);
// mocked clients
var mockedApiClient = MockApisClient.GetMockedApiClientWithDefaultValues();
var mockedProductClient = MockProductsClient.GetMockedApiClientWithDefaultValues();
var mockedApiSchemaClient = MockApiSchemaClient.GetMockedApiClientWithDefaultValues();
var mockedPolicyClient = MockPolicyClient.GetMockedApiClientWithDefaultValues();
var mockedTagClient = MockTagClient.GetMockedApiClientWithDefaultValues();
var mockedApiOperationClient = MockApiOperationClient.GetMockedApiClientWithDefaultValues();
var mockedDiagnosticClient = MockDiagnosticClient.GetMockedClientWithApiDependentValues();
// mocked extractors
var mockedDiagnosticExtractor = new DiagnosticExtractor(this.GetTestLogger <DiagnosticExtractor>(), mockedDiagnosticClient);
var mockedApiSchemaExtractor = new ApiSchemaExtractor(this.GetTestLogger <ApiSchemaExtractor>(), mockedApiSchemaClient);
var mockedPolicyExtractor = new PolicyExtractor(this.GetTestLogger <PolicyExtractor>(), mockedPolicyClient, new TemplateBuilder());
var mockedProductApisExtractor = new ProductApisExtractor(this.GetTestLogger <ProductApisExtractor>(), mockedProductClient, mockedApiClient, new TemplateBuilder());
var mockedTagExtractor = new TagExtractor(this.GetTestLogger <TagExtractor>(), mockedTagClient, new TemplateBuilder());
var mockedApiOperationExtractor = new ApiOperationExtractor(this.GetTestLogger <ApiOperationExtractor>(), mockedApiOperationClient);
var apiExtractor = new ApiExtractor(
this.GetTestLogger <ApiExtractor>(),
new TemplateBuilder(),
mockedApiClient,
mockedDiagnosticExtractor,
mockedApiSchemaExtractor,
mockedPolicyExtractor,
mockedProductApisExtractor,
mockedTagExtractor,
mockedApiOperationExtractor);
var extractorExecutor = ExtractorExecutor.BuildExtractorExecutor(
this.GetTestLogger <ExtractorExecutor>(),
apiExtractor: apiExtractor);
extractorExecutor.SetExtractorParameters(extractorParameters);
// act
var apiTemplate = await extractorExecutor.GenerateApiTemplateAsync(
singleApiName : It.IsAny <string>(),
multipleApiNames : It.IsAny <List <string> >(),
currentTestDirectory);
// assert
File.Exists(Path.Combine(currentTestDirectory, apiTemplate.TypedResources.FileName)).Should().BeTrue();
Directory.GetFiles(Path.Combine(currentTestDirectory, PolicyExtractor.PoliciesDirectoryName)).Count().Should().Be(4);
apiTemplate.Parameters.Should().NotBeNull();
apiTemplate.Parameters.Should().ContainKey(ParameterNames.ApimServiceName);
apiTemplate.Parameters.Should().ContainKey(ParameterNames.ServiceUrl);
apiTemplate.Parameters.Should().ContainKey(ParameterNames.ApiLoggerId);
apiTemplate.Parameters.Should().ContainKey(ParameterNames.PolicyXMLBaseUrl);
apiTemplate.Parameters.Should().ContainKey(ParameterNames.PolicyXMLSasToken);
apiTemplate.Resources.Count().Should().Be(23);
// apis
apiTemplate.TypedResources.Apis.Count().Should().Be(2);
apiTemplate.TypedResources.Apis.All(x => x.Type == ResourceTypeConstants.API).Should().BeTrue();
apiTemplate.TypedResources.Apis.All(x => x.Properties is not null).Should().BeTrue();
// api schemas
apiTemplate.TypedResources.ApiSchemas.Count().Should().Be(2);
apiTemplate.TypedResources.ApiSchemas.All(x => x.Type == ResourceTypeConstants.APISchema).Should().BeTrue();
apiTemplate.TypedResources.ApiSchemas.All(x => x.Properties is not null).Should().BeTrue();
// diagnostics
apiTemplate.TypedResources.Diagnostics.Count().Should().Be(3);
apiTemplate.TypedResources.Diagnostics.All(x => x.Type == ResourceTypeConstants.APIServiceDiagnostic || x.Type == ResourceTypeConstants.APIDiagnostic).Should().BeTrue();
apiTemplate.TypedResources.Diagnostics.All(x => x.Properties is not null).Should().BeTrue();
// tags
apiTemplate.TypedResources.Tags.Count().Should().Be(4);
apiTemplate.TypedResources.Tags.All(x => x.Type == ResourceTypeConstants.ProductTag).Should().BeTrue();
// api products
apiTemplate.TypedResources.ApiProducts.Count().Should().Be(2);
apiTemplate.TypedResources.ApiProducts.All(x => x.Type == ResourceTypeConstants.ProductApi).Should().BeTrue();
apiTemplate.TypedResources.ApiProducts.All(x => x.Properties is not null).Should().BeTrue();
// api policies
apiTemplate.TypedResources.ApiPolicies.Count().Should().Be(2);
apiTemplate.TypedResources.ApiPolicies.All(x => x.Properties is not null).Should().BeTrue();
// api operations
apiTemplate.TypedResources.ApiOperations.Count().Should().Be(2);
apiTemplate.TypedResources.ApiOperations.All(x => x.Type == ResourceTypeConstants.APIOperation).Should().BeTrue();
apiTemplate.TypedResources.ApiOperations.All(x => x.Properties is not null).Should().BeTrue();
apiTemplate.TypedResources.ApiOperations.SelectMany(x => x.DependsOn).Any(x => x.Contains($"'{ResourceTypeConstants.API}'")).Should().BeTrue();
apiTemplate.TypedResources.ApiOperations.SelectMany(x => x.DependsOn).Any(x => x.Contains($"'{ResourceTypeConstants.APIOperation}'")).Should().BeFalse();
// api operations policies
apiTemplate.TypedResources.ApiOperationsPolicies.Count().Should().Be(2);
apiTemplate.TypedResources.ApiOperations.All(x => x.Properties is not null).Should().BeTrue();
// api operations tags
apiTemplate.TypedResources.ApiOperationsPolicies.Count().Should().Be(2);
apiTemplate.TypedResources.ApiOperations.All(x => x.Properties is not null).Should().BeTrue();
}
