public async Task TryUpdateQuota()
{
Environment.SetEnvironmentVariable("AZURE_TEST_MODE", "Playback");
using (MockContext context = MockContext.Start(this.GetType()))
{
var testBase = new ApiManagementTestBase(context);
testBase.TryCreateApiManagementService();
try
{
// try to update quota. should not be 400(bad contract) but 404(quota not found)
await testBase.client.QuotaByCounterKeys.UpdateAsync(
testBase.rgName,
testBase.serviceName,
"not_exist",
new QuotaCounterValueUpdateContract()
{
CallsCount = 0, KbTransferred = 0
});
}
catch (ErrorResponseException ex) when(ex.Body.Code == "ResourceNotFound")
{
//expected, do not raise exception
}
}
}
public void GetOutboundNetworkDependencies()
{
Environment.SetEnvironmentVariable("AZURE_TEST_MODE", "Playback");
using (MockContext context = MockContext.Start(this.GetType()))
{
var testBase = new ApiManagementTestBase(context);
// create service
var createdService = testBase.client.ApiManagementService.CreateOrUpdate(
resourceGroupName: testBase.rgName,
serviceName: testBase.serviceName,
parameters: testBase.serviceProperties);
var outboundDependencies = testBase.client.OutboundNetworkDependenciesEndpoints.ListByService(testBase.rgName, testBase.serviceName);
Assert.NotNull(outboundDependencies);
Assert.Equal(10, outboundDependencies.Value.Count);
Assert.NotNull(outboundDependencies.Value.Single(d => d.Category.Equals("Azure SMTP")));
Assert.NotNull(outboundDependencies.Value.Single(d => d.Category.Equals("Azure Storage")));
Assert.NotNull(outboundDependencies.Value.Single(d => d.Category.Equals("Azure Active Directory")));
Assert.NotNull(outboundDependencies.Value.Single(d => d.Category.Equals("Azure SQL")));
Assert.NotNull(outboundDependencies.Value.Single(d => d.Category.Equals("Azure Key Vault")));
Assert.NotNull(outboundDependencies.Value.Single(d => d.Category.Equals("Azure Event Hub")));
Assert.NotNull(outboundDependencies.Value.Single(d => d.Category.Equals("Portal Captcha")));
Assert.NotNull(outboundDependencies.Value.Single(d => d.Category.Equals("SSL Certificate Verification")));
Assert.NotNull(outboundDependencies.Value.Single(d => d.Category.Equals("Azure Monitor")));
Assert.NotNull(outboundDependencies.Value.Single(d => d.Category.Equals("Windows Activation")));
// Delete
testBase.client.ApiManagementService.Delete(
resourceGroupName: testBase.rgName,
serviceName: testBase.serviceName);
}
}
protected async Task <HttpStatusCode> CallApiServiceEchoApi(ApiManagementTestBase testBase)
{
var subscriptionList = await testBase.client.Subscription.ListAsync(testBase.rgName, testBase.serviceName);
var subscription = subscriptionList.First();
var subscriptionId = subscription.Id.Split("/").Last();
var subscriptionKey = await testBase.client.Subscription.ListSecretsAsync(testBase.rgName, testBase.serviceName, subscriptionId);
var echoApi = await testBase.client.Api.GetAsync(testBase.rgName, testBase.serviceName, echoApiId);
var apiService = await testBase.client.ApiManagementService.GetAsync(testBase.rgName, testBase.serviceName);
var url = string.Format(CultureInfo.InvariantCulture, $"/{echoApi.Path}/resource");
using (var handler = new HttpClientHandler())
{
using (var httpClient = new HttpClient(handler)
{
BaseAddress = new Uri(apiService.GatewayUrl)
})
{
var message = new HttpRequestMessage(HttpMethod.Head, url);
message.Headers.Add("Ocp-Apim-Subscription-Key", subscriptionKey.PrimaryKey);
var response = await httpClient.SendAsync(message);
return(response.StatusCode);
}
}
}
static void ValidateProperty(
NamedValueContract contract,
ApiManagementTestBase testBase,
string propertyId,
string propertyDisplayName,
string propertyValue,
bool isSecret,
List <string> tags = null)
{
Assert.NotNull(contract);
Assert.Equal(propertyDisplayName, contract.DisplayName);
if (isSecret)
{
Assert.Null(contract.Value);
}
else
{
Assert.Equal(propertyValue, contract.Value);
}
Assert.Equal(isSecret, contract.Secret);
Assert.Equal(propertyId, contract.Name);
if (tags != null)
{
Assert.NotNull(contract.Tags);
Assert.Equal(tags.Count, contract.Tags.Count);
}
}
async Task <PublicIPAddress> SetupPublicIPAsync(ApiManagementTestBase testBase)
{
// put Public IP
string publicIpName = TestUtilities.GenerateName();
string domainNameLabel = TestUtilities.GenerateName(testBase.rgName);
var publicIp = new PublicIPAddress()
{
Location = testBase.location,
Tags = new Dictionary <string, string>()
{
{ "key", "value" }
},
PublicIPAllocationMethod = IPAllocationMethod.Static,
PublicIPAddressVersion = "IPv4",
DnsSettings = new PublicIPAddressDnsSettings()
{
DomainNameLabel = domainNameLabel
},
Sku = new PublicIPAddressSku()
{
Name = "Standard"
}
};
var putPublicIPResponse = await testBase.networkClient.PublicIPAddresses.CreateOrUpdateAsync(testBase.rgName, publicIpName, publicIp);
Assert.Equal("Succeeded", putPublicIPResponse.ProvisioningState);
return(putPublicIPResponse);
}
public void DeletedServicesTest()
{
Environment.SetEnvironmentVariable("AZURE_TEST_MODE", "Playback");
using (MockContext context = MockContext.Start(this.GetType()))
{
var testBase = new ApiManagementTestBase(context);
var deletedServices = testBase.client.DeletedServices.ListBySubscription();
Assert.NotNull(deletedServices);
var firstService = deletedServices.First();
var serviceDetails = testBase.client.DeletedServices.GetByName(firstService.Name, firstService.Location);
Assert.NotNull(serviceDetails);
Assert.NotNull(serviceDetails.Location);
Assert.NotNull(serviceDetails.ScheduledPurgeDate);
Assert.NotNull(serviceDetails.ServiceId);
Assert.Contains(firstService.Name, serviceDetails.ServiceId);
Assert.NotNull(serviceDetails.DeletionDate);
Assert.True(serviceDetails.DeletionDate < serviceDetails.ScheduledPurgeDate);
// Purge the service
testBase.client.DeletedServices.Purge(firstService.Name, firstService.Location);
Assert.Throws <ErrorResponseException>(() =>
{
testBase.client.DeletedServices.GetByName(
firstService.Name,
firstService.Location);
});
}
}
public async Task SubscriptionsList()
{
Environment.SetEnvironmentVariable("AZURE_TEST_MODE", "Playback");
using (MockContext context = MockContext.Start(this.GetType()))
{
var testBase = new ApiManagementTestBase(context);
testBase.TryCreateApiManagementService();
// get product
var listProductsResponse = testBase.client.Product.ListByService(
testBase.rgName,
testBase.serviceName,
new Microsoft.Rest.Azure.OData.ODataQuery <ProductContract>
{
Filter = "name eq 'Starter'"
});
var product = listProductsResponse.Single();
// list product's subscriptions
var listSubscriptionsResponse = await testBase.client.ProductSubscriptions.ListAsync(
testBase.rgName,
testBase.serviceName,
product.Name,
null);
Assert.NotNull(listSubscriptionsResponse);
Assert.Single(listSubscriptionsResponse);
}
}
public void WadlTest()
{
Environment.SetEnvironmentVariable("AZURE_TEST_MODE", "Playback");
using (MockContext context = MockContext.Start(this.GetType().FullName))
{
var testBase = new ApiManagementTestBase(context);
testBase.TryCreateApiManagementService();
const string wadlPath = "./Resources/WADLYahoo.xml";
const string path = "yahooWadl";
string wadlApi = TestUtilities.GenerateName("aid");
try
{
// import API
string wadlApiContent;
using (StreamReader reader = File.OpenText(wadlPath))
{
wadlApiContent = reader.ReadToEnd();
}
var apiCreateOrUpdate = new ApiCreateOrUpdateParameter()
{
Path = path,
ContentFormat = ContentFormat.WadlXml,
ContentValue = wadlApiContent
};
var wadlApiResponse = testBase.client.Api.CreateOrUpdate(
testBase.rgName,
testBase.serviceName,
wadlApi,
apiCreateOrUpdate);
Assert.NotNull(wadlApiResponse);
// get the api to check it was created
var getResponse = testBase.client.Api.Get(testBase.rgName, testBase.serviceName, wadlApi);
Assert.NotNull(getResponse);
Assert.Equal(wadlApi, getResponse.Name);
Assert.Equal(path, getResponse.Path);
Assert.Equal("Yahoo News Search", getResponse.DisplayName);
Assert.Equal("http://api.search.yahoo.com/NewsSearchService/V1/", getResponse.ServiceUrl);
Assert.True(getResponse.IsCurrent);
Assert.True(getResponse.Protocols.Contains(Protocol.Https));
Assert.Equal("1", getResponse.ApiRevision);
ApiExportResult wadlExport = testBase.client.ApiExport.Get(testBase.rgName, testBase.serviceName, wadlApi, ExportFormat.Wadl);
Assert.NotNull(wadlExport);
Assert.NotNull(wadlExport.Link);
}
finally
{
// remove the API
testBase.client.Api.Delete(testBase.rgName, testBase.serviceName, wadlApi, "*");
}
}
}
public void SwaggerTest()
{
Environment.SetEnvironmentVariable("AZURE_TEST_MODE", "Playback");
using (MockContext context = MockContext.Start(this.GetType()))
{
var testBase = new ApiManagementTestBase(context);
testBase.TryCreateApiManagementService();
const string swaggerPath = "./Resources/SwaggerPetStoreV2.json";
const string path = "swaggerApi";
string swaggerApi = TestUtilities.GenerateName("aid");
try
{
// import API
string swaggerApiContent;
using (StreamReader reader = File.OpenText(swaggerPath))
{
swaggerApiContent = reader.ReadToEnd();
}
var apiCreateOrUpdate = new ApiCreateOrUpdateParameter()
{
Path = path,
Format = ContentFormat.SwaggerJson,
Value = swaggerApiContent
};
var swaggerApiResponse = testBase.client.Api.CreateOrUpdate(
testBase.rgName,
testBase.serviceName,
swaggerApi,
apiCreateOrUpdate);
Assert.NotNull(swaggerApiResponse);
// get the api to check it was created
var getResponse = testBase.client.Api.Get(testBase.rgName, testBase.serviceName, swaggerApi);
Assert.NotNull(getResponse);
Assert.Equal(swaggerApi, getResponse.Name);
Assert.Equal(path, getResponse.Path);
Assert.Equal("Swagger Petstore Extensive", getResponse.DisplayName);
Assert.Equal("http://petstore.swagger.wordnik.com/api", getResponse.ServiceUrl);
ApiExportResult swaggerExport = testBase.client.ApiExport.Get(testBase.rgName, testBase.serviceName, swaggerApi, ExportFormat.Swagger);
Assert.NotNull(swaggerExport);
Assert.NotNull(swaggerExport.Value.Link);
Assert.Equal("swagger-link-json", swaggerExport.ExportResultFormat);
}
finally
{
// remove the API
testBase.client.Api.Delete(testBase.rgName, testBase.serviceName, swaggerApi, "*");
}
}
}
public void OpenApiTest()
{
Environment.SetEnvironmentVariable("AZURE_TEST_MODE", "Playback");
using (MockContext context = MockContext.Start(this.GetType()))
{
var testBase = new ApiManagementTestBase(context);
testBase.TryCreateApiManagementService();
const string openapiFilePath = "./Resources/petstore.yaml";
const string path = "openapi3";
string openApiId = TestUtilities.GenerateName("aid");
try
{
// import API
string openApiContent;
using (StreamReader reader = File.OpenText(openapiFilePath))
{
openApiContent = reader.ReadToEnd();
}
var apiCreateOrUpdate = new ApiCreateOrUpdateParameter()
{
Path = path,
Format = ContentFormat.Openapi,
Value = openApiContent
};
var swaggerApiResponse = testBase.client.Api.CreateOrUpdate(
testBase.rgName,
testBase.serviceName,
openApiId,
apiCreateOrUpdate);
Assert.NotNull(swaggerApiResponse);
// get the api to check it was created
var getResponse = testBase.client.Api.Get(testBase.rgName, testBase.serviceName, openApiId);
Assert.NotNull(getResponse);
Assert.Equal(openApiId, getResponse.Name);
Assert.Equal(path, getResponse.Path);
Assert.Equal("Swagger Petstore", getResponse.DisplayName);
Assert.Equal("http://petstore.swagger.io/v1", getResponse.ServiceUrl);
ApiExportResult openApiExport = testBase.client.ApiExport.Get(testBase.rgName, testBase.serviceName, openApiId, ExportFormat.Openapi);
Assert.NotNull(openApiExport);
Assert.NotNull(openApiExport.Value.Link);
Assert.Equal("openapi-link", openApiExport.ExportResultFormat);
}
finally
{
// remove the API
testBase.client.Api.Delete(testBase.rgName, testBase.serviceName, openApiId, "*");
}
}
}
public async Task CreateListUpdatePortalRevision()
{
Environment.SetEnvironmentVariable("AZURE_TEST_MODE", "Playback");
using (MockContext context = MockContext.Start(this.GetType()))
{
var testBase = new ApiManagementTestBase(context);
testBase.TryCreateApiManagementService();
var revisionId = TestUtilities.GenerateName("revisionId");
var portalRevisionContract = new PortalRevisionContract
{
Description = new string('a', 99),
IsCurrent = true
};
// create portal revision
var portalRevision = await testBase.client.PortalRevision.CreateOrUpdateAsync(
testBase.rgName,
testBase.serviceName,
revisionId,
portalRevisionContract);
Assert.NotNull(portalRevision);
Assert.True(portalRevision.IsCurrent);
Assert.Equal("completed", portalRevision.Status);
//get
var getPortalRevision = testBase.client.PortalRevision.Get(
testBase.rgName,
testBase.serviceName,
revisionId);
Assert.NotNull(getPortalRevision);
Assert.True(portalRevision.IsCurrent);
Assert.Equal("completed", portalRevision.Status);
var updateDescription = "Updated " + portalRevisionContract.Description;
var updatedResult = await testBase.client.PortalRevision.UpdateAsync(
testBase.rgName,
testBase.serviceName,
revisionId,
new PortalRevisionContract { Description = updateDescription },
"*");
Assert.NotNull(updatedResult);
Assert.True(portalRevision.IsCurrent);
Assert.Equal("completed", updatedResult.Status);
Assert.Equal(updateDescription, updatedResult.Description);
//list
var listPortalRevision = testBase.client.PortalRevision.ListByService(
testBase.rgName,
testBase.serviceName);
Assert.NotNull(listPortalRevision);
}
}
public void InstallIntermediateCertificatesTest()
{
Environment.SetEnvironmentVariable("AZURE_TEST_MODE", "Playback");
using (MockContext context = MockContext.Start(this.GetType()))
{
var testBase = new ApiManagementTestBase(context);
testBase.serviceProperties.Sku.Name = SkuType.Basic;
testBase.serviceProperties.Certificates = new List <CertificateConfiguration>();
var certConfig = new CertificateConfiguration()
{
StoreName = StoreName.CertificateAuthority.ToString("G"),
EncodedCertificate = testBase.base64EncodedTestCertificateData,
CertificatePassword = testBase.testCertificatePassword
};
testBase.serviceProperties.Certificates.Add(certConfig);
var base64ArrayCertificate = Convert.FromBase64String(testBase.base64EncodedTestCertificateData);
var cert = new X509Certificate2(base64ArrayCertificate, testBase.testCertificatePassword);
var createdService = testBase.client.ApiManagementService.CreateOrUpdate(
resourceGroupName: testBase.rgName,
serviceName: testBase.serviceName,
parameters: testBase.serviceProperties);
ValidateService(createdService,
testBase.serviceName,
testBase.rgName,
testBase.subscriptionId,
testBase.location,
testBase.serviceProperties.PublisherEmail,
testBase.serviceProperties.PublisherName,
testBase.serviceProperties.Sku.Name,
testBase.tags,
PlatformVersion.Stv2);
Assert.NotNull(createdService.Certificates);
Assert.Single(createdService.Certificates);
Assert.Equal(StoreName.CertificateAuthority.ToString("G"), createdService.Certificates.First().StoreName, ignoreCase: true);
Assert.Equal(cert.Thumbprint, createdService.Certificates.First().Certificate.Thumbprint, ignoreCase: true);
// Delete
testBase.client.ApiManagementService.Delete(
resourceGroupName: testBase.rgName,
serviceName: testBase.serviceName);
Assert.Throws <ErrorResponseException>(() =>
{
testBase.client.ApiManagementService.Get(
resourceGroupName: testBase.rgName,
serviceName: testBase.serviceName);
});
}
}
public void CreateMultiRegionService()
{
Environment.SetEnvironmentVariable("AZURE_TEST_MODE", "Playback");
using (MockContext context = MockContext.Start(this.GetType()))
{
var testBase = new ApiManagementTestBase(context);
var additionalLocation = new AdditionalLocation()
{
Location = testBase.GetLocation("Europe"),
Sku = new ApiManagementServiceSkuProperties(SkuType.Premium)
};
// only premium sku supports multi-region
testBase.serviceProperties.Sku.Name = SkuType.Premium;
testBase.serviceProperties.AdditionalLocations = new List <AdditionalLocation>()
{
additionalLocation
};
var createdService = testBase.client.ApiManagementService.CreateOrUpdate(
resourceGroupName: testBase.rgName,
serviceName: testBase.serviceName,
parameters: testBase.serviceProperties);
ValidateService(createdService,
testBase.serviceName,
testBase.rgName,
testBase.subscriptionId,
testBase.location,
testBase.serviceProperties.PublisherEmail,
testBase.serviceProperties.PublisherName,
testBase.serviceProperties.Sku.Name,
testBase.tags);
Assert.NotNull(createdService.AdditionalLocations);
Assert.Single(createdService.AdditionalLocations);
Assert.Equal(additionalLocation.Location.ToLowerInvariant().Replace(" ", string.Empty),
createdService.AdditionalLocations.First().Location.ToLowerInvariant().Replace(" ", string.Empty));
// Delete
testBase.client.ApiManagementService.Delete(
resourceGroupName: testBase.rgName,
serviceName: testBase.serviceName);
Assert.Throws <CloudException>(() =>
{
testBase.client.ApiManagementService.Get(
resourceGroupName: testBase.rgName,
serviceName: testBase.serviceName);
});
}
}
public async Task CreateUpdateReset()
{
Environment.SetEnvironmentVariable("AZURE_TEST_MODE", "Playback");
using (MockContext context = MockContext.Start(this.GetType()))
{
var testBase = new ApiManagementTestBase(context);
testBase.TryCreateApiManagementService();
// get the existing settings on the service
PortalSignupSettings defaultSignupSettings = await testBase.client.SignUpSettings.GetAsync(
testBase.rgName,
testBase.serviceName);
Assert.NotNull(defaultSignupSettings);
// check settings Etag
var signUpTag = await testBase.client.SignUpSettings.GetEntityTagAsync(
testBase.rgName,
testBase.serviceName);
Assert.NotNull(signUpTag);
Assert.NotNull(signUpTag.ETag);
// disable portal signIn
var portalSignUpSettingParams = new PortalSignupSettings()
{
Enabled = false,
TermsOfService = defaultSignupSettings.TermsOfService
};
var portalSignUpSettings = testBase.client.SignUpSettings.CreateOrUpdate(
testBase.rgName,
testBase.serviceName,
portalSignUpSettingParams);
Assert.NotNull(portalSignUpSettings);
Assert.False(portalSignUpSettings.Enabled);
signUpTag = await testBase.client.SignUpSettings.GetEntityTagAsync(
testBase.rgName,
testBase.serviceName);
Assert.NotNull(signUpTag);
Assert.NotNull(signUpTag.ETag);
// reset the signIn settings
portalSignUpSettings.Enabled = defaultSignupSettings.Enabled;
portalSignUpSettings.TermsOfService = defaultSignupSettings.TermsOfService;
await testBase.client.SignUpSettings.UpdateAsync(
testBase.rgName,
testBase.serviceName,
portalSignUpSettings,
signUpTag.ETag);
}
}
public void SubscriptionsList()
{
Environment.SetEnvironmentVariable("AZURE_TEST_MODE", "Playback");
using (MockContext context = MockContext.Start(this.GetType()))
{
var testBase = new ApiManagementTestBase(context);
testBase.TryCreateApiManagementService();
var usersResponse = testBase.client.User.ListByService(testBase.rgName, testBase.serviceName, null);
var user = usersResponse.First();
// list subscriptions of a user: there should be two by default
var listResponse = testBase.client.UserSubscription.List(
testBase.rgName,
testBase.serviceName,
user.Name,
null);
Assert.NotNull(listResponse);
Assert.True(listResponse.Count() >= 2);
Assert.Null(listResponse.NextPageLink);
var userSubscription = testBase.client.UserSubscription.Get(
testBase.rgName,
testBase.serviceName,
user.Name,
listResponse.First().Name);
Assert.NotNull(userSubscription);
Assert.NotNull(userSubscription.Name);
// list paged
listResponse = testBase.client.UserSubscription.List(
testBase.rgName,
testBase.serviceName,
user.Name,
new Microsoft.Rest.Azure.OData.ODataQuery <SubscriptionContract> {
Top = 1
});
Assert.NotNull(listResponse);
Assert.Single(listResponse);
Assert.NotNull(listResponse.NextPageLink);
// list next page
listResponse = testBase.client.UserSubscription.ListNext(listResponse.NextPageLink);
Assert.NotNull(listResponse);
Assert.Single(listResponse);
Assert.Null(listResponse.NextPageLink);
}
}
public async Task GetUpdateKeys()
{
Environment.SetEnvironmentVariable("AZURE_TEST_MODE", "Playback");
using (MockContext context = MockContext.Start(this.GetType()))
{
var testBase = new ApiManagementTestBase(context);
testBase.TryCreateApiManagementService();
// get settings
var getResponse = testBase.client.TenantAccessGit.Get(
testBase.rgName,
testBase.serviceName);
Assert.NotNull(getResponse);
Assert.NotNull(getResponse);
Assert.True(getResponse.Enabled); // git access is always enabled
Assert.Null(getResponse.PrimaryKey);
Assert.Null(getResponse.SecondaryKey);
var secretsResponse = testBase.client.TenantAccessGit.ListSecrets(
testBase.rgName,
testBase.serviceName);
Assert.NotNull(secretsResponse.PrimaryKey);
Assert.NotNull(secretsResponse.SecondaryKey);
testBase.client.TenantAccessGit.RegeneratePrimaryKey(
testBase.rgName,
testBase.serviceName);
var secretsResponse2 = testBase.client.TenantAccessGit.ListSecrets(
testBase.rgName,
testBase.serviceName);
Assert.NotNull(secretsResponse2);
Assert.Equal(secretsResponse.SecondaryKey, secretsResponse2.SecondaryKey);
Assert.NotEqual(secretsResponse.PrimaryKey, secretsResponse2.PrimaryKey);
testBase.client.TenantAccessGit.RegenerateSecondaryKey(
testBase.rgName,
testBase.serviceName);
var getSecretsHttpResponse = await testBase.client.TenantAccessGit.ListSecretsWithHttpMessagesAsync(
testBase.rgName,
testBase.serviceName);
Assert.NotNull(getSecretsHttpResponse);
Assert.NotNull(getSecretsHttpResponse.Body);
Assert.NotNull(getSecretsHttpResponse.Headers.ETag);
Assert.NotEqual(secretsResponse.SecondaryKey, getSecretsHttpResponse.Body.SecondaryKey);
}
}
public async Task CreateUpdateReset()
{
Environment.SetEnvironmentVariable("AZURE_TEST_MODE", "Playback");
using (MockContext context = MockContext.Start(this.GetType()))
{
var testBase = new ApiManagementTestBase(context);
testBase.TryCreateApiManagementService();
// get the existing settings on the service
var portalSignInSettings = await testBase.client.SignInSettings.GetAsync(
testBase.rgName,
testBase.serviceName);
Assert.NotNull(portalSignInSettings);
// disable portal signIn
portalSignInSettings.Enabled = false;
portalSignInSettings = testBase.client.SignInSettings.CreateOrUpdate(
testBase.rgName,
testBase.serviceName,
portalSignInSettings);
Assert.NotNull(portalSignInSettings);
Assert.False(portalSignInSettings.Enabled);
// check settings
var signInTag = await testBase.client.SignInSettings.GetEntityTagAsync(
testBase.rgName,
testBase.serviceName);
Assert.NotNull(signInTag);
Assert.NotNull(signInTag.ETag);
// reset the signIn settings
portalSignInSettings.Enabled = true;
await testBase.client.SignInSettings.UpdateAsync(
testBase.rgName,
testBase.serviceName,
portalSignInSettings,
signInTag.ETag);
// get the delegation settings
portalSignInSettings = await testBase.client.SignInSettings.GetAsync(
testBase.rgName,
testBase.serviceName);
Assert.NotNull(portalSignInSettings);
Assert.True(portalSignInSettings.Enabled);
}
}
public void ListPortalSetting()
{
Environment.SetEnvironmentVariable("AZURE_TEST_MODE", "Playback");
using (MockContext context = MockContext.Start(this.GetType()))
{
var testBase = new ApiManagementTestBase(context);
testBase.TryCreateApiManagementService();
// get the existing settings on the service
var portalSettings = testBase.client.PortalSettings.ListByService(
testBase.rgName,
testBase.serviceName);
Assert.NotNull(portalSettings);
}
}
public void SetupSystemAssignedMsiTests()
{
Environment.SetEnvironmentVariable("AZURE_TEST_MODE", "Playback");
using (MockContext context = MockContext.Start(this.GetType()))
{
var testBase = new ApiManagementTestBase(context);
string consumptionSkuRegion = "West US";
// setup MSI on Consumption SKU
testBase.serviceProperties.Location = consumptionSkuRegion;
testBase.serviceProperties.Sku = new ApiManagementServiceSkuProperties(SkuType.Consumption, capacity: 0);
testBase.serviceProperties.Identity = new ApiManagementServiceIdentity("SystemAssigned");
var createdService = testBase.client.ApiManagementService.CreateOrUpdate(
resourceGroupName: testBase.rgName,
serviceName: testBase.serviceName,
parameters: testBase.serviceProperties);
ValidateService(createdService,
testBase.serviceName,
testBase.rgName,
testBase.subscriptionId,
consumptionSkuRegion,
testBase.serviceProperties.PublisherEmail,
testBase.serviceProperties.PublisherName,
testBase.serviceProperties.Sku.Name,
testBase.tags,
PlatformVersion.Mtv1);
Assert.NotNull(createdService.Identity);
Assert.Equal("SystemAssigned", createdService.Identity.Type);
Assert.NotNull(createdService.Identity.PrincipalId);
Assert.NotNull(createdService.Identity.TenantId);
// Delete
testBase.client.ApiManagementService.Delete(
resourceGroupName: testBase.rgName,
serviceName: testBase.serviceName);
Assert.Throws <ErrorResponseException>(() =>
{
testBase.client.ApiManagementService.Get(
resourceGroupName: testBase.rgName,
serviceName: testBase.serviceName);
});
}
}
public async Task List()
{
Environment.SetEnvironmentVariable("AZURE_TEST_MODE", "Playback");
using (MockContext context = MockContext.Start(this.GetType()))
{
var testBase = new ApiManagementTestBase(context);
testBase.TryCreateApiManagementService();
var regions = await testBase.client.Region.ListByServiceAsync(
testBase.rgName,
testBase.serviceName);
Assert.NotNull(regions);
Assert.Single(regions);
Assert.Equal(testBase.location.ToLowerInvariant().Replace(" ", ""), regions.First().Name.ToLowerInvariant().Replace(" ", ""));
Assert.True(regions.First().IsMasterRegion);
}
}
public void SetupMsiTests()
{
Environment.SetEnvironmentVariable("AZURE_TEST_MODE", "Playback");
using (MockContext context = MockContext.Start(this.GetType().FullName))
{
var testBase = new ApiManagementTestBase(context);
testBase.serviceProperties.Identity = new ApiManagementServiceIdentity();
var createdService = testBase.client.ApiManagementService.CreateOrUpdate(
resourceGroupName: testBase.rgName,
serviceName: testBase.serviceName,
parameters: testBase.serviceProperties);
ValidateService(createdService,
testBase.serviceName,
testBase.rgName,
testBase.subscriptionId,
testBase.location,
testBase.serviceProperties.PublisherEmail,
testBase.serviceProperties.PublisherName,
testBase.serviceProperties.Sku.Name,
testBase.tags);
Assert.NotNull(createdService.Identity);
Assert.NotNull(createdService.Identity.PrincipalId);
Assert.NotNull(createdService.Identity.TenantId);
// Delete
testBase.client.ApiManagementService.Delete(
resourceGroupName: testBase.rgName,
serviceName: testBase.serviceName);
Assert.Throws <CloudException>(() =>
{
testBase.client.ApiManagementService.Get(
resourceGroupName: testBase.rgName,
serviceName: testBase.serviceName);
});
}
}
public async Task ListAndGetSetting()
{
Environment.SetEnvironmentVariable("AZURE_TEST_MODE", "Playback");
using (MockContext context = MockContext.Start(this.GetType()))
{
var testBase = new ApiManagementTestBase(context);
testBase.TryCreateApiManagementService();
// list tenant access
var listSettings = testBase.client.TenantSettings.ListByService(
testBase.rgName,
testBase.serviceName);
Assert.NotNull(listSettings);
// there is only one setting `public`
var getSetting = await testBase.client.TenantSettings.GetAsync(testBase.rgName, testBase.serviceName);
Assert.NotNull(getSetting.Settings);
Assert.True(getSetting.Settings.Count > 1);
}
}
public void UserIdentities()
{
Environment.SetEnvironmentVariable("AZURE_TEST_MODE", "Playback");
using (MockContext context = MockContext.Start(this.GetType().FullName))
{
var testBase = new ApiManagementTestBase(context);
testBase.TryCreateApiManagementService();
// there should be 'Echo API' which is created by default for every new instance of API Management and
// 'Starter' product
var listUsersResponse = testBase.client.User.ListByService(
testBase.rgName,
testBase.serviceName,
new Microsoft.Rest.Azure.OData.ODataQuery <UserContract> {
Filter = "firstName eq 'Administrator'"
});
Assert.NotNull(listUsersResponse);
Assert.Single(listUsersResponse);
var user = listUsersResponse.Single();
// list user identities
var listResponse = testBase.client.UserIdentities.List(
testBase.rgName,
testBase.serviceName,
user.Name);
Assert.NotNull(listResponse);
// there should be Azure identification
Assert.Single(listResponse);
Assert.Equal(user.Email, listResponse.Single().Id);
Assert.Equal("Azure", listResponse.Single().Provider);
}
}
public async Task UpdateHostNameTests()
{
Environment.SetEnvironmentVariable("AZURE_TEST_MODE", "Playback");
using (MockContext context = MockContext.Start(this.GetType().FullName))
{
var testBase = new ApiManagementTestBase(context);
var createdService = testBase.client.ApiManagementService.CreateOrUpdate(
resourceGroupName: testBase.rgName,
serviceName: testBase.serviceName,
parameters: testBase.serviceProperties);
ValidateService(createdService,
testBase.serviceName,
testBase.rgName,
testBase.subscriptionId,
testBase.location,
testBase.serviceProperties.PublisherEmail,
testBase.serviceProperties.PublisherName,
testBase.serviceProperties.Sku.Name,
testBase.tags);
var base64ArrayCertificate = Convert.FromBase64String(testBase.base64EncodedTestCertificateData);
var cert = new X509Certificate2(base64ArrayCertificate, testBase.testCertificatePassword);
var uploadCertificateParams = new ApiManagementServiceUploadCertificateParameters()
{
Type = HostnameType.Proxy,
Certificate = testBase.base64EncodedTestCertificateData,
CertificatePassword = testBase.testCertificatePassword
};
var certificateInformation = await testBase.client.ApiManagementService.UploadCertificateAsync(testBase.rgName, testBase.serviceName, uploadCertificateParams);
Assert.NotNull(certificateInformation);
Assert.Equal(cert.Thumbprint, certificateInformation.Thumbprint);
Assert.Equal(cert.Subject, certificateInformation.Subject);
var updateHostnameParams = new ApiManagementServiceUpdateHostnameParameters()
{
Update = new List <HostnameConfigurationOld>()
{
new HostnameConfigurationOld(HostnameType.Proxy, "proxy.msitesting.net", certificateInformation)
}
};
var serviceResource = await testBase.client.ApiManagementService.UpdateHostnameAsync(
testBase.rgName,
testBase.serviceName,
updateHostnameParams);
Assert.NotNull(serviceResource);
Assert.Single(serviceResource.HostnameConfigurations);
Assert.Equal(HostnameType.Proxy, serviceResource.HostnameConfigurations.First().Type);
Assert.Equal("proxy.msitesting.net", serviceResource.HostnameConfigurations.First().HostName);
// Delete
testBase.client.ApiManagementService.Delete(
resourceGroupName: testBase.rgName,
serviceName: testBase.serviceName);
Assert.Throws <CloudException>(() =>
{
testBase.client.ApiManagementService.Get(
resourceGroupName: testBase.rgName,
serviceName: testBase.serviceName);
});
}
}
public async Task GetRegenerateKeys()
{
Environment.SetEnvironmentVariable("AZURE_TEST_MODE", "Playback");
using (MockContext context = MockContext.Start(this.GetType()))
{
var testBase = new ApiManagementTestBase(context);
testBase.TryCreateApiManagementService();
// list gateways: there should be none
var gatewayListResponse = testBase.client.Gateway.ListByService(
testBase.rgName,
testBase.serviceName,
null);
Assert.NotNull(gatewayListResponse);
Assert.Empty(gatewayListResponse);
string gatewayId = TestUtilities.GenerateName("gatewayid");;
try
{
var gatewayContract = new GatewayContract()
{
LocationData = new ResourceLocationDataContract()
{
City = "Seattle",
CountryOrRegion = "USA",
District = "King County",
Name = "Microsoft"
},
Description = TestUtilities.GenerateName()
};
var createResponse = await testBase.client.Gateway.CreateOrUpdateAsync(
testBase.rgName,
testBase.serviceName,
gatewayId,
gatewayContract);
Assert.NotNull(createResponse);
Assert.Equal(gatewayId, createResponse.Name);
Assert.Equal(gatewayContract.Description, createResponse.Description);
Assert.NotNull(createResponse.LocationData);
Assert.Equal(gatewayContract.LocationData.City, createResponse.LocationData.City);
Assert.Equal(gatewayContract.LocationData.CountryOrRegion, createResponse.LocationData.CountryOrRegion);
Assert.Equal(gatewayContract.LocationData.District, createResponse.LocationData.District);
Assert.Equal(gatewayContract.LocationData.Name, createResponse.LocationData.Name);
// get keys
var getResponse = await testBase.client.Gateway.ListKeysAsync(
testBase.rgName,
testBase.serviceName,
gatewayId);
Assert.NotNull(getResponse);
Assert.NotNull(getResponse.Primary);
Assert.NotNull(getResponse.Secondary);
var primaryKey = getResponse.Primary;
var secondaryKey = getResponse.Secondary;
Assert.NotEqual(primaryKey, secondaryKey);
var expiry = DateTime.UtcNow;
// generate token
var tokenResponse = await testBase.client.Gateway.GenerateTokenAsync(
testBase.rgName,
testBase.serviceName,
gatewayId,
new GatewayTokenRequestContract()
{
Expiry = expiry, KeyType = KeyType.Primary
});
Assert.NotNull(tokenResponse);
Assert.NotNull(tokenResponse.Value);
var primaryToken = tokenResponse.Value;
//check the same token stays
tokenResponse = await testBase.client.Gateway.GenerateTokenAsync(
testBase.rgName,
testBase.serviceName,
gatewayId,
new GatewayTokenRequestContract()
{
Expiry = expiry, KeyType = KeyType.Primary
});
Assert.NotNull(tokenResponse);
Assert.NotNull(tokenResponse.Value);
Assert.Equal(primaryToken, tokenResponse.Value);
// generate secondary token
tokenResponse = await testBase.client.Gateway.GenerateTokenAsync(
testBase.rgName,
testBase.serviceName,
gatewayId,
new GatewayTokenRequestContract()
{
Expiry = expiry, KeyType = KeyType.Secondary
});
Assert.NotNull(tokenResponse);
Assert.NotNull(tokenResponse.Value);
var secondaryToken = tokenResponse.Value;
Assert.NotEqual(primaryToken, secondaryToken);
//change keys
await testBase.client.Gateway.RegenerateKeyAsync(
testBase.rgName,
testBase.serviceName,
gatewayId,
new GatewayKeyRegenerationRequestContract()
{
KeyType = KeyType.Primary
});
await testBase.client.Gateway.RegenerateKeyAsync(
testBase.rgName,
testBase.serviceName,
gatewayId,
new GatewayKeyRegenerationRequestContract()
{
KeyType = KeyType.Secondary
});
// get keys
getResponse = await testBase.client.Gateway.ListKeysAsync(
testBase.rgName,
testBase.serviceName,
gatewayId);
Assert.NotNull(getResponse);
Assert.NotNull(getResponse.Primary);
Assert.NotNull(getResponse.Secondary);
Assert.NotEqual(primaryKey, getResponse.Primary);
Assert.NotEqual(secondaryKey, getResponse.Secondary);
// generate token
tokenResponse = await testBase.client.Gateway.GenerateTokenAsync(
testBase.rgName,
testBase.serviceName,
gatewayId,
new GatewayTokenRequestContract()
{
Expiry = expiry, KeyType = KeyType.Primary
});
Assert.NotNull(tokenResponse);
Assert.NotNull(tokenResponse.Value);
Assert.NotEqual(primaryToken, tokenResponse.Value);
// generate secondary token
tokenResponse = await testBase.client.Gateway.GenerateTokenAsync(
testBase.rgName,
testBase.serviceName,
gatewayId,
new GatewayTokenRequestContract()
{
Expiry = expiry, KeyType = KeyType.Secondary
});
Assert.NotNull(tokenResponse);
Assert.NotNull(tokenResponse.Value);
Assert.NotEqual(secondaryToken, tokenResponse.Value);
}
finally
{
testBase.client.Gateway.Delete(testBase.rgName, testBase.serviceName, gatewayId, "*");
}
}
}
public async Task CreateListUpdateDelete()
{
Environment.SetEnvironmentVariable("AZURE_TEST_MODE", "Playback");
using (MockContext context = MockContext.Start(this.GetType()))
{
var testBase = new ApiManagementTestBase(context);
testBase.TryCreateApiManagementService();
// list gateways: there should be none
var gatewayListResponse = testBase.client.Gateway.ListByService(
testBase.rgName,
testBase.serviceName,
null);
Assert.NotNull(gatewayListResponse);
Assert.Empty(gatewayListResponse);
// list all the APIs
var apisResponse = testBase.client.Api.ListByService(
testBase.rgName,
testBase.serviceName,
null);
Assert.NotNull(apisResponse);
Assert.Single(apisResponse);
Assert.Null(apisResponse.NextPageLink);
var echoApi = apisResponse.First();
string gatewayId = TestUtilities.GenerateName("gatewayid");;
string certificateId = TestUtilities.GenerateName("certificateId");
string hostnameConfigId = TestUtilities.GenerateName("hostnameConfigId");
try
{
var gatewayContract = new GatewayContract()
{
LocationData = new ResourceLocationDataContract()
{
City = "Seattle",
CountryOrRegion = "USA",
District = "King County",
Name = "Microsoft"
},
Description = TestUtilities.GenerateName()
};
var createResponse = await testBase.client.Gateway.CreateOrUpdateAsync(
testBase.rgName,
testBase.serviceName,
gatewayId,
gatewayContract);
Assert.NotNull(createResponse);
Assert.Equal(gatewayId, createResponse.Name);
Assert.Equal(gatewayContract.Description, createResponse.Description);
Assert.NotNull(createResponse.LocationData);
Assert.Equal(gatewayContract.LocationData.City, createResponse.LocationData.City);
Assert.Equal(gatewayContract.LocationData.CountryOrRegion, createResponse.LocationData.CountryOrRegion);
Assert.Equal(gatewayContract.LocationData.District, createResponse.LocationData.District);
Assert.Equal(gatewayContract.LocationData.Name, createResponse.LocationData.Name);
// get the gateway to check is was created
var getResponse = await testBase.client.Gateway.GetWithHttpMessagesAsync(
testBase.rgName,
testBase.serviceName,
gatewayId);
Assert.NotNull(getResponse);
Assert.Equal(gatewayId, getResponse.Body.Name);
// list gateways
gatewayListResponse = testBase.client.Gateway.ListByService(
testBase.rgName,
testBase.serviceName,
null);
Assert.NotNull(gatewayListResponse);
Assert.Single(gatewayListResponse);
var associationContract = new AssociationContract()
{
ProvisioningState = ProvisioningState.Created
};
// assign gateway to api
var assignResponse = await testBase.client.GatewayApi.CreateOrUpdateAsync(
testBase.rgName,
testBase.serviceName,
gatewayId,
echoApi.Name,
associationContract);
Assert.NotNull(assignResponse);
Assert.Equal(echoApi.Name, assignResponse.Name);
// list gateway apis
var apiGatewaysResponse = await testBase.client.GatewayApi.ListByServiceAsync(
testBase.rgName,
testBase.serviceName,
gatewayId);
Assert.NotNull(apiGatewaysResponse);
Assert.Single(apiGatewaysResponse);
Assert.Equal(echoApi.Name, apiGatewaysResponse.First().Name);
//certificate first:
var base64ArrayCertificate = Convert.FromBase64String(testBase.base64EncodedTestCertificateData);
var cert = new X509Certificate2(base64ArrayCertificate, testBase.testCertificatePassword);
var certCreateResponse = testBase.client.Certificate.CreateOrUpdate(
testBase.rgName,
testBase.serviceName,
certificateId,
new CertificateCreateOrUpdateParameters
{
Data = testBase.base64EncodedTestCertificateData,
Password = testBase.testCertificatePassword
},
null);
//GatewayCertificateAuthority:
var gatewayCertificateAuthority = new GatewayCertificateAuthorityContract()
{
IsTrusted = true
};
var gatewayCertificateAuthorityCreateResponse = await testBase.client.GatewayCertificateAuthority.CreateOrUpdateWithHttpMessagesAsync(
testBase.rgName,
testBase.serviceName,
gatewayId,
certificateId,
gatewayCertificateAuthority
);
Assert.NotNull(gatewayCertificateAuthorityCreateResponse);
Assert.Equal(certificateId, gatewayCertificateAuthorityCreateResponse.Body.Name);
Assert.True(gatewayCertificateAuthorityCreateResponse.Body.IsTrusted);
var gatewayCertificateAuthorityResponse = await testBase.client.GatewayCertificateAuthority.GetAsync(
testBase.rgName,
testBase.serviceName,
gatewayId,
certificateId
);
Assert.NotNull(gatewayCertificateAuthorityResponse);
Assert.Equal(certificateId, gatewayCertificateAuthorityResponse.Name);
Assert.True(gatewayCertificateAuthorityResponse.IsTrusted);
//delete
testBase.client.GatewayCertificateAuthority.Delete(
testBase.rgName,
testBase.serviceName,
gatewayId,
certificateId,
"*");
//hostnameConfiguration:
var hostnameConfig = new GatewayHostnameConfigurationContract()
{
CertificateId = certCreateResponse.Id,
Hostname = "www.contoso.com",
NegotiateClientCertificate = false
};
var hostnameConfigCreateResponse = await testBase.client.GatewayHostnameConfiguration.CreateOrUpdateAsync(
testBase.rgName,
testBase.serviceName,
gatewayId,
hostnameConfigId,
hostnameConfig
);
Assert.NotNull(hostnameConfigCreateResponse);
Assert.Equal(hostnameConfigId, hostnameConfigCreateResponse.Name);
Assert.Equal(hostnameConfigCreateResponse.CertificateId, hostnameConfigCreateResponse.CertificateId);
Assert.Equal("www.contoso.com", hostnameConfigCreateResponse.Hostname);
Assert.False(hostnameConfigCreateResponse.NegotiateClientCertificate);
var hostnameConfigResponse = await testBase.client.GatewayHostnameConfiguration.GetAsync(
testBase.rgName,
testBase.serviceName,
gatewayId,
hostnameConfigId
);
Assert.NotNull(hostnameConfigCreateResponse);
Assert.Equal(hostnameConfigId, hostnameConfigCreateResponse.Name);
Assert.Equal(hostnameConfigCreateResponse.CertificateId, hostnameConfigCreateResponse.CertificateId);
Assert.Equal("www.contoso.com", hostnameConfigCreateResponse.Hostname);
Assert.False(hostnameConfigCreateResponse.NegotiateClientCertificate);
//delete hostname config
testBase.client.GatewayHostnameConfiguration.Delete(
testBase.rgName,
testBase.serviceName,
gatewayId,
hostnameConfigId,
"*");
//get latest etag for delete
getResponse = await testBase.client.Gateway.GetWithHttpMessagesAsync(
testBase.rgName,
testBase.serviceName,
gatewayId);
// remove the gateway
testBase.client.Gateway.Delete(
testBase.rgName,
testBase.serviceName,
gatewayId,
getResponse.Headers.ETag);
// list again to see it was removed
gatewayListResponse = testBase.client.Gateway.ListByService(
testBase.rgName,
testBase.serviceName,
null);
Assert.NotNull(gatewayListResponse);
Assert.Empty(gatewayListResponse);
}
finally
{
try
{
testBase.client.GatewayHostnameConfiguration.Delete(testBase.rgName, testBase.serviceName, gatewayId, hostnameConfigId, "*");
}
catch (ErrorResponseException) { }
testBase.client.Gateway.Delete(testBase.rgName, testBase.serviceName, gatewayId, "*");
testBase.client.Certificate.Delete(testBase.rgName, testBase.serviceName, certificateId, "*");
}
}
}
public async Task CreateUpdateDelete()
{
Environment.SetEnvironmentVariable("AZURE_TEST_MODE", "Playback");
using (MockContext context = MockContext.Start(this.GetType()))
{
var testBase = new ApiManagementTestBase(context);
testBase.TryCreateApiManagementService();
// list all the APIs
var apiListResponse = testBase.client.Api.ListByService(
testBase.rgName,
testBase.serviceName,
null);
Assert.NotNull(apiListResponse);
Assert.Single(apiListResponse);
Assert.Null(apiListResponse.NextPageLink);
// find the echo api
var echoApi = apiListResponse.First();
// list users
var listUsersResponse = testBase.client.User.ListByService(
testBase.rgName,
testBase.serviceName,
null);
Assert.NotNull(listUsersResponse);
Assert.Single(listUsersResponse);
var adminUser = listUsersResponse.First();
// there should be now issues initially
var issuesList = testBase.client.ApiIssue.ListByService(
testBase.rgName,
testBase.serviceName,
echoApi.Name,
null);
Assert.NotNull(issuesList);
Assert.Empty(issuesList);
string newissueId = TestUtilities.GenerateName("newIssue");
string newcommentId = TestUtilities.GenerateName("newComment");
string newattachmentId = TestUtilities.GenerateName("newattachment");
const string attachmentPath = "./Resources/apiissueattachment.JPG";
try
{
// add a recipient to the notification
var issueContract = new IssueContract()
{
Title = TestUtilities.GenerateName("title"),
Description = TestUtilities.GenerateName("description"),
UserId = adminUser.Id,
ApiId = echoApi.Id,
CreatedDate = DateTime.UtcNow
};
var apiIssueContract = await testBase.client.ApiIssue.CreateOrUpdateAsync(
testBase.rgName,
testBase.serviceName,
echoApi.Name,
newissueId,
issueContract);
Assert.NotNull(apiIssueContract);
Assert.Equal(echoApi.Id, apiIssueContract.ApiId);
Assert.Equal(State.Proposed, apiIssueContract.State);
Assert.Equal(issueContract.Title, apiIssueContract.Title);
// get the issue
var issueData = await testBase.client.ApiIssue.GetAsync(
testBase.rgName,
testBase.serviceName,
echoApi.Name,
newissueId);
Assert.NotNull(issueData);
Assert.Equal(issueData.Name, newissueId);
Assert.Equal(adminUser.Id, issueData.UserId);
// update the issue
var updateTitle = TestUtilities.GenerateName("updatedTitle");
var updateDescription = TestUtilities.GenerateName("updateddescription");
var issueUpdateContract = new IssueUpdateContract()
{
Description = updateDescription,
Title = updateTitle
};
await testBase.client.ApiIssue.UpdateAsync(
testBase.rgName,
testBase.serviceName,
echoApi.Name,
newissueId,
issueUpdateContract,
"*");
// get the issue
issueData = await testBase.client.ApiIssue.GetAsync(
testBase.rgName,
testBase.serviceName,
echoApi.Name,
newissueId);
Assert.NotNull(issueData);
Assert.Equal(issueData.Name, newissueId);
Assert.Equal(adminUser.Id, issueData.UserId);
Assert.Equal(updateTitle, issueData.Title);
Assert.Equal(updateDescription, issueData.Description);
// get commments on issue. there should be none initially
var emptyCommentList = await testBase.client.ApiIssueComment.ListByServiceAsync(
testBase.rgName,
testBase.serviceName,
echoApi.Name,
newissueId,
null);
Assert.Empty(emptyCommentList);
// add a comment
var issueCommentParameters = new IssueCommentContract()
{
Text = TestUtilities.GenerateName("issuecommenttext"),
UserId = adminUser.Id,
CreatedDate = DateTime.UtcNow
};
var addedComment = await testBase.client.ApiIssueComment.CreateOrUpdateAsync(
testBase.rgName,
testBase.serviceName,
echoApi.Name,
newissueId,
newcommentId,
issueCommentParameters);
Assert.NotNull(addedComment);
Assert.Equal(addedComment.Name, newcommentId);
// https://msazure.visualstudio.com/DefaultCollection/One/_workitems/edit/4402087
//Assert.Equal(addedComment.UserId, adminUser.Id); //Bug userId is not getting populated
Assert.NotNull(addedComment.CreatedDate);
// get the comment tag.
var commentEntityTag = await testBase.client.ApiIssueComment.GetEntityTagAsync(
testBase.rgName,
testBase.serviceName,
echoApi.Name,
newissueId,
newcommentId);
Assert.NotNull(commentEntityTag);
Assert.NotNull(commentEntityTag.ETag);
// delete the commment
await testBase.client.ApiIssueComment.DeleteAsync(
testBase.rgName,
testBase.serviceName,
echoApi.Name,
newissueId,
newcommentId,
commentEntityTag.ETag);
try
{
// get the apicomment
var getComment = await testBase.client.ApiIssueComment.GetAsync(
testBase.rgName,
testBase.serviceName,
echoApi.Name,
newissueId,
newcommentId);
// should not come here
throw new Exception("This code should not have been executed.");
}
catch (ErrorResponseException ex)
{
Assert.Equal(HttpStatusCode.NotFound, ex.Response.StatusCode);
}
// get the issue attachments
var apiIssueAttachments = await testBase.client.ApiIssueAttachment.ListByServiceAsync(
testBase.rgName,
testBase.serviceName,
echoApi.Name,
newissueId,
null);
Assert.Empty(apiIssueAttachments);
// add an attachment to the issue
FileInfo fileInfo = new FileInfo(attachmentPath);
// The byte[] to save the data in
byte[] data = new byte[fileInfo.Length];
// Load a filestream and put its content into the byte[]
using (FileStream fs = fileInfo.OpenRead())
{
fs.Read(data, 0, data.Length);
}
var content = Convert.ToBase64String(data);
var issueAttachmentContract = new IssueAttachmentContract()
{
Content = content,
ContentFormat = "image/jpeg",
Title = TestUtilities.GenerateName("attachment")
};
var issueAttachment = await testBase.client.ApiIssueAttachment.CreateOrUpdateAsync(
testBase.rgName,
testBase.serviceName,
echoApi.Name,
newissueId,
newattachmentId,
issueAttachmentContract);
Assert.NotNull(issueAttachment);
Assert.Equal(newattachmentId, issueAttachment.Name);
Assert.Equal("link", issueAttachment.ContentFormat);
Assert.NotNull(issueAttachment.Content);
// get the attachment tag
var issueAttachmentTag = await testBase.client.ApiIssueAttachment.GetEntityTagAsync(
testBase.rgName,
testBase.serviceName,
echoApi.Name,
newissueId,
newattachmentId);
Assert.NotNull(issueAttachmentTag);
Assert.NotNull(issueAttachmentTag.ETag);
// delete the attachment
await testBase.client.ApiIssueAttachment.DeleteAsync(
testBase.rgName,
testBase.serviceName,
echoApi.Name,
newissueId,
newattachmentId,
issueAttachmentTag.ETag);
try
{
var issueattachment = await testBase.client.ApiIssueAttachment.GetAsync(
testBase.rgName,
testBase.serviceName,
echoApi.Name,
newissueId,
newattachmentId);
// it should not reach here.
throw new Exception("This code should not have been executed.");
}
catch (ErrorResponseException ex)
{
Assert.Equal(HttpStatusCode.NotFound, ex.Response.StatusCode);
}
// get the issue tag
var apiIssuetag = await testBase.client.ApiIssue.GetEntityTagAsync(
testBase.rgName,
testBase.serviceName,
echoApi.Name,
newissueId);
Assert.NotNull(apiIssuetag);
// delete the issue
await testBase.client.ApiIssue.DeleteAsync(
testBase.rgName,
testBase.serviceName,
echoApi.Name,
newissueId,
apiIssuetag.ETag);
// check the issue exist
try
{
var apiIssue = await testBase.client.ApiIssue.GetAsync(
testBase.rgName,
testBase.serviceName,
echoApi.Name,
newissueId);
// it should not reach here.
throw new Exception("This code should not have been executed.");
}
catch (ErrorResponseException ex)
{
Assert.Equal(HttpStatusCode.NotFound, ex.Response.StatusCode);
}
}
finally
{
// cleanup the api issue attachment, if exists
testBase.client.ApiIssueAttachment.Delete(
testBase.rgName,
testBase.serviceName,
echoApi.Name,
newissueId,
newattachmentId,
"*");
// cleanup the api issue comment if exists
testBase.client.ApiIssueComment.Delete(
testBase.rgName,
testBase.serviceName,
echoApi.Name,
newissueId,
newcommentId,
"*");
// cleanup the api issue if exists
testBase.client.ApiIssue.Delete(
testBase.rgName,
testBase.serviceName,
echoApi.Name,
newissueId,
"*");
}
}
}
public async Task CreateListUpdateDelete()
{
Environment.SetEnvironmentVariable("AZURE_TEST_MODE", "Playback");
using (MockContext context = MockContext.Start(this.GetType()))
{
var testBase = new ApiManagementTestBase(context);
testBase.TryCreateApiManagementService();
var userId = TestUtilities.GenerateName("sdkUserId");
var newGroupId = TestUtilities.GenerateName("sdkGroupId");
try
{
// create a new group
var newGroupDisplayName = TestUtilities.GenerateName("sdkGroup");
var parameters = new GroupCreateParameters()
{
DisplayName = newGroupDisplayName,
Description = "Group created from Sdk client"
};
var groupContract = await testBase.client.Group.CreateOrUpdateAsync(
testBase.rgName,
testBase.serviceName,
newGroupId,
parameters);
Assert.NotNull(groupContract);
Assert.Equal(newGroupDisplayName, groupContract.DisplayName);
Assert.False(groupContract.BuiltIn);
Assert.NotNull(groupContract.Description);
Assert.Equal(GroupType.Custom, groupContract.GroupContractType);
// list all group users
var listResponse = testBase.client.GroupUser.List(
testBase.rgName,
testBase.serviceName,
newGroupId,
null);
Assert.NotNull(listResponse);
Assert.Empty(listResponse);
// create a new user and add to the group
var createParameters = new UserCreateParameters()
{
FirstName = TestUtilities.GenerateName("sdkFirst"),
LastName = TestUtilities.GenerateName("sdkLast"),
Email = TestUtilities.GenerateName("sdkFirst.Last") + "@contoso.com",
State = UserState.Active,
Note = "dummy note"
};
var userContract = testBase.client.User.CreateOrUpdate(
testBase.rgName,
testBase.serviceName,
userId,
createParameters);
Assert.NotNull(userContract);
// add user to group
var addUserContract = testBase.client.GroupUser.Create(
testBase.rgName,
testBase.serviceName,
newGroupId,
userId);
Assert.NotNull(addUserContract);
Assert.Equal(userContract.Email, addUserContract.Email);
Assert.Equal(userContract.FirstName, addUserContract.FirstName);
// list group user
var listgroupResponse = testBase.client.GroupUser.List(
testBase.rgName,
testBase.serviceName,
newGroupId);
Assert.NotNull(listgroupResponse);
Assert.Single(listgroupResponse);
Assert.Equal(addUserContract.Email, listgroupResponse.GetEnumerator().ToIEnumerable().First().Email);
// check entity exists
var entityStatus = await testBase.client.GroupUser.CheckEntityExistsAsync(
testBase.rgName,
testBase.serviceName,
newGroupId,
userId);
Assert.True(entityStatus);
// remove user from group
testBase.client.GroupUser.Delete(
testBase.rgName,
testBase.serviceName,
newGroupId,
userId);
// make sure user is removed
entityStatus = await testBase.client.GroupUser.CheckEntityExistsAsync(
testBase.rgName,
testBase.serviceName,
newGroupId,
userId);
Assert.False(entityStatus);
}
finally
{
// delete the user
testBase.client.User.Delete(
testBase.rgName,
testBase.serviceName,
userId,
"*",
deleteSubscriptions: true);
// delete the group
testBase.client.Group.Delete(
testBase.rgName,
testBase.serviceName,
newGroupId,
"*");
}
}
}
public async Task CreateListUpdateDeleteOperationTags()
{
Environment.SetEnvironmentVariable("AZURE_TEST_MODE", "Playback");
using (MockContext context = MockContext.Start(this.GetType()))
{
var testBase = new ApiManagementTestBase(context);
testBase.TryCreateApiManagementService();
var tagsResources = await testBase.client.Tag.ListByServiceAsync(
testBase.rgName,
testBase.serviceName);
Assert.Empty(tagsResources);
// there should be 'Echo API' which is created by default for every new instance of API Management
var apis = testBase.client.Api.ListByService(
testBase.rgName,
testBase.serviceName);
Assert.Single(apis);
var api = apis.Single();
// list paged
var listResponse = testBase.client.ApiOperation.ListByApi(
testBase.rgName,
testBase.serviceName,
api.Name,
new Microsoft.Rest.Azure.OData.ODataQuery <OperationContract> {
Top = 1
});
var firstOperation = listResponse.First();
string tagId = TestUtilities.GenerateName("operationTag");
try
{
string tagDisplayName = TestUtilities.GenerateName("opreationTag");
var createParameters = new TagCreateUpdateParameters();
createParameters.DisplayName = tagDisplayName;
// create a tag
var tagContract = testBase.client.Tag.CreateOrUpdate(
testBase.rgName,
testBase.serviceName,
tagId,
createParameters);
Assert.NotNull(tagContract);
Assert.Equal(tagDisplayName, tagContract.DisplayName);
// associate the tag with the API Operation
tagContract = await testBase.client.Tag.AssignToOperationAsync(
testBase.rgName,
testBase.serviceName,
api.Name,
firstOperation.Name,
tagId);
Assert.NotNull(tagContract);
// Tag list by Api Operation
var tagsInOperation = await testBase.client.Tag.ListByOperationAsync(
testBase.rgName,
testBase.serviceName,
api.Name,
firstOperation.Name);
Assert.NotNull(tagsInOperation);
Assert.Single(tagsInOperation);
Assert.Equal(tagDisplayName, tagsInOperation.First().DisplayName);
// get the tag on the api operation
var tagOnOperation = await testBase.client.Tag.GetByOperationAsync(
testBase.rgName,
testBase.serviceName,
api.Name,
firstOperation.Name,
tagId);
Assert.NotNull(tagOnOperation);
Assert.Equal(tagDisplayName, tagOnOperation.DisplayName);
// get the tag resources for the service.
var tagResources = await testBase.client.TagResource.ListByServiceAsync(
testBase.rgName,
testBase.serviceName);
Assert.NotNull(tagResources);
Assert.Single(tagResources);
Assert.Equal(tagDisplayName, tagResources.First().Tag.Name);
Assert.Null(tagResources.First().Api);
Assert.NotNull(tagResources.First().Operation);
Assert.Null(tagResources.First().Product);
Assert.Equal(firstOperation.DisplayName, tagResources.GetEnumerator().ToIEnumerable().First().Operation.Name, true);
Assert.Equal(firstOperation.Method, tagResources.GetEnumerator().ToIEnumerable().First().Operation.Method);
// get the tag Etag
var tagEtagByOperation = await testBase.client.Tag.GetEntityStateByOperationAsync(
testBase.rgName,
testBase.serviceName,
api.Name,
firstOperation.Name,
tagId);
Assert.NotNull(tagEtagByOperation);
Assert.NotNull(tagEtagByOperation.ETag);
// detach the tag
await testBase.client.Tag.DetachFromOperationAsync(
testBase.rgName,
testBase.serviceName,
api.Name,
firstOperation.Name,
tagId);
Assert.Throws <ErrorResponseException>(()
=> testBase.client.Tag.GetByOperation(
testBase.rgName,
testBase.serviceName,
api.Name,
firstOperation.Name,
tagId));
var tagEtag = await testBase.client.Tag.GetEntityStateAsync(
testBase.rgName,
testBase.serviceName,
tagId);
Assert.NotNull(tagEtag);
Assert.NotNull(tagEtag.ETag);
//delete the tag
await testBase.client.Tag.DeleteAsync(
testBase.rgName,
testBase.serviceName,
tagId,
tagEtag.ETag);
Assert.Throws <ErrorResponseException>(()
=> testBase.client.Tag.GetEntityState(
testBase.rgName,
testBase.serviceName,
tagId));
}
finally
{
testBase.client.Tag.DetachFromOperation(
testBase.rgName,
testBase.serviceName,
api.Name,
firstOperation.Name,
tagId);
testBase.client.Tag.Delete(
testBase.rgName, testBase.serviceName, tagId, "*");
}
}
}
public async Task CreateListUpdateDeleteApiTags()
{
Environment.SetEnvironmentVariable("AZURE_TEST_MODE", "Playback");
using (MockContext context = MockContext.Start(this.GetType()))
{
var testBase = new ApiManagementTestBase(context);
testBase.TryCreateApiManagementService();
var tagsResources = await testBase.client.Tag.ListByServiceAsync(
testBase.rgName,
testBase.serviceName);
Assert.Empty(tagsResources);
// list all the APIs
var listResponse = testBase.client.Api.ListByService(
testBase.rgName,
testBase.serviceName,
null);
Assert.NotNull(listResponse);
Assert.Single(listResponse);
Assert.Null(listResponse.NextPageLink);
var echoApi = listResponse.First();
string tagId = TestUtilities.GenerateName("apiTag");
try
{
string tagDisplayName = TestUtilities.GenerateName("apiTag");
var createParameters = new TagCreateUpdateParameters();
createParameters.DisplayName = tagDisplayName;
// create a tag
var tagContract = testBase.client.Tag.CreateOrUpdate(
testBase.rgName,
testBase.serviceName,
tagId,
createParameters);
Assert.NotNull(tagContract);
Assert.Equal(tagDisplayName, tagContract.DisplayName);
// associate the tag with the API
tagContract = await testBase.client.Tag.AssignToApiAsync(
testBase.rgName,
testBase.serviceName,
echoApi.Name,
tagId);
Assert.NotNull(tagContract);
// get APIs with Tags
var apisWithTags = await testBase.client.Api.ListByTagsAsync(
testBase.rgName,
testBase.serviceName,
new Microsoft.Rest.Azure.OData.ODataQuery <TagResourceContract>
{
Top = 1
});
Assert.NotNull(apisWithTags);
Assert.Single(apisWithTags);
Assert.Equal(tagContract.DisplayName, apisWithTags.GetEnumerator().ToIEnumerable().First().Tag.Name);
// Tag list by API
var tagsInApi = await testBase.client.Tag.ListByApiAsync(
testBase.rgName,
testBase.serviceName,
echoApi.Name);
Assert.NotNull(tagsInApi);
Assert.Single(tagsInApi);
Assert.Equal(tagDisplayName, tagsInApi.GetEnumerator().ToIEnumerable().First().DisplayName);
// get the tag on the api
var tagOnApi = await testBase.client.Tag.GetByApiAsync(
testBase.rgName,
testBase.serviceName,
echoApi.Name,
tagId);
Assert.NotNull(tagOnApi);
Assert.Equal(tagDisplayName, tagOnApi.DisplayName);
// get the tag Etag
var tagEtagByApi = await testBase.client.Tag.GetEntityStateByApiAsync(
testBase.rgName,
testBase.serviceName,
echoApi.Name,
tagId);
Assert.NotNull(tagEtagByApi);
Assert.NotNull(tagEtagByApi.ETag);
// get the tag resources for the service.
var tagResources = await testBase.client.TagResource.ListByServiceAsync(
testBase.rgName,
testBase.serviceName);
Assert.NotNull(tagResources);
Assert.Single(tagResources);
Assert.Equal(tagDisplayName, tagResources.GetEnumerator().ToIEnumerable().First().Tag.Name);
Assert.NotNull(tagResources.GetEnumerator().ToIEnumerable().First().Api);
Assert.Equal(echoApi.DisplayName, tagResources.GetEnumerator().ToIEnumerable().First().Api.Name);
// detach the tag
await testBase.client.Tag.DetachFromApiAsync(
testBase.rgName,
testBase.serviceName,
echoApi.Name,
tagId);
Assert.Throws <ErrorResponseException>(()
=> testBase.client.Tag.GetByApi(
testBase.rgName,
testBase.serviceName,
echoApi.Name,
tagId));
var tagEtag = await testBase.client.Tag.GetEntityStateAsync(
testBase.rgName,
testBase.serviceName,
tagId);
Assert.NotNull(tagEtag);
Assert.NotNull(tagEtag.ETag);
//delete the tag
await testBase.client.Tag.DeleteAsync(
testBase.rgName,
testBase.serviceName,
tagId,
tagEtag.ETag);
Assert.Throws <ErrorResponseException>(()
=> testBase.client.Tag.GetEntityState(
testBase.rgName,
testBase.serviceName,
tagId));
}
finally
{
testBase.client.Tag.DetachFromApi(
testBase.rgName, testBase.serviceName, echoApi.Name, tagId);
testBase.client.Tag.Delete(
testBase.rgName, testBase.serviceName, tagId, "*");
}
}
}