public async Task Delete()
{
SubscriptionResource subscription = await Client.GetDefaultSubscriptionAsync();
string rgName = Recording.GenerateAssetName("testRg-5-");
ResourceGroupData rgData = new ResourceGroupData(AzureLocation.WestUS2);
var lro = await subscription.GetResourceGroups().CreateOrUpdateAsync(WaitUntil.Completed, rgName, rgData);
ResourceGroupResource rg = lro.Value;
string appDefName = Recording.GenerateAssetName("appDef-D-");
ArmApplicationDefinitionData appDefData = CreateApplicationDefinitionData(appDefName);
ArmApplicationDefinitionResource appDef = (await rg.GetArmApplicationDefinitions().CreateOrUpdateAsync(WaitUntil.Completed, appDefName, appDefData)).Value;
string appName = Recording.GenerateAssetName("application-D-");
ArmApplicationData applicationData = CreateApplicationData(appDef.Id, new ResourceIdentifier(subscription.Id + Recording.GenerateAssetName("/resourceGroups/managed-5-")), Recording.GenerateAssetName("s5"));
ArmApplicationResource application = (await rg.GetArmApplications().CreateOrUpdateAsync(WaitUntil.Completed, appName, applicationData)).Value;
await application.DeleteAsync(WaitUntil.Completed);
var ex = Assert.ThrowsAsync <RequestFailedException>(async() => await application.GetAsync());
Assert.AreEqual(404, ex.Status);
}
private async Task <ArmOperation <VirtualNetworkResource> > createVirtualNetwork()
{
var vnetName = Recording.GenerateAssetName("vnet-");
var vnet = new VirtualNetworkData()
{
Location = Location,
Subnets = { new SubnetData()
{
Name = "default",
AddressPrefix = "10.0.1.0/24",
PrivateEndpointNetworkPolicies = VirtualNetworkPrivateEndpointNetworkPolicies.Disabled
} }
};
vnet.AddressPrefixes.Add("10.0.0.0/16");
vnet.DhcpOptionsDnsServers.Add("10.1.1.1");
vnet.DhcpOptionsDnsServers.Add("10.1.2.4");
VirtualNetworkCollection networks = ResourceGroupResource.GetVirtualNetworks();
return(await networks.CreateOrUpdateAsync(WaitUntil.Completed, vnetName, vnet));
}
public async Task Delete()
{
SubscriptionResource subscription = await Client.GetDefaultSubscriptionAsync();
ResourceGroupResource rg = await CreateResourceGroup(subscription, "testRg-");
string cdnProfileName = Recording.GenerateAssetName("profile-");
ProfileResource cdnProfile = await CreateCdnProfile(rg, cdnProfileName, CdnSkuName.StandardMicrosoft);
string cdnEndpointName = Recording.GenerateAssetName("endpoint-");
CdnEndpointResource cdnEndpoint = await CreateCdnEndpoint(cdnProfile, cdnEndpointName);
string cdnOriginGroupName = Recording.GenerateAssetName("origingroup-");
CdnOriginGroupResource cdnOriginGroup = await CreateCdnOriginGroup(cdnEndpoint, cdnOriginGroupName, cdnEndpoint.Data.Origins[0].Name);
await cdnOriginGroup.DeleteAsync(WaitUntil.Completed);
var ex = Assert.ThrowsAsync <RequestFailedException>(async() => await cdnOriginGroup.GetAsync());
Assert.AreEqual(404, ex.Status);
}
public async Task CreateAvailabilitySet()
{
// First, initialize the ArmClient and get the default subscription
ArmClient armClient = new ArmClient(new DefaultAzureCredential());
// Now we get a ResourceGroupResource collection for that subscription
SubscriptionResource subscription = await armClient.GetDefaultSubscriptionAsync();
ResourceGroupCollection rgCollection = subscription.GetResourceGroups();
// With the collection, we can create a new resource group with an specific name
string rgName = "myRgName";
AzureLocation location = AzureLocation.WestUS2;
ArmOperation<ResourceGroupResource> rgLro = await rgCollection.CreateOrUpdateAsync(WaitUntil.Completed, rgName, new ResourceGroupData(location));
ResourceGroupResource resourceGroup = rgLro.Value;
#region Snippet:Managing_Availability_Set_CreateAnAvailabilitySet
AvailabilitySetCollection availabilitySetCollection = resourceGroup.GetAvailabilitySets();
string availabilitySetName = "myAvailabilitySet";
AvailabilitySetData input = new AvailabilitySetData(location);
ArmOperation<AvailabilitySetResource> lro = await availabilitySetCollection.CreateOrUpdateAsync(WaitUntil.Completed, availabilitySetName, input);
AvailabilitySetResource availabilitySet = lro.Value;
#endregion Snippet:Managing_Availability_Set_CreateAnAvailabilitySet
}
public async Task Delete()
{
SubscriptionResource subscription = await Client.GetDefaultSubscriptionAsync();
ResourceGroupResource rg = await CreateResourceGroup(subscription, "testRg-");
string afdProfileName = Recording.GenerateAssetName("AFDProfile-");
ProfileResource afdProfileResource = await CreateAfdProfile(rg, afdProfileName, CdnSkuName.StandardAzureFrontDoor);
string afdOriginGroupName = Recording.GenerateAssetName("AFDOriginGroup-");
AfdOriginGroupResource afdOriginGroupInstance = await CreateAfdOriginGroup(afdProfileResource, afdOriginGroupName);
string afdOriginName = Recording.GenerateAssetName("AFDOrigin-");
AfdOriginResource afdOriginInstance = await CreateAfdOrigin(afdOriginGroupInstance, afdOriginName);
await afdOriginInstance.DeleteAsync(WaitUntil.Completed);
var ex = Assert.ThrowsAsync <RequestFailedException>(async() => await afdOriginInstance.GetAsync());
Assert.AreEqual(404, ex.Status);
}
public async Task Update()
{
SubscriptionResource subscription = await Client.GetDefaultSubscriptionAsync();
ResourceGroupResource rg = await CreateResourceGroup(subscription, "testRg-");
string afdProfileName = Recording.GenerateAssetName("AFDProfile-");
ProfileResource afdProfile = await CreateAfdProfile(rg, afdProfileName, CdnSkuName.StandardAzureFrontDoor);
string afdEndpointName = Recording.GenerateAssetName("AFDEndpoint-");
FrontDoorEndpointResource afdEndpointInstance = await CreateAfdEndpoint(afdProfile, afdEndpointName);
FrontDoorEndpointPatch updateOptions = new FrontDoorEndpointPatch();
updateOptions.Tags.Add("newTag", "newValue");
var lro = await afdEndpointInstance.UpdateAsync(WaitUntil.Completed, updateOptions);
FrontDoorEndpointResource updatedAfdEndpointInstance = lro.Value;
ResourceDataHelper.AssertAfdEndpointUpdate(updatedAfdEndpointInstance, updateOptions);
}
public async Task ManageAvailabilitySetOld()
{
#region Snippet:Readme_ManageAvailabilitySetOld
ResourceIdentifier id = new ResourceIdentifier("/subscriptions/aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee/resourceGroups/workshop2021-rg/providers/Microsoft.Compute/availabilitySets/ws2021availSet");
// We construct a new client to work with
ArmClient client = new ArmClient(new DefaultAzureCredential());
// Next we get the collection of subscriptions
SubscriptionCollection subscriptions = client.GetSubscriptions();
// Next we get the specific subscription this resource belongs to
SubscriptionResource subscription = await subscriptions.GetAsync(id.SubscriptionId);
// Next we get the collection of resource groups that belong to that subscription
ResourceGroupCollection resourceGroups = subscription.GetResourceGroups();
// Next we get the specific resource group this resource belongs to
ResourceGroupResource resourceGroup = await resourceGroups.GetAsync(id.ResourceGroupName);
// Next we get the collection of availability sets that belong to that resource group
AvailabilitySetCollection availabilitySets = resourceGroup.GetAvailabilitySets();
// Finally we get the resource itself
// Note: for this last step in this example, Azure.ResourceManager.Compute is needed
AvailabilitySetResource availabilitySet = await availabilitySets.GetAsync(id.Name);
#endregion Snippet:Readme_ManageAvailabilitySetOld
}
public async Task EnableAndDisable()
{
//In this test, the CName mapping from custom domain "customdomaintest-5.azuretest.net" to endpoint "testEndpoint4dotnetsdk.azureedge.net" is created in advance.
SubscriptionResource subscription = await Client.GetDefaultSubscriptionAsync();
ResourceGroupResource rg = await subscription.GetResourceGroups().GetAsync("CdnTest");
ProfileResource cdnProfile = await rg.GetProfiles().GetAsync("testProfile");
CdnEndpointResource cdnEndpoint = await cdnProfile.GetCdnEndpoints().GetAsync("testEndpoint4dotnetsdk");
string cdnCustomDomainName = Recording.GenerateAssetName("customDomain-");
string hostName = "customdomaintest-5.azuretest.net";
CdnCustomDomainResource cdnCustomDomain = await CreateCdnCustomDomain(cdnEndpoint, cdnCustomDomainName, hostName);
Assert.ThrowsAsync <RequestFailedException>(async() => await cdnCustomDomain.DisableCustomHttpsAsync(WaitUntil.Completed));
CdnManagedHttpsOptions customDomainHttpsOptions = new CdnManagedHttpsOptions(ProtocolType.ServerNameIndication, new CdnCertificateSourceParameters(CdnCertificateSourceParametersOdataType.MicrosoftAzureCdnModelsCdnCertificateSourceParameters, CertificateType.Dedicated));
Assert.DoesNotThrowAsync(async() => await cdnCustomDomain.EnableCustomHttpsAsync(WaitUntil.Completed, customDomainHttpsOptions));
Assert.DoesNotThrowAsync(async() => await cdnCustomDomain.DisableCustomHttpsAsync(WaitUntil.Completed));
}
[LiveOnly] // Playback error: Fast polling interval of 00:00:00 detected in playback mode. Please use the default WaitForCompletion(). The test framework would automatically reduce the interval in playback.
public async Task StartDelete()
{
var rgOp = await(await Client.GetDefaultSubscriptionAsync().ConfigureAwait(false)).GetResourceGroups().Construct(AzureLocation.WestUS2).CreateOrUpdateAsync(Recording.GenerateAssetName("testrg"));
ResourceGroupResource rg = rgOp.Value;
var createOp = InstrumentOperation(await StartCreateGenericAvailabilitySetAsync(rg.Id));
GenericResource aset = await createOp.WaitForCompletionAsync();
Assert.DoesNotThrowAsync(async() =>
{
var deleteOp = await aset.DeleteAsync(WaitUntil.Started);
_ = await deleteOp.WaitForCompletionResponseAsync();
});
var fakeId = $"/subscriptions/{TestEnvironment.SubscriptionId}/resourceGroups/foo-1";
Assert.ThrowsAsync <RequestFailedException>(async() =>
{
var createOp = await StartCreateGenericAvailabilitySetAsync(new ResourceIdentifier(fakeId));
_ = await createOp.WaitForCompletionAsync();
});
}
public async Task List()
{
SubscriptionResource subscription = await Client.GetDefaultSubscriptionAsync();
ResourceGroupResource rg = await CreateResourceGroup(subscription, "testRg-");
string afdProfileName = Recording.GenerateAssetName("AFDProfile-");
ProfileResource afdProfileResource = await CreateAfdProfile(rg, afdProfileName, CdnSkuName.StandardAzureFrontDoor);
string afdOriginGroupName = Recording.GenerateAssetName("AFDOriginGroup-");
_ = await CreateAfdOriginGroup(afdProfileResource, afdOriginGroupName);
int count = 0;
await foreach (var tempAfdOriginGroup in afdProfileResource.GetAfdOriginGroups().GetAllAsync())
{
count++;
}
Assert.AreEqual(count, 1);
}
public async Task GetAllAvailabilitySets()
{
#region Snippet:Managing_Availability_Set_GetAllAvailabilitySets
// First, initialize the ArmClient and get the default subscription
ArmClient armClient = new ArmClient(new DefaultAzureCredential());
// Now we get a ResourceGroupResource collection for that subscription
SubscriptionResource subscription = await armClient.GetDefaultSubscriptionAsync();
ResourceGroupCollection rgCollection = subscription.GetResourceGroups();
string rgName = "myRgName";
ResourceGroupResource resourceGroup = await rgCollection.GetAsync(rgName);
// First, we get the availability set collection from the resource group
AvailabilitySetCollection availabilitySetCollection = resourceGroup.GetAvailabilitySets();
// With GetAllAsync(), we can get a list of the availability sets in the collection
AsyncPageable<AvailabilitySetResource> response = availabilitySetCollection.GetAllAsync();
await foreach (AvailabilitySetResource availabilitySet in response)
{
Console.WriteLine(availabilitySet.Data.Name);
}
#endregion Snippet:Managing_Availability_Set_GetAllAvailabilitySets
}
public async Task UpdateAccountIdentityFromSystemToNone()
{
_resourceGroup = await CreateResourceGroupAsync();
StorageAccountCollection storageAccountCollection = _resourceGroup.GetStorageAccounts();
string accountName = await CreateValidAccountNameAsync(namePrefix);
var identity = new ManagedServiceIdentity(ManagedServiceIdentityType.SystemAssigned);
var param = GetDefaultStorageAccountParameters(sku: new StorageSku(StorageSkuName.StandardLRS), identity: identity);
StorageAccountResource account1 = (await storageAccountCollection.CreateOrUpdateAsync(WaitUntil.Completed, accountName, param)).Value;
Assert.AreEqual(accountName, account1.Id.Name);
VerifyAccountProperties(account1, false);
Assert.AreEqual(ManagedServiceIdentityType.SystemAssigned, account1.Data.Identity.ManagedServiceIdentityType);
Assert.IsEmpty(account1.Data.Identity.UserAssignedIdentities);
Assert.NotNull(account1.Data.Identity.PrincipalId);
Assert.NotNull(account1.Data.Identity.TenantId);
var noneIdentity = new ManagedServiceIdentity(ManagedServiceIdentityType.None);
StorageAccountPatch parameters = new StorageAccountPatch()
{
Identity = noneIdentity
};
account1 = await account1.UpdateAsync(parameters);
Assert.AreEqual(ManagedServiceIdentityType.None, account1.Data.Identity.ManagedServiceIdentityType);
Assert.IsEmpty(account1.Data.Identity.UserAssignedIdentities);
Assert.Null(account1.Data.Identity.PrincipalId);
Assert.Null(account1.Data.Identity.TenantId);
// validate
StorageAccountResource account2 = await storageAccountCollection.GetAsync(accountName);
Assert.AreEqual(ManagedServiceIdentityType.None, account2.Data.Identity.ManagedServiceIdentityType);
Assert.IsEmpty(account2.Data.Identity.UserAssignedIdentities);
Assert.Null(account2.Data.Identity.PrincipalId);
Assert.Null(account2.Data.Identity.TenantId);
}
public async Task CreateGetUpdateDeleteCluster()
{
//create a cluster
_resourceGroup = await CreateResourceGroupAsync();
string clusterName = Recording.GenerateAssetName("cluster");
EventHubClusterCollection clusterCollection = _resourceGroup.GetEventHubClusters();
EventHubClusterData parameter = new EventHubClusterData(AzureLocation.EastUS2);
EventHubClusterResource cluster = (await clusterCollection.CreateOrUpdateAsync(WaitUntil.Completed, clusterName, parameter)).Value;
Assert.NotNull(cluster);
Assert.AreEqual(cluster.Data.Name, clusterName);
//get the cluster
cluster = await clusterCollection.GetAsync(clusterName);
Assert.NotNull(cluster);
Assert.AreEqual(cluster.Data.Name, clusterName);
//get the namespace under cluster
SubResource subResource = null;
await foreach (var namespaceId in cluster.GetNamespacesAsync())
{
subResource = namespaceId;
break;
}
Assert.NotNull(subResource);
//update the cluster
cluster.Data.Tags.Add("key", "value");
cluster = (await cluster.UpdateAsync(WaitUntil.Completed, cluster.Data)).Value;
Assert.AreEqual(cluster.Data.Tags["key"], "value");
//delete the cluster
await cluster.DeleteAsync(WaitUntil.Completed);
Assert.IsFalse(await clusterCollection.ExistsAsync(clusterName));
}
public async Task GetNamespacesInSubscription()
{
//create two namespaces in two resourcegroups
string namespaceName1 = await CreateValidNamespaceName("testnamespacemgmt1");
string namespaceName2 = await CreateValidNamespaceName("testnamespacemgmt2");
_resourceGroup = await CreateResourceGroupAsync();
ResourceGroupResource resourceGroup = await CreateResourceGroupAsync();
EventHubNamespaceCollection namespaceCollection1 = _resourceGroup.GetEventHubNamespaces();
EventHubNamespaceCollection namespaceCollection2 = resourceGroup.GetEventHubNamespaces();
_ = (await namespaceCollection1.CreateOrUpdateAsync(WaitUntil.Completed, namespaceName1, new EventHubNamespaceData(DefaultLocation))).Value;
_ = (await namespaceCollection2.CreateOrUpdateAsync(WaitUntil.Completed, namespaceName2, new EventHubNamespaceData(DefaultLocation))).Value;
int count = 0;
EventHubNamespaceResource namespace1 = null;
EventHubNamespaceResource namespace2 = null;
//validate
await foreach (EventHubNamespaceResource eventHubNamespace in DefaultSubscription.GetEventHubNamespacesAsync())
{
count++;
if (eventHubNamespace.Id.Name == namespaceName1)
{
namespace1 = eventHubNamespace;
}
if (eventHubNamespace.Id.Name == namespaceName2)
{
namespace2 = eventHubNamespace;
}
}
VerifyNamespaceProperties(namespace1, true);
VerifyNamespaceProperties(namespace2, true);
Assert.AreEqual(namespace1.Id.ResourceGroupName, _resourceGroup.Id.Name);
Assert.AreEqual(namespace2.Id.ResourceGroupName, resourceGroup.Id.Name);
await namespace2.DeleteAsync(WaitUntil.Completed);
}
public async Task GetResourceUsage()
{
SubscriptionResource subscription = await Client.GetDefaultSubscriptionAsync();
ResourceGroupResource rg = await CreateResourceGroup(subscription, "testRg-");
string afdProfileName = Recording.GenerateAssetName("AFDProfile-");
ProfileResource afdProfileResource = await CreateAfdProfile(rg, afdProfileName, CdnSkuName.StandardAzureFrontDoor);
string afdRuleSetName = Recording.GenerateAssetName("AFDRuleSet");
AfdRuleSetResource afdRuleSet = await CreateAfdRuleSet(afdProfileResource, afdRuleSetName);
int count = 0;
await foreach (var tempUsage in afdRuleSet.GetResourceUsagesAsync())
{
count++;
Assert.AreEqual(tempUsage.Unit, UsageUnit.Count);
Assert.AreEqual(tempUsage.CurrentValue, 0);
}
Assert.AreEqual(count, 1);
}
public async Task ValidateCustomDomain()
{
//A CName mapping needs to be created in advance to validate custom domain.
//In this test is "customdomainrecord.azuretest.net" maps to "testEndpoint4dotnetsdk.azureedge.net"
SubscriptionResource subscription = await Client.GetDefaultSubscriptionAsync();
ResourceGroupResource rg = await subscription.GetResourceGroups().GetAsync("CdnTest");
ProfileResource cdnProfile = await rg.GetProfiles().GetAsync("testProfile");
CdnEndpointResource cdnEndpoint = await cdnProfile.GetCdnEndpoints().GetAsync("testEndpoint4dotnetsdk");
ValidateCustomDomainInput validateCustomDomainInput1 = new ValidateCustomDomainInput("customdomainrecord.azuretest.net");
ValidateCustomDomainOutput validateResult = await cdnEndpoint.ValidateCustomDomainAsync(validateCustomDomainInput1);
Assert.True(validateResult.CustomDomainValidated);
ValidateCustomDomainInput validateCustomDomainInput2 = new ValidateCustomDomainInput("customdomainvirtual.azuretest.net");
validateResult = await cdnEndpoint.ValidateCustomDomainAsync(validateCustomDomainInput2);
Assert.False(validateResult.CustomDomainValidated);
}
public async Task CreateNamespaceWithZoneRedundant()
{
IgnoreTestInLiveMode();
//create namespace and wait for completion
string namespaceName = await CreateValidNamespaceName(namespacePrefix);
_resourceGroup = await CreateResourceGroupAsync();
ServiceBusNamespaceCollection namespaceCollection = _resourceGroup.GetServiceBusNamespaces();
var parameters = new ServiceBusNamespaceData(DefaultLocation)
{
Sku = new ServiceBusSku(ServiceBusSkuName.Premium)
{
Tier = ServiceBusSkuTier.Premium
},
ZoneRedundant = true
};
ServiceBusNamespaceResource serviceBusNamespace = (await namespaceCollection.CreateOrUpdateAsync(WaitUntil.Completed, namespaceName, parameters)).Value;
VerifyNamespaceProperties(serviceBusNamespace, false);
Assert.IsTrue(serviceBusNamespace.Data.ZoneRedundant);
}
public async Task GetNamespacesInSubscription()
{
IgnoreTestInLiveMode();
//create two namespaces in two resourcegroups
string namespaceName1 = await CreateValidNamespaceName(namespacePrefix);
_resourceGroup = await CreateResourceGroupAsync();
ResourceGroupResource resourceGroup = await CreateResourceGroupAsync();
ServiceBusNamespaceCollection namespaceCollection1 = _resourceGroup.GetServiceBusNamespaces();
ServiceBusNamespaceCollection namespaceCollection2 = resourceGroup.GetServiceBusNamespaces();
_ = (await namespaceCollection1.CreateOrUpdateAsync(WaitUntil.Completed, namespaceName1, new ServiceBusNamespaceData(DefaultLocation))).Value;
string namespaceName2 = await CreateValidNamespaceName(namespacePrefix);
_ = (await namespaceCollection2.CreateOrUpdateAsync(WaitUntil.Completed, namespaceName2, new ServiceBusNamespaceData(DefaultLocation))).Value;
int count = 0;
ServiceBusNamespaceResource namespace1 = null;
ServiceBusNamespaceResource namespace2 = null;
//validate
await foreach (ServiceBusNamespaceResource serviceBusNamespace in DefaultSubscription.GetServiceBusNamespacesAsync())
{
count++;
if (serviceBusNamespace.Id.Name == namespaceName1)
{
namespace1 = serviceBusNamespace;
}
if (serviceBusNamespace.Id.Name == namespaceName2)
{
namespace2 = serviceBusNamespace;
}
}
VerifyNamespaceProperties(namespace1, true);
VerifyNamespaceProperties(namespace2, true);
Assert.AreEqual(namespace1.Id.ResourceGroupName, _resourceGroup.Id.Name);
Assert.AreEqual(namespace2.Id.ResourceGroupName, resourceGroup.Id.Name);
}
public async Task WhatIfAtResourceGroup()
{
SubscriptionResource subscription = await Client.GetDefaultSubscriptionAsync();
string rgName = Recording.GenerateAssetName("testRg-5-");
ResourceGroupData rgData = new ResourceGroupData(AzureLocation.WestUS2);
var lro = await subscription.GetResourceGroups().CreateOrUpdateAsync(WaitUntil.Completed, rgName, rgData);
ResourceGroupResource rg = lro.Value;
ResourceIdentifier deploymentResourceIdentifier = ArmDeploymentResource.CreateResourceIdentifier(rg.Id, "testDeploymentWhatIf");
ArmDeploymentResource deployment = Client.GetArmDeploymentResource(deploymentResourceIdentifier);
var deploymentWhatIf = new ArmDeploymentWhatIfContent(new ArmDeploymentWhatIfProperties(ArmDeploymentMode.Incremental)
{
Template = CreateDeploymentPropertiesUsingString().Template,
Parameters = CreateDeploymentPropertiesUsingJsonElement().Parameters
});
WhatIfOperationResult whatIfOperationResult = (await deployment.WhatIfAsync(WaitUntil.Completed, deploymentWhatIf)).Value;
Assert.AreEqual(whatIfOperationResult.Status, "Succeeded");
Assert.AreEqual(whatIfOperationResult.Changes.Count, 1);
Assert.AreEqual(whatIfOperationResult.Changes[0].ChangeType, WhatIfChangeType.Create);
}
public async Task StartCreateOrUpdate()
{
SubscriptionResource subscription = await Client.GetDefaultSubscriptionAsync().ConfigureAwait(false);
string rgName = Recording.GenerateAssetName("testRg-");
var rgOp = await subscription.GetResourceGroups().Construct(AzureLocation.WestUS2).CreateOrUpdateAsync(rgName, WaitUntil.Started);
ResourceGroupResource rg = await rgOp.WaitForCompletionAsync();
Assert.AreEqual(rgName, rg.Data.Name);
Assert.ThrowsAsync <ArgumentNullException>(async() =>
{
var rgOp = await subscription.GetResourceGroups().CreateOrUpdateAsync(WaitUntil.Started, null, new ResourceGroupData(AzureLocation.WestUS2));
_ = await rgOp.WaitForCompletionAsync();
});
Assert.ThrowsAsync <ArgumentNullException>(async() =>
{
var rgOp = await subscription.GetResourceGroups().CreateOrUpdateAsync(WaitUntil.Started, rgName, null);
_ = await rgOp.WaitForCompletionAsync();
});
}
public async Task EnableAndDisable()
{
//In this test, the CName mapping from custom domain "customdomaintest5.azuretest.net" to endpoint "testEndpoint4dotnetsdk.azureedge.net" is created in advance.
SubscriptionResource subscription = await Client.GetDefaultSubscriptionAsync();
ResourceGroupResource rg = await subscription.GetResourceGroups().GetAsync("CdnTest");
ProfileResource cdnProfile = await rg.GetProfiles().GetAsync("testProfile");
CdnEndpointResource cdnEndpoint = await cdnProfile.GetCdnEndpoints().GetAsync("testEndpoint4dotnetsdk");
string cdnCustomDomainName = "customdomaintest5-azuretest-net";
var lro = await cdnEndpoint.GetCdnCustomDomains().GetAsync(cdnCustomDomainName);
CdnCustomDomainResource cdnCustomDomain = lro.Value;
Assert.ThrowsAsync <RequestFailedException>(async() => await cdnCustomDomain.DisableCustomHttpsAsync());
CdnManagedHttpsOptions customDomainHttpsOptions = new CdnManagedHttpsOptions(ProtocolType.ServerNameIndication, new CdnCertificateSourceParameters(CdnCertificateSourceParametersTypeName.CdnCertificateSourceParameters, CertificateType.Dedicated));
CdnCustomDomainResource enabledCdnCustomDomain = await cdnCustomDomain.EnableCustomHttpsAsync(customDomainHttpsOptions);
Assert.AreEqual(enabledCdnCustomDomain.Data.CustomHttpsProvisioningState, CustomHttpsProvisioningState.Enabling);
}
public async Task List()
{
SubscriptionResource subscription = await Client.GetDefaultSubscriptionAsync();
ResourceGroupResource rg = await CreateResourceGroup(subscription, "testRg-");
string afdProfileName = Recording.GenerateAssetName("AFDProfile-");
ProfileResource afdProfileResource = await CreateAfdProfile(rg, afdProfileName, CdnSkuName.StandardAzureFrontDoor);
string afdCustomDomainName = Recording.GenerateAssetName("AFDCustomDomain-");
string afdHostName = "customdomain4afd-2.azuretest.net";
_ = await CreateAfdCustomDomain(afdProfile, afdCustomDomainName, afdHostName);
int count = 0;
await foreach (var tempAfdCustomDomain in afdProfile.GetAfdCustomDomains().GetAllAsync())
{
count++;
}
Assert.AreEqual(count, 1);
}
public async Task AddTagToAvailabilitySet()
{
#region Snippet:Managing_Availability_Set_AddTagAvailabilitySet
// First, initialize the ArmClient and get the default subscription
ArmClient armClient = new ArmClient(new DefaultAzureCredential());
// Now we get a ResourceGroupResource collection for that subscription
SubscriptionResource subscription = await armClient.GetDefaultSubscriptionAsync();
ResourceGroupCollection rgCollection = subscription.GetResourceGroups();
string rgName = "myRgName";
ResourceGroupResource resourceGroup = await rgCollection.GetAsync(rgName);
AvailabilitySetCollection availabilitySetCollection = resourceGroup.GetAvailabilitySets();
string availabilitySetName = "myAvailabilitySet";
AvailabilitySetResource availabilitySet = await availabilitySetCollection.GetAsync(availabilitySetName);
// add a tag on this availabilitySet
AvailabilitySetResource updatedAvailabilitySet = await availabilitySet.AddTagAsync("key", "value");
#endregion Snippet:Managing_Availability_Set_AddTagAvailabilitySet
}
public async Task GetWafLogAnalyticsMetrics()
{
SubscriptionResource subscription = await Client.GetDefaultSubscriptionAsync();
ResourceGroupResource rg = await subscription.GetResourceGroups().GetAsync("CdnTest");
ProfileResource afdProfile = await rg.GetProfiles().GetAsync("testAFDPremiumProfile");
List <WafMetric> metric = new List <WafMetric>()
{
WafMetric.ClientRequestCount
};
DateTimeOffset dateTimeBegin = new DateTimeOffset(2021, 9, 23, 0, 0, 0, TimeSpan.Zero);
DateTimeOffset dateTimeEnd = new DateTimeOffset(2021, 9, 25, 0, 0, 0, TimeSpan.Zero);
WafMetricsResponse wafMtricsResponse = await afdProfile.GetWafLogAnalyticsMetricsAsync(metric, dateTimeBegin, dateTimeEnd, WafGranularity.PT5M);
Assert.AreEqual(wafMtricsResponse.Granularity, WafMetricsResponseGranularity.PT5M);
Assert.AreEqual(wafMtricsResponse.Series.Count, 1);
Assert.AreEqual(wafMtricsResponse.Series[0].Metric, WafMetric.ClientRequestCount.ToString());
Assert.AreEqual(wafMtricsResponse.Series[0].Unit, WafMetricsResponseSeriesItemUnit.Count);
Assert.AreEqual(wafMtricsResponse.Series[0].Data.Count, 0);
}
public async Task List()
{
SubscriptionResource subscription = await Client.GetDefaultSubscriptionAsync();
string rgName = Recording.GenerateAssetName("testRg-2-");
ResourceGroupData rgData = new ResourceGroupData(AzureLocation.WestUS2);
var lro = await subscription.GetResourceGroups().CreateOrUpdateAsync(WaitUntil.Completed, rgName, rgData);
ResourceGroupResource rg = lro.Value;
string deployName = Recording.GenerateAssetName("deployEx-L-");
var deploymentData = CreateDeploymentData(CreateDeploymentProperties());
_ = await rg.GetArmDeployments().CreateOrUpdateAsync(WaitUntil.Completed, deployName, deploymentData);
int count = 0;
await foreach (var tempDeployment in rg.GetArmDeployments().GetAllAsync())
{
count++;
}
Assert.AreEqual(count, 1);
}
public async Task CreateAccountWithSystemAndUserAssignedIdentity()
{
_resourceGroup = await CreateResourceGroupAsync();
StorageAccountCollection storageAccountCollection = _resourceGroup.GetStorageAccounts();
string accountName = await CreateValidAccountNameAsync(namePrefix);
var identity = new ManagedServiceIdentity(ManagedServiceIdentityType.SystemAssignedUserAssigned);
var userAssignedIdentity = await CreateUserAssignedIdentityAsync();
identity.UserAssignedIdentities.Add(userAssignedIdentity.Id, new UserAssignedIdentity());
var param = GetDefaultStorageAccountParameters(sku: new StorageSku(StorageSkuName.StandardLRS), identity: identity);
StorageAccountResource account1 = (await storageAccountCollection.CreateOrUpdateAsync(WaitUntil.Completed, accountName, param)).Value;
Assert.AreEqual(accountName, account1.Id.Name);
VerifyAccountProperties(account1, false);
Assert.AreEqual(ManagedServiceIdentityType.SystemAssignedUserAssigned, account1.Data.Identity.ManagedServiceIdentityType);
Assert.AreEqual(account1.Data.Identity.UserAssignedIdentities.Count, 1);
Assert.NotNull(account1.Data.Identity.PrincipalId);
Assert.NotNull(account1.Data.Identity.UserAssignedIdentities[userAssignedIdentity.Id].PrincipalId);
}
public async Task createNamespace()
{
#region Snippet:Managing_ServiceBusQueues_DefaultSubscription
ArmClient armClient = new ArmClient(new DefaultAzureCredential());
SubscriptionResource subscription = await armClient.GetDefaultSubscriptionAsync();
#endregion
#region Snippet:Managing_ServiceBusQueues_CreateResourceGroup
string rgName = "myRgName";
AzureLocation location = AzureLocation.WestUS2;
ArmOperation <ResourceGroupResource> operation = await subscription.GetResourceGroups().CreateOrUpdateAsync(WaitUntil.Completed, rgName, new ResourceGroupData(location));
ResourceGroupResource resourceGroup = operation.Value;
#endregion
#region Snippet:Managing_ServiceBusQueues_CreateNamespace
string namespaceName = "myNamespace";
ServiceBusNamespaceCollection namespaceCollection = resourceGroup.GetServiceBusNamespaces();
ServiceBusNamespaceResource serviceBusNamespace = (await namespaceCollection.CreateOrUpdateAsync(WaitUntil.Completed, namespaceName, new ServiceBusNamespaceData(location))).Value;
ServiceBusQueueCollection serviceBusQueueCollection = serviceBusNamespace.GetServiceBusQueues();
#endregion
this.serviceBusQueueCollection = serviceBusQueueCollection;
}
public async Task Get()
{
SubscriptionResource subscription = await Client.GetDefaultSubscriptionAsync().ConfigureAwait(false);
var rg1Op = await subscription.GetResourceGroups().CreateOrUpdateAsync(WaitUntil.Completed, Recording.GenerateAssetName("testrg"), new ResourceGroupData(AzureLocation.WestUS2));
ResourceGroupResource rg1 = rg1Op.Value;
ResourceGroupResource rg2 = await rg1.GetAsync();
Assert.AreEqual(rg1.Data.Name, rg2.Data.Name);
Assert.AreEqual(rg1.Data.Id, rg2.Data.Id);
Assert.AreEqual(rg1.Data.ResourceType, rg2.Data.ResourceType);
Assert.AreEqual(rg1.Data.Properties.ProvisioningState, rg2.Data.Properties.ProvisioningState);
Assert.AreEqual(rg1.Data.Location, rg2.Data.Location);
Assert.AreEqual(rg1.Data.ManagedBy, rg2.Data.ManagedBy);
Assert.AreEqual(rg1.Data.Tags, rg2.Data.Tags);
ResourceIdentifier fakeId = new ResourceIdentifier(rg1.Data.Id.ToString() + "x");
var ex = Assert.ThrowsAsync <RequestFailedException>(async() => await Client.GetResourceGroupResource(new ResourceIdentifier(fakeId)).GetAsync());
Assert.AreEqual(404, ex.Status);
}
public async Task CreateOrUpdate()
{
TenantResource tenant = await Client.GetTenants().GetAllAsync().FirstOrDefaultAsync(_ => true);
SubscriptionResource subscription = await tenant.GetSubscriptions().GetAllAsync().FirstOrDefaultAsync(_ => true);
string rgName = Recording.GenerateAssetName("testRg-");
ResourceGroupResource rg = await CreateResourceGroup(subscription, rgName);
string vnName1 = Recording.GenerateAssetName("testVn-");
string vnName2 = Recording.GenerateAssetName("testVn-");
GenericResource vn1 = await CreateGenericVirtualNetwork(subscription, rg, vnName1);
GenericResource vn2 = await CreateGenericVirtualNetwork(subscription, rg, vnName2);
string resourceLinkName = Recording.GenerateAssetName("link-");
ResourceLinkResource resourceLink = await CreateResourceLink(tenant, vn1, vn2, resourceLinkName);
Assert.AreEqual(resourceLinkName, resourceLink.Data.Name);
Assert.ThrowsAsync <ArgumentNullException>(async() => _ = await tenant.GetResourceLinks(null).CreateOrUpdateAsync(WaitUntil.Completed, null));
Assert.ThrowsAsync <ArgumentNullException>(async() => _ = await tenant.GetResourceLinks(rg.Id).CreateOrUpdateAsync(WaitUntil.Completed, null));
}
public async Task Delete()
{
//In this test, the CName mapping from custom domain "customdomaintest4.azuretest.net" to endpoint "testEndpoint4dotnetsdk.azureedge.net" is created in advance.
//The CName mapping needs to be deleted before deleting the custom domain.
SubscriptionResource subscription = await Client.GetDefaultSubscriptionAsync();
ResourceGroupResource rg = await subscription.GetResourceGroups().GetAsync("CdnTest");
ProfileResource cdnProfile = await rg.GetProfiles().GetAsync("testProfile");
CdnEndpointResource cdnEndpoint = await cdnProfile.GetCdnEndpoints().GetAsync("testEndpoint4dotnetsdk");
string cdnCustomDomainName = "customdomaintest4-azuretest-net";
var lro = await cdnEndpoint.GetCdnCustomDomains().GetAsync(cdnCustomDomainName);
CdnCustomDomainResource cdnCustomDomain = lro.Value;
await cdnCustomDomain.DeleteAsync(WaitUntil.Completed);
var ex = Assert.ThrowsAsync <RequestFailedException>(async() => await cdnCustomDomain.GetAsync());
Assert.AreEqual(404, ex.Status);
}