public async Task TestSetUp()
{
var client = GetArmClient();
_resourceGroup = await client.GetResourceGroupResource(_resourceGroupIdentifier).GetAsync();
_network = await _resourceGroup.GetVirtualNetworks().GetAsync(_networkIdentifier.Name);
_publicIPAddress = await _resourceGroup.GetPublicIPAddresses().GetAsync(_publicIPAddressIdentifier.Name);
}
public async Task VmssNetworkInterfaceApiTest()
{
string resourceGroupName = Recording.GenerateAssetName("azsmnet");
string location = TestEnvironment.Location;
string deploymentName = Recording.GenerateAssetName("vmss");
var resourceGroup = CreateResourceGroup(resourceGroupName, location);
await CreateVmss(ResourceManagementClient, resourceGroupName, deploymentName);
string virtualMachineScaleSetName = "vmssip";
AsyncPageable <PublicIPAddressResource> vmssListAllPageResultAP = NetworkManagementClient.PublicIPAddresses.GetVirtualMachineScaleSetPublicIPAddressesAsync(resourceGroupName, virtualMachineScaleSetName);
List <PublicIPAddressResource> vmssListAllPageResult = await vmssListAllPageResultAP.ToEnumerableAsync();
List <PublicIPAddressResource> vmssListAllResult = vmssListAllPageResult.ToList();
PublicIPAddressResource firstResult = vmssListAllResult.First();
Assert.NotNull(vmssListAllResult);
Assert.AreEqual("Succeeded", firstResult.ProvisioningState.ToString());
Assert.NotNull(firstResult.ResourceGuid);
string idItem = firstResult.Id;
string vmIndex = GetNameById(idItem, "virtualMachines");
string nicName = GetNameById(idItem, "networkInterfaces");
// Verify that NICs contain refernce to publicip, nsg and dns settings
AsyncPageable <NetworkInterfaceResource> listNicPerVmssAP = NetworkManagementClient.NetworkInterfaces.GetVirtualMachineScaleSetNetworkInterfacesAsync(resourceGroupName, virtualMachineScaleSetName);
List <NetworkInterfaceResource> listNicPerVmss = await listNicPerVmssAP.ToEnumerableAsync();
Assert.NotNull(listNicPerVmss);
foreach (NetworkInterfaceResource nic in listNicPerVmss)
{
VerifyVmssNicProperties(nic);
}
// Verify nics on a vm level
AsyncPageable <NetworkInterfaceResource> listNicPerVmAP = NetworkManagementClient.NetworkInterfaces.GetVirtualMachineScaleSetVMNetworkInterfacesAsync(resourceGroupName, virtualMachineScaleSetName, vmIndex);
List <NetworkInterfaceResource> listNicPerVm = await listNicPerVmAP.ToEnumerableAsync();
Assert.NotNull(listNicPerVm);
Has.One.EqualTo(listNicPerVm);
foreach (NetworkInterfaceResource nic in listNicPerVm)
{
VerifyVmssNicProperties(nic);
}
// Verify getting individual nic
Response <NetworkInterfaceResource> getNic = await NetworkManagementClient.NetworkInterfaces.GetVirtualMachineScaleSetNetworkInterfaceAsync(resourceGroupName, virtualMachineScaleSetName, vmIndex, nicName);
Assert.NotNull(getNic);
VerifyVmssNicProperties(getNic);
}
public async Task TestSetUp()
{
var client = GetArmClient();
var _ = await client.GetDefaultSubscriptionAsync(); // TODO: hack to avoid mismatch of recordings so we don't need to re-record for the change. Remove when you need to run live tests next time.
_resourceGroup = await client.GetResourceGroupResource(_resourceGroupIdentifier).GetAsync();
VirtualNetworkResource vnet = await _resourceGroup.GetVirtualNetworks().GetAsync(_subnetIdentifier.Parent.Name);
_subnet = await vnet.GetSubnets().GetAsync(_subnetIdentifier.Name);
_publicIPAddress = await _resourceGroup.GetPublicIPAddresses().GetAsync(_publicIPAddressIdentifier.Name);
}
public async Task GlobalSetUp()
{
SubscriptionResource subscription = await GlobalClient.GetDefaultSubscriptionAsync();
var rgLro = await subscription.GetResourceGroups().CreateOrUpdateAsync(WaitUntil.Completed, SessionRecording.GenerateAssetName("FirewallRG-"), new ResourceGroupData(AzureLocation.WestUS2));
ResourceGroupResource rg = rgLro.Value;
_resourceGroupIdentifier = rg.Id;
VirtualNetworkData vnetData = new VirtualNetworkData()
{
Location = AzureLocation.WestUS2,
AddressSpace = new AddressSpace()
{
AddressPrefixes = { "10.20.0.0/16", }
},
Subnets =
{
new SubnetData()
{
Name = "Default", AddressPrefix = "10.20.1.0/26",
},
new SubnetData()
{
Name = "AzureFirewallSubnet", AddressPrefix = "10.20.2.0/26",
},
},
};
var vnetLro = await rg.GetVirtualNetworks().CreateOrUpdateAsync(WaitUntil.Completed, SessionRecording.GenerateAssetName("vnet-"), vnetData);
_network = vnetLro.Value;
_networkIdentifier = _network.Id;
PublicIPAddressData ipData = new PublicIPAddressData()
{
Location = AzureLocation.WestUS2,
PublicIPAllocationMethod = IPAllocationMethod.Static,
Sku = new PublicIPAddressSku()
{
Name = PublicIPAddressSkuName.Standard
},
};
var ipLro = await rg.GetPublicIPAddresses().CreateOrUpdateAsync(WaitUntil.Completed, SessionRecording.GenerateAssetName("publicIp-"), ipData);
_publicIPAddress = ipLro.Value;
_publicIPAddressIdentifier = _publicIPAddress.Id;
_firewallName = SessionRecording.GenerateAssetName("firewall-");
await StopSessionRecordingAsync();
}
public async Task VmssPublicIpAddressApiTest()
{
string resourceGroupName = Recording.GenerateAssetName("azsmnet");
string location = TestEnvironment.Location;
string deploymentName = Recording.GenerateAssetName("vmss");
var resourceGroup = CreateResourceGroup(resourceGroupName, location);
await CreateVmss(ResourceManagementClient, resourceGroupName, deploymentName);
string virtualMachineScaleSetName = "vmssip";
AsyncPageable <PublicIPAddressResource> vmssListAllPageResultAP = NetworkManagementClient.PublicIPAddresses.GetVirtualMachineScaleSetPublicIPAddressesAsync(resourceGroupName, virtualMachineScaleSetName);
List <PublicIPAddressResource> vmssListAllPageResult = await vmssListAllPageResultAP.ToEnumerableAsync();
List <PublicIPAddressResource> vmssListAllResult = vmssListAllPageResult.ToList();
PublicIPAddressResource firstResult = vmssListAllResult.First();
Assert.NotNull(vmssListAllResult);
Assert.AreEqual("Succeeded", firstResult.ProvisioningState.ToString());
Assert.NotNull(firstResult.ResourceGuid);
string idItem = firstResult.Id;
string vmIndex = GetNameById(idItem, "virtualMachines");
string nicName = GetNameById(idItem, "networkInterfaces");
string ipConfigName = GetNameById(idItem, "ipConfigurations");
string ipName = GetNameById(idItem, "publicIPAddresses");
AsyncPageable <PublicIPAddressResource> vmssListPageResultAP = NetworkManagementClient.PublicIPAddresses.GetVirtualMachineScaleSetVMPublicIPAddressesAsync(
resourceGroupName, virtualMachineScaleSetName, vmIndex, nicName, ipConfigName);
List <PublicIPAddressResource> vmssListPageResult = await vmssListPageResultAP.ToEnumerableAsync();
List <PublicIPAddressResource> vmssListResult = vmssListPageResult.ToList();
Has.One.EqualTo(vmssListResult);
Response <PublicIPAddressResource> vmssGetResult = await NetworkManagementClient.PublicIPAddresses.GetVirtualMachineScaleSetPublicIPAddressAsync(
resourceGroupName, virtualMachineScaleSetName, vmIndex, nicName, ipConfigName, ipName);
Assert.NotNull(vmssGetResult);
Assert.AreEqual("Succeeded", vmssGetResult.Value.ProvisioningState.ToString());
Assert.NotNull(vmssGetResult.Value.ResourceGuid);
}
public async Task TroubleshootApiTest()
{
string resourceGroupName = Recording.GenerateAssetName("azsmnet");
string location = "westus2";
var resourceGroup = CreateResourceGroup(resourceGroupName, location);
// CreateVirtualNetworkGateway API
// Prerequisite:- Create PublicIPAddress(Gateway Ip) using Put PublicIPAddressResource API
string publicIpName = Recording.GenerateAssetName("azsmnet");
string domainNameLabel = Recording.GenerateAssetName("azsmnet");
PublicIPAddressResource nic1publicIp = await CreateDefaultPublicIpAddress(publicIpName, resourceGroupName, domainNameLabel, location);
//Prerequisite:-Create Virtual Network using Put VirtualNetworkResource API
string vnetName = Recording.GenerateAssetName("azsmnet");
string subnetName = "GatewaySubnet";
await CreateVirtualNetwork(vnetName, subnetName, resourceGroupName, location);
Response <SubnetResource> getSubnetResponse = await GetVirtualNetworkCollection(resourceGroupName).Get(vnetName).Value.GetSubnets().GetAsync(subnetName);
// CreateVirtualNetworkGateway API
string virtualNetworkGatewayName = Recording.GenerateAssetName("azsmnet");
string ipConfigName = Recording.GenerateAssetName("azsmnet");
var virtualNetworkGateway = new VirtualNetworkGatewayData()
{
Location = location,
Tags = { { "key", "value" } },
EnableBgp = false,
GatewayDefaultSite = null,
GatewayType = VirtualNetworkGatewayType.Vpn,
VpnType = VpnType.RouteBased,
IpConfigurations =
{
new VirtualNetworkGatewayIPConfiguration()
{
Name = ipConfigName,
PrivateIPAllocationMethod = IPAllocationMethod.Dynamic,
PublicIPAddress = new SubResource()
{
Id = nic1publicIp.Id
}, Subnet = new SubResource()
{
Id = getSubnetResponse.Value.Id
}
}
},
Sku = new VirtualNetworkGatewaySku()
{
Name = VirtualNetworkGatewaySkuName.Basic, Tier = VirtualNetworkGatewaySkuTier.Basic
}
};
var virtualNetworkGatewayCollection = GetVirtualNetworkGatewayCollection(resourceGroupName);
var putVirtualNetworkGatewayResponseOperation =
await virtualNetworkGatewayCollection.CreateOrUpdateAsync(true, virtualNetworkGatewayName, virtualNetworkGateway);
await putVirtualNetworkGatewayResponseOperation.WaitForCompletionAsync();;
// GetVirtualNetworkGateway API
Response <VirtualNetworkGatewayResource> getVirtualNetworkGatewayResponse =
await virtualNetworkGatewayCollection.GetAsync(virtualNetworkGatewayName);
//TODO:There is no need to perform a separate create NetworkWatchers operation
//Create network Watcher
//string networkWatcherName = Recording.GenerateAssetName("azsmnet");
//NetworkWatcherResource properties = new NetworkWatcherResource { Location = location };
//await networkWatcherCollection.CreateOrUpdateAsync(true, resourceGroupName, networkWatcherName, properties);
//Create storage
//string storageName = Recording.GenerateAssetName("azsmnet");
//var storageParameters = new StorageAccountCreateParameters(new Sku(SkuName.StandardLRS), Kind.Storage, location);
//Operation<StorageAccountResource> accountOperation = await StorageManagementClient.StorageAccounts.CreateAsync(resourceGroupName, storageName, storageParameters);
//Response<StorageAccountResource> account = await accountOperation.WaitForCompletionAsync();;
//TroubleshootingParameters parameters = new TroubleshootingParameters(getVirtualNetworkGatewayResponse.Value.Id, account.Value.Id, "https://nwtestdbdzq4xsvskrei6.blob.core.windows.net/vhds");
////Get troubleshooting
//var networkWatcherCollection = GetNetworkWatcherCollection("NetworkWatcherRG");
//var troubleshootOperation = await networkWatcherCollection.Get("NetworkWatcher_westus2").Value.GetTroubleshootingAsync(parameters);
//await troubleshootOperation.WaitForCompletionAsync();;
////Query last troubleshoot
//var queryTroubleshootOperation = await networkWatcherCollection.Get("NetworkWatcher_westus2").Value.GetTroubleshootingResultAsync(new QueryTroubleshootingParameters(getVirtualNetworkGatewayResponse.Value.Id));
//await queryTroubleshootOperation.WaitForCompletionAsync();;
//TODO: make verification once fixed for troubleshoot API deployed
}
public async Task CreateOrUpdate()
{
VirtualNetworkCollection virtualNetworkCollection = resourceGroup.GetVirtualNetworks();
string vnetName = "myVnet";
// Use the same location as the resource group
VirtualNetworkData vnetInput = new VirtualNetworkData()
{
Location = resourceGroup.Data.Location,
AddressSpace = new AddressSpace()
{
AddressPrefixes = { "10.0.0.0/16", }
},
DhcpOptions = new DhcpOptions()
{
DnsServers = { "10.1.1.1", "10.1.2.4" }
},
Subnets = { new SubnetData()
{
Name = "mySubnet", AddressPrefix = "10.0.1.0/24"
} }
};
VirtualNetworkResource virtualNetwork = await virtualNetworkCollection.CreateOrUpdate(WaitUntil.Completed, vnetName, vnetInput).WaitForCompletionAsync();
#region Snippet:Managing_Networks_CreateANetworkInterface
PublicIPAddressCollection publicIPAddressCollection = resourceGroup.GetPublicIPAddresses();
string publicIPAddressName = "myIPAddress";
PublicIPAddressData publicIPInput = new PublicIPAddressData()
{
Location = resourceGroup.Data.Location,
PublicIPAllocationMethod = IPAllocationMethod.Dynamic,
DnsSettings = new PublicIPAddressDnsSettings()
{
DomainNameLabel = "myDomain"
}
};
PublicIPAddressResource publicIPAddress = await publicIPAddressCollection.CreateOrUpdate(WaitUntil.Completed, publicIPAddressName, publicIPInput).WaitForCompletionAsync();
NetworkInterfaceCollection networkInterfaceCollection = resourceGroup.GetNetworkInterfaces();
string networkInterfaceName = "myNetworkInterface";
NetworkInterfaceData networkInterfaceInput = new NetworkInterfaceData()
{
Location = resourceGroup.Data.Location,
IPConfigurations =
{
new NetworkInterfaceIPConfigurationData()
{
Name = "ipConfig",
PrivateIPAllocationMethod = IPAllocationMethod.Dynamic,
PublicIPAddress = new PublicIPAddressData()
{
Id = publicIPAddress.Id
},
Subnet = new SubnetData()
{
// use the virtual network just created
Id = virtualNetwork.Data.Subnets[0].Id
}
}
}
};
NetworkInterfaceResource networkInterface = await networkInterfaceCollection.CreateOrUpdate(WaitUntil.Completed, networkInterfaceName, networkInterfaceInput).WaitForCompletionAsync();
#endregion
}
public async Task ExpandResourceTest()
{
string resourceGroupName = Recording.GenerateAssetName("csmrg");
string location = TestEnvironment.Location;
var resourceGroup = await CreateResourceGroup(resourceGroupName);
// Create lbPublicIP
string lbPublicIpName = Recording.GenerateAssetName("azsmnet");
string lbDomaingNameLabel = Recording.GenerateAssetName("azsmnet");
PublicIPAddressResource lbPublicIp = await CreateDefaultPublicIpAddress(
lbPublicIpName,
lbDomaingNameLabel,
location,
resourceGroup.GetPublicIPAddresses());
// Create Vnet
string vnetName = Recording.GenerateAssetName("azsmnet");
string subnetName = Recording.GenerateAssetName("azsmnet");
VirtualNetworkResource vnet = await CreateVirtualNetwork(vnetName, subnetName, location, resourceGroup.GetVirtualNetworks());
// Create Nics
string nic1name = Recording.GenerateAssetName("azsmnet");
string nic2name = Recording.GenerateAssetName("azsmnet");
string nic3name = Recording.GenerateAssetName("azsmnet");
NetworkInterfaceResource nic1 = await CreateNetworkInterface(
nic1name,
null,
vnet.Data.Subnets[0].Id,
location,
"ipconfig",
resourceGroup.GetNetworkInterfaces());
NetworkInterfaceResource nic2 = await CreateNetworkInterface(
nic2name,
null,
vnet.Data.Subnets[0].Id,
location,
"ipconfig",
resourceGroup.GetNetworkInterfaces());
NetworkInterfaceResource nic3 = await CreateNetworkInterface(
nic3name,
null,
vnet.Data.Subnets[0].Id,
location,
"ipconfig",
resourceGroup.GetNetworkInterfaces());
// Create the LoadBalancer
var lbName = Recording.GenerateAssetName("azsmnet");
var frontendIpConfigName = Recording.GenerateAssetName("azsmnet");
var backEndAddressPoolName = Recording.GenerateAssetName("azsmnet");
var loadBalancingRuleName = Recording.GenerateAssetName("azsmnet");
var probeName = Recording.GenerateAssetName("azsmnet");
var inboundNatRule1Name = Recording.GenerateAssetName("azsmnet");
var inboundNatRule2Name = Recording.GenerateAssetName("azsmnet");
// Populate the loadBalancerCreateOrUpdateParameter
var loadBalancerData = new LoadBalancerData()
{
Location = location,
FrontendIPConfigurations =
{
new FrontendIPConfigurationData()
{
Name = frontendIpConfigName,
PublicIPAddress = new PublicIPAddressData()
{
Id = lbPublicIp.Id
}
}
},
BackendAddressPools =
{
new BackendAddressPoolData()
{
Name = backEndAddressPoolName,
}
},
LoadBalancingRules =
{
new LoadBalancingRuleData()
{
Name = loadBalancingRuleName,
FrontendIPConfiguration = new WritableSubResource()
{
Id = GetChildLbResourceId(TestEnvironment.SubscriptionId,
resourceGroupName, lbName, "FrontendIPConfigurations", frontendIpConfigName)
},
Protocol = TransportProtocol.Tcp,
FrontendPort = 80,
BackendPort = 80,
EnableFloatingIP = false,
IdleTimeoutInMinutes = 15,
BackendAddressPool = new WritableSubResource()
{
Id = GetChildLbResourceId(TestEnvironment.SubscriptionId,
resourceGroupName, lbName, "backendAddressPools", backEndAddressPoolName)
},
Probe = new WritableSubResource()
{
Id = GetChildLbResourceId(TestEnvironment.SubscriptionId,
resourceGroupName, lbName, "probes", probeName)
}
}
},
Probes =
{
new ProbeData()
{
Name = probeName,
Protocol = ProbeProtocol.Http,
Port = 80,
RequestPath = "healthcheck.aspx",
IntervalInSeconds = 10,
NumberOfProbes = 2
}
},
InboundNatRules =
{
new InboundNatRuleData()
{
Name = inboundNatRule1Name,
FrontendIPConfiguration = new WritableSubResource()
{
Id = GetChildLbResourceId(TestEnvironment.SubscriptionId,
resourceGroupName, lbName, "FrontendIPConfigurations", frontendIpConfigName)
},
Protocol = TransportProtocol.Tcp,
FrontendPort = 3389,
BackendPort = 3389,
IdleTimeoutInMinutes = 15,
EnableFloatingIP = false
},
new InboundNatRuleData()
{
Name = inboundNatRule2Name,
FrontendIPConfiguration = new WritableSubResource()
{
Id = GetChildLbResourceId(TestEnvironment.SubscriptionId,
resourceGroupName, lbName, "FrontendIPConfigurations", frontendIpConfigName)
},
Protocol = TransportProtocol.Tcp,
FrontendPort = 3390,
BackendPort = 3389,
IdleTimeoutInMinutes = 15,
EnableFloatingIP = false,
}
}
};
// Create the loadBalancer
var loadBalancerCollection = resourceGroup.GetLoadBalancers();
LoadBalancerResource loadBalancer = (await loadBalancerCollection.CreateOrUpdateAsync(WaitUntil.Completed, lbName, loadBalancerData)).Value;
// Associate the nic with LB
//nic1.GetNetworkInterfaceIPConfigurations().List().First().`
// TODO: where do we have the following?
//nic1.IpConfigurations.First().LoadBalancerBackendAddressPools.Add(getLoadBalancer.Value.BackendAddressPools.First());
//nic1.IpConfigurations.First().LoadBalancerInboundNatRules.Add(getLoadBalancer.Value.InboundNatRules.First());
//nic2.IpConfigurations.First().LoadBalancerBackendAddressPools.Add(getLoadBalancer.Value.BackendAddressPools.First());
//nic3.IpConfigurations.First().LoadBalancerInboundNatRules.Add(getLoadBalancer.Value.InboundNatRules[1]);
nic1.Data.IPConfigurations.First().LoadBalancerBackendAddressPools.Add(loadBalancer.Data.BackendAddressPools.First());
nic1.Data.IPConfigurations.First().LoadBalancerInboundNatRules.Add(loadBalancer.Data.InboundNatRules[0]);
nic2.Data.IPConfigurations.First().LoadBalancerBackendAddressPools.Add(loadBalancer.Data.BackendAddressPools.First());
nic2.Data.IPConfigurations.First().LoadBalancerInboundNatRules.Add(loadBalancer.Data.InboundNatRules[1]);
nic3.Data.IPConfigurations.First().LoadBalancerBackendAddressPools.Add(loadBalancer.Data.BackendAddressPools.First());
// Put Nics
var networkInterfaceCollection = resourceGroup.GetNetworkInterfaces();
var createOrUpdateOperation1 = await networkInterfaceCollection.CreateOrUpdateAsync(WaitUntil.Completed, nic1name, nic1.Data);
await createOrUpdateOperation1.WaitForCompletionAsync();
var createOrUpdateOperation2 = await networkInterfaceCollection.CreateOrUpdateAsync(WaitUntil.Completed, nic2name, nic2.Data);
await createOrUpdateOperation2.WaitForCompletionAsync();
var createOrUpdateOperation3 = await networkInterfaceCollection.CreateOrUpdateAsync(WaitUntil.Completed, nic3name, nic3.Data);
await createOrUpdateOperation3.WaitForCompletionAsync();
// Get Nics
await networkInterfaceCollection.GetAsync(nic1name);
await networkInterfaceCollection.GetAsync(nic2name);
await networkInterfaceCollection.GetAsync(nic3name);
// Get lb with expanded nics from nat rules
loadBalancer = await loadBalancerCollection.GetAsync(lbName, "InboundNatRules/backendIPConfiguration");
await foreach (var natRule in loadBalancer.GetInboundNatRules())
{
Assert.NotNull(natRule.Data.BackendIPConfiguration);
Assert.NotNull(natRule.Data.BackendIPConfiguration.Id);
//Assert.NotNull(natRule.Data.BackendIPConfiguration.Name);
//Assert.NotNull(natRule.Data.BackendIPConfiguration.Etag);
//Assert.AreEqual(natRule.Id, natRule.Data.BackendIPConfiguration.LoadBalancerInboundNatRules[0].Id);
}
// Get lb with expanded nics from pools
loadBalancer = await loadBalancerCollection.GetAsync(lbName, "BackendAddressPools/backendIPConfigurations");
await foreach (var pool in loadBalancer.GetBackendAddressPools())
{
BackendAddressPoolResource firstPool = await GetFirstPoolAsync(loadBalancer);
foreach (var ipconfig in firstPool.Data.BackendIPConfigurations)
{
Assert.NotNull(ipconfig.Id);
//Assert.NotNull(ipconfig.Name);
//Assert.NotNull(ipconfig.Etag);
//Assert.AreEqual(pool.Id, ipconfig.LoadBalancerBackendAddressPools[0].Id);
}
}
// Get lb with expanded publicip
loadBalancer = await loadBalancerCollection.GetAsync(lbName, "FrontendIPConfigurations/PublicIPAddress");
foreach (var ipconfig in loadBalancer.Data.FrontendIPConfigurations)
{
Assert.NotNull(ipconfig.PublicIPAddress);
Assert.NotNull(ipconfig.PublicIPAddress.Id);
Assert.NotNull(ipconfig.PublicIPAddress.Name);
Assert.NotNull(ipconfig.PublicIPAddress.Etag);
Assert.AreEqual(ipconfig.Id, ipconfig.PublicIPAddress.IPConfiguration.Id);
}
// Get NIC with expanded subnet
nic1 = await networkInterfaceCollection.GetAsync(nic1name, "IPConfigurations/Subnet");
await foreach (NetworkInterfaceIPConfigurationResource ipconfig in nic1.GetNetworkInterfaceIPConfigurations())
{
Assert.NotNull(ipconfig.Data.Subnet);
Assert.NotNull(ipconfig.Data.Subnet.Id);
//Assert.NotNull(ipconfig.Subnet.Name);
//Assert.NotNull(ipconfig.Subnet.Etag);
//Assert.IsNotEmpty(ipconfig.Subnet.IpConfigurations);
}
// Get subnet with expanded ipconfigurations
Response <SubnetResource> subnet = await(await resourceGroup.GetVirtualNetworks().GetAsync(vnetName)).Value.GetSubnets().GetAsync(
subnetName,
"IPConfigurations");
foreach (IPConfiguration ipconfig in subnet.Value.Data.IPConfigurations)
{
Assert.NotNull(ipconfig.Id);
//Assert.NotNull(ipconfig.Name);
//Assert.NotNull(ipconfig.Etag);
Assert.NotNull(ipconfig.PrivateIPAddress);
}
// Get publicIPAddress with expanded ipconfigurations
Response <PublicIPAddressResource> publicip = await resourceGroup.GetPublicIPAddresses().GetAsync(
lbPublicIpName,
"IPConfiguration");
Assert.NotNull(publicip.Value.Data.IPConfiguration);
Assert.NotNull(publicip.Value.Data.IPConfiguration.Id);
//Assert.NotNull(publicip.Value.Data.IpConfiguration.Name);
//Assert.NotNull(publicip.Value.Data.IpConfiguration.Etag);
// Delete LoadBalancer
Operation deleteOperation = await(await loadBalancerCollection.GetAsync(lbName)).Value.DeleteAsync(WaitUntil.Completed);
await deleteOperation.WaitForCompletionResponseAsync();
// Verify Delete
AsyncPageable <LoadBalancerResource> listLoadBalancerAP = loadBalancerCollection.GetAllAsync();
List <LoadBalancerResource> listLoadBalancer = await listLoadBalancerAP.ToEnumerableAsync();
Assert.IsEmpty(listLoadBalancer);
// Delete all NetworkInterfaces
await(await networkInterfaceCollection.GetAsync(nic1name)).Value.DeleteAsync(WaitUntil.Completed);
await(await networkInterfaceCollection.GetAsync(nic2name)).Value.DeleteAsync(WaitUntil.Completed);
await(await networkInterfaceCollection.GetAsync(nic3name)).Value.DeleteAsync(WaitUntil.Completed);
// Delete all PublicIPAddresses
await(await resourceGroup.GetPublicIPAddresses().GetAsync(lbPublicIpName)).Value.DeleteAsync(WaitUntil.Completed);
}
public async Task GlobalSetUp()
{
SubscriptionResource subscription = await GlobalClient.GetDefaultSubscriptionAsync();
var rgLro = await subscription.GetResourceGroups().CreateOrUpdateAsync(WaitUntil.Completed, SessionRecording.GenerateAssetName("FirewallPolicyRG-"), new ResourceGroupData(AzureLocation.WestUS2));
ResourceGroupResource rg = rgLro.Value;
_resourceGroupIdentifier = rg.Id;
VirtualNetworkData vnetData = new VirtualNetworkData()
{
Location = AzureLocation.WestUS2,
AddressSpace = new AddressSpace()
{
AddressPrefixes = { "10.26.0.0/16", }
},
Subnets =
{
new SubnetData()
{
Name = "Default", AddressPrefix = "10.26.1.0/26",
},
new SubnetData()
{
Name = "AzureFirewallSubnet", AddressPrefix = "10.26.2.0/26",
},
},
};
var vnetLro = await rg.GetVirtualNetworks().CreateOrUpdateAsync(WaitUntil.Completed, SessionRecording.GenerateAssetName("vnet-"), vnetData);
_network = vnetLro.Value;
_networkIdentifier = _network.Id;
PublicIPAddressData ipData = new PublicIPAddressData()
{
Location = AzureLocation.WestUS2,
PublicIPAllocationMethod = IPAllocationMethod.Static,
Sku = new PublicIPAddressSku()
{
Name = PublicIPAddressSkuName.Standard
},
};
var ipLro = await rg.GetPublicIPAddresses().CreateOrUpdateAsync(WaitUntil.Completed, SessionRecording.GenerateAssetName("publicIp-"), ipData);
_publicIPAddress = ipLro.Value;
_publicIPAddressIdentifier = _publicIPAddress.Id;
AzureFirewallData firewallData = new AzureFirewallData();
firewallData.Location = AzureLocation.WestUS2;
firewallData.IPConfigurations.Add(new AzureFirewallIPConfiguration()
{
Name = "fwpip",
PublicIPAddress = new WritableSubResource()
{
Id = _publicIPAddressIdentifier
},
Subnet = new WritableSubResource()
{
Id = _networkIdentifier.AppendChildResource("subnets", "AzureFirewallSubnet")
},
});
var firewallLro = await rg.GetAzureFirewalls().CreateOrUpdateAsync(WaitUntil.Completed, SessionRecording.GenerateAssetName("firewall-"), firewallData);
_firewall = firewallLro.Value;
_firewallIdentifier = _firewall.Id;
await StopSessionRecordingAsync();
}
