public async Task VirtualNetworkPeeringApiTest()
{
string resourceGroupName = Recording.GenerateAssetName("csmrg");
var location = "westus";
await ResourceGroupsOperations.CreateOrUpdateAsync(resourceGroupName, new ResourceGroup(location));
string vnetName = Recording.GenerateAssetName("azsmnet");
string remoteVirtualNetworkName = Recording.GenerateAssetName("azsmnet");
string vnetPeeringName = Recording.GenerateAssetName("azsmnet");
string subnet1Name = Recording.GenerateAssetName("azsmnet");
string subnet2Name = Recording.GenerateAssetName("azsmnet");
VirtualNetwork vnet = new VirtualNetwork()
{
Location = location,
AddressSpace = new AddressSpace()
{
AddressPrefixes = new List <string>()
{
"10.0.0.0/16",
}
},
DhcpOptions = new DhcpOptions()
{
DnsServers = new List <string>()
{
"10.1.1.1", "10.1.2.4"
}
},
Subnets = new List <Subnet>()
{
new Subnet()
{
Name = subnet1Name, AddressPrefix = "10.0.1.0/24",
}, new Subnet()
{
Name = subnet2Name, AddressPrefix = "10.0.2.0/24",
}
}
};
// Put Vnet
VirtualNetworksCreateOrUpdateOperation putVnetResponseOperation = await NetworkManagementClient.VirtualNetworks.StartCreateOrUpdateAsync(resourceGroupName, vnetName, vnet);
Response <VirtualNetwork> putVnetResponse = await WaitForCompletionAsync(putVnetResponseOperation);
Assert.AreEqual("Succeeded", putVnetResponse.Value.ProvisioningState.ToString());
// Get Vnet
Response <VirtualNetwork> getVnetResponse = await NetworkManagementClient.VirtualNetworks.GetAsync(resourceGroupName, vnetName);
Assert.AreEqual(vnetName, getVnetResponse.Value.Name);
Assert.NotNull(getVnetResponse.Value.ResourceGuid);
Assert.AreEqual("Succeeded", getVnetResponse.Value.ProvisioningState.ToString());
// Get all Vnets
AsyncPageable <VirtualNetwork> getAllVnetsAP = NetworkManagementClient.VirtualNetworks.ListAsync(resourceGroupName);
await getAllVnetsAP.ToEnumerableAsync();
vnet.AddressSpace.AddressPrefixes[0] = "10.1.0.0/16";
vnet.Subnets[0].AddressPrefix = "10.1.1.0/24";
vnet.Subnets[1].AddressPrefix = "10.1.2.0/24";
VirtualNetworksCreateOrUpdateOperation remoteVirtualNetworkOperation = await NetworkManagementClient.VirtualNetworks.StartCreateOrUpdateAsync(resourceGroupName, remoteVirtualNetworkName, vnet);
Response <VirtualNetwork> remoteVirtualNetwork = await WaitForCompletionAsync(remoteVirtualNetworkOperation);
// Get Peerings in the vnet
AsyncPageable <VirtualNetworkPeering> listPeeringAP = NetworkManagementClient.VirtualNetworkPeerings.ListAsync(resourceGroupName, vnetName);
List <VirtualNetworkPeering> listPeering = await listPeeringAP.ToEnumerableAsync();
Assert.IsEmpty(listPeering);
VirtualNetworkPeering peering = new VirtualNetworkPeering
{
Name = vnetPeeringName,
RemoteVirtualNetwork = new SubResource
{
Id = remoteVirtualNetwork.Value.Id
},
AllowForwardedTraffic = true,
AllowVirtualNetworkAccess = false
};
// Put peering in the vnet
VirtualNetworkPeeringsCreateOrUpdateOperation putPeeringOperation = await NetworkManagementClient.VirtualNetworkPeerings.StartCreateOrUpdateAsync(resourceGroupName, vnetName, vnetPeeringName, peering);
Response <VirtualNetworkPeering> putPeering = await WaitForCompletionAsync(putPeeringOperation);
Assert.NotNull(putPeering.Value.Etag);
Assert.AreEqual(vnetPeeringName, putPeering.Value.Name);
Assert.AreEqual(remoteVirtualNetwork.Value.Id, putPeering.Value.RemoteVirtualNetwork.Id);
Assert.AreEqual(peering.AllowForwardedTraffic, putPeering.Value.AllowForwardedTraffic);
Assert.AreEqual(peering.AllowVirtualNetworkAccess, putPeering.Value.AllowVirtualNetworkAccess);
Assert.False(putPeering.Value.UseRemoteGateways);
Assert.False(putPeering.Value.AllowGatewayTransit);
Assert.AreEqual(VirtualNetworkPeeringState.Initiated, putPeering.Value.PeeringState);
// get peering
Response <VirtualNetworkPeering> getPeering = await NetworkManagementClient.VirtualNetworkPeerings.GetAsync(resourceGroupName, vnetName, vnetPeeringName);
Assert.AreEqual(getPeering.Value.Etag, putPeering.Value.Etag);
Assert.AreEqual(vnetPeeringName, getPeering.Value.Name);
Assert.AreEqual(remoteVirtualNetwork.Value.Id, getPeering.Value.RemoteVirtualNetwork.Id);
Assert.AreEqual(peering.AllowForwardedTraffic, getPeering.Value.AllowForwardedTraffic);
Assert.AreEqual(peering.AllowVirtualNetworkAccess, getPeering.Value.AllowVirtualNetworkAccess);
Assert.False(getPeering.Value.UseRemoteGateways);
Assert.False(getPeering.Value.AllowGatewayTransit);
Assert.AreEqual(VirtualNetworkPeeringState.Initiated, getPeering.Value.PeeringState);
// list peering
listPeeringAP = NetworkManagementClient.VirtualNetworkPeerings.ListAsync(resourceGroupName, vnetName);
listPeering = await listPeeringAP.ToEnumerableAsync();
Has.One.EqualTo(listPeering);
Assert.AreEqual(listPeering.ElementAt(0).Etag, putPeering.Value.Etag);
Assert.AreEqual(vnetPeeringName, listPeering.ElementAt(0).Name);
Assert.AreEqual(remoteVirtualNetwork.Value.Id, listPeering.ElementAt(0).RemoteVirtualNetwork.Id);
Assert.AreEqual(peering.AllowForwardedTraffic, listPeering.ElementAt(0).AllowForwardedTraffic);
Assert.AreEqual(peering.AllowVirtualNetworkAccess, listPeering.ElementAt(0).AllowVirtualNetworkAccess);
Assert.False(listPeering.ElementAt(0).UseRemoteGateways);
Assert.False(listPeering.ElementAt(0).AllowGatewayTransit);
Assert.AreEqual(VirtualNetworkPeeringState.Initiated, listPeering.ElementAt(0).PeeringState);
// delete peering
await NetworkManagementClient.VirtualNetworkPeerings.StartDeleteAsync(resourceGroupName, vnetName, vnetPeeringName);
listPeeringAP = NetworkManagementClient.VirtualNetworkPeerings.ListAsync(resourceGroupName, vnetName);
listPeering = await listPeeringAP.ToEnumerableAsync();
Assert.IsEmpty(listPeering);
// Delete Vnet
await NetworkManagementClient.VirtualNetworks.StartDeleteAsync(resourceGroupName, vnetName);
await NetworkManagementClient.VirtualNetworks.StartDeleteAsync(resourceGroupName, remoteVirtualNetworkName);
// Get all Vnets
getAllVnetsAP = NetworkManagementClient.VirtualNetworks.ListAsync(resourceGroupName);
List <VirtualNetwork> getAllVnets = await getAllVnetsAP.ToEnumerableAsync();
Assert.IsEmpty(getAllVnets);
}
public async Task ApplicationGatewayApiTest()
{
string resourceGroupName = Recording.GenerateAssetName("csmrg");
string location = "West US";
await ResourceGroupsOperations.CreateOrUpdateAsync(resourceGroupName, new ResourceGroup(location));
string vnetName = Recording.GenerateAssetName("azsmnet");
string gwSubnetName = Recording.GenerateAssetName("azsmnet");
string subnet2Name = Recording.GenerateAssetName("azsmnet");
string appGwName = Recording.GenerateAssetName("azsmnet");
VirtualNetwork vnet = new VirtualNetwork()
{
Location = location,
AddressSpace = new AddressSpace()
{
AddressPrefixes = { "10.0.0.0/16", }
},
DhcpOptions = new DhcpOptions()
{
DnsServers = { "10.1.1.1", "10.1.2.4" }
},
Subnets =
{
new Subnet()
{
Name = gwSubnetName, AddressPrefix = "10.0.0.0/24"
},
new Subnet()
{
Name = subnet2Name, AddressPrefix = "10.0.1.0/24"
}
}
};
VirtualNetworksCreateOrUpdateOperation putVnetResponseOperation = await NetworkManagementClient.VirtualNetworks.StartCreateOrUpdateAsync(resourceGroupName, vnetName, vnet);
await WaitForCompletionAsync(putVnetResponseOperation);
Response <VirtualNetwork> getVnetResponse = await NetworkManagementClient.VirtualNetworks.GetAsync(resourceGroupName, vnetName);
Response <Subnet> getSubnetResponse = await NetworkManagementClient.Subnets.GetAsync(resourceGroupName, vnetName, gwSubnetName);
Console.WriteLine("Virtual Network GatewaySubnet Id: {0}", getSubnetResponse.Value.Id);
Response <Subnet> gwSubnet = getSubnetResponse;
ApplicationGateway appGw = CreateApplicationGateway(location, gwSubnet, resourceGroupName, appGwName, TestEnvironment.SubscriptionId);
// Put AppGw
Operation <ApplicationGateway> putAppGw = await NetworkManagementClient.ApplicationGateways.StartCreateOrUpdateAsync(resourceGroupName, appGwName, appGw);
Response <ApplicationGateway> putAppGwResponse = await WaitForCompletionAsync(putAppGw);
Assert.AreEqual("Succeeded", putAppGwResponse.Value.ProvisioningState.ToString());
// Get AppGw
Response <ApplicationGateway> getGateway = await NetworkManagementClient.ApplicationGateways.GetAsync(resourceGroupName, appGwName);
Assert.AreEqual(appGwName, getGateway.Value.Name);
CompareApplicationGateway(appGw, getGateway);
// Get available WAF rule sets (validate first result set/group)
Response <ApplicationGatewayAvailableWafRuleSetsResult> availableWAFRuleSets = await NetworkManagementClient.ApplicationGateways.ListAvailableWafRuleSetsAsync();
Assert.NotNull(availableWAFRuleSets);
Assert.IsNotEmpty(availableWAFRuleSets.Value.Value);
Assert.NotNull(availableWAFRuleSets.Value.Value[0].Name);
Assert.NotNull(availableWAFRuleSets.Value.Value[0].RuleSetType);
Assert.NotNull(availableWAFRuleSets.Value.Value[0].RuleSetVersion);
Assert.IsNotEmpty(availableWAFRuleSets.Value.Value[0].RuleGroups);
Assert.NotNull(availableWAFRuleSets.Value.Value[0].RuleGroups[0].RuleGroupName);
Assert.IsNotEmpty(availableWAFRuleSets.Value.Value[0].RuleGroups[0].Rules);
// Assert.NotNull(availableWAFRuleSets.Value[0].RuleGroups[0].Rules[0].RuleId);
// Get availalbe SSL options
Response <ApplicationGatewayAvailableSslOptions> sslOptions = await NetworkManagementClient.ApplicationGateways.ListAvailableSslOptionsAsync();
Assert.NotNull(sslOptions.Value.DefaultPolicy);
Assert.NotNull(sslOptions.Value.AvailableCipherSuites);
Assert.NotNull(sslOptions.Value.AvailableCipherSuites[20]);
AsyncPageable <ApplicationGatewaySslPredefinedPolicy> policies = NetworkManagementClient.ApplicationGateways.ListAvailableSslPredefinedPoliciesAsync();
IAsyncEnumerator <ApplicationGatewaySslPredefinedPolicy> enumerator = policies.GetAsyncEnumerator();
Assert.True(enumerator.MoveNextAsync().Result);
Assert.NotNull(enumerator.Current.Name);
Task <Response <ApplicationGatewaySslPredefinedPolicy> > policy = NetworkManagementClient.ApplicationGateways.GetSslPredefinedPolicyAsync(ApplicationGatewaySslPolicyName.AppGwSslPolicy20150501.ToString());
Assert.NotNull(policy.Result.Value.MinProtocolVersion);
Assert.NotNull(policy.Result.Value.CipherSuites);
Assert.NotNull(policy.Result.Value.CipherSuites[20]);
// Create Nics
string nic1name = Recording.GenerateAssetName("azsmnet");
string nic2name = Recording.GenerateAssetName("azsmnet");
Task <NetworkInterface> nic1 = CreateNetworkInterface(
nic1name,
resourceGroupName,
null,
getVnetResponse.Value.Subnets[1].Id,
location,
"ipconfig",
NetworkManagementClient);
Task <NetworkInterface> nic2 = CreateNetworkInterface(
nic2name,
resourceGroupName,
null,
getVnetResponse.Value.Subnets[1].Id,
location,
"ipconfig",
NetworkManagementClient);
// Add NIC to application gateway backend address pool.
nic1.Result.IpConfigurations[0].ApplicationGatewayBackendAddressPools.Add(getGateway.Value.BackendAddressPools[1]);
nic2.Result.IpConfigurations[0].ApplicationGatewayBackendAddressPools.Add(getGateway.Value.BackendAddressPools[1]);
// Put Nics
NetworkInterfacesCreateOrUpdateOperation createOrUpdateOperation1 = await NetworkManagementClient.NetworkInterfaces.StartCreateOrUpdateAsync(resourceGroupName, nic1name, nic1.Result);
await WaitForCompletionAsync(createOrUpdateOperation1);
NetworkInterfacesCreateOrUpdateOperation createOrUpdateOperation2 = await NetworkManagementClient.NetworkInterfaces.StartCreateOrUpdateAsync(resourceGroupName, nic2name, nic2.Result);
await WaitForCompletionAsync(createOrUpdateOperation2);
// Get AppGw backend health
Operation <ApplicationGatewayBackendHealth> backendHealthOperation = await NetworkManagementClient.ApplicationGateways.StartBackendHealthAsync(resourceGroupName, appGwName, "true");
Response <ApplicationGatewayBackendHealth> backendHealth = await WaitForCompletionAsync(backendHealthOperation);
Assert.AreEqual(2, backendHealth.Value.BackendAddressPools.Count);
Assert.AreEqual(1, backendHealth.Value.BackendAddressPools[0].BackendHttpSettingsCollection.Count);
Assert.AreEqual(1, backendHealth.Value.BackendAddressPools[1].BackendHttpSettingsCollection.Count);
Assert.True(backendHealth.Value.BackendAddressPools[1].BackendAddressPool.BackendIPConfigurations.Any());
//Start AppGw
await NetworkManagementClient.ApplicationGateways.StartStartAsync(resourceGroupName, appGwName);
// Get AppGw and make sure nics are added to backend
getGateway = await NetworkManagementClient.ApplicationGateways.GetAsync(resourceGroupName, appGwName);
Assert.AreEqual(2, getGateway.Value.BackendAddressPools[1].BackendIPConfigurations.Count);
//Stop AppGw
await NetworkManagementClient.ApplicationGateways.StartStopAsync(resourceGroupName, appGwName);
// Delete AppGw
await NetworkManagementClient.ApplicationGateways.StartDeleteAsync(resourceGroupName, appGwName);
}
public async Task SubnetResourceNavigationLinksTest()
{
string resourceGroupName = Recording.GenerateAssetName("csmrg");
string location = await NetworkManagementTestUtilities.GetResourceLocation(ResourceManagementClient, "Microsoft.Network/virtualNetworks");
await ResourceGroupsOperations.CreateOrUpdateAsync(resourceGroupName, new ResourceGroup(location));
string vnetName = Recording.GenerateAssetName("azsmnet");
string subnetName = Recording.GenerateAssetName("azsmnet");
VirtualNetwork vnet = new VirtualNetwork()
{
Location = location,
AddressSpace = new AddressSpace()
{
AddressPrefixes = { "10.0.0.0/16", }
},
DhcpOptions = new DhcpOptions()
{
DnsServers = { "10.1.1.1", "10.1.2.4" }
},
Subnets = { new Subnet()
{
Name = subnetName, AddressPrefix = "10.0.0.0/24",
} }
};
VirtualNetworksCreateOrUpdateOperation putVnetResponseOperation = await NetworkManagementClient.VirtualNetworks.StartCreateOrUpdateAsync(resourceGroupName, vnetName, vnet);
await WaitForCompletionAsync(putVnetResponseOperation);
Response <Subnet> getSubnetResponse = await NetworkManagementClient.Subnets.GetAsync(resourceGroupName, vnetName, subnetName);
Assert.Null(getSubnetResponse.Value.ResourceNavigationLinks);
//TODO:Need RedisManagementClient
//redisClient.Redis.CreateOrUpdateWithHttpMessagesAsync(resourceGroupName, redisName, parameters: new RedisCreateOrUpdateParameters
//{
// Location = location,
// Sku = new Microsoft.Azure.Management.Redis.Models.Sku()
// {
// Name = SkuName.Premium,
// Family = SkuFamily.P,
// Capacity = 1
// },
// SubnetId = getSubnetResponse.Id
//}).Wait();
// wait for maximum 30 minutes for cache to create
//for (int i = 0; i < 60; i++)
//{
// TestUtilities.Wait(new TimeSpan(0, 0, 30));
// RedisResource responseGet = redisClient.Redis.Get(resourceGroupName: resourceGroupName, name: redisName);
// if ("succeeded".Equals(responseGet.ProvisioningState, StringComparison.OrdinalIgnoreCase))
// {
// break;
// }
// Assert.False(i == 60, "Cache is not in succeeded state even after 30 min.");
//}
getSubnetResponse = await NetworkManagementClient.Subnets.GetAsync(resourceGroupName, vnetName, subnetName);
Assert.AreEqual(1, getSubnetResponse.Value.ResourceNavigationLinks.Count);
}
public async Task SubnetApiTest()
{
string resourceGroupName = Recording.GenerateAssetName("csmrg");
string location = await NetworkManagementTestUtilities.GetResourceLocation(ResourceManagementClient, "Microsoft.Network/virtualNetworks");
await ResourceGroupsOperations.CreateOrUpdateAsync(resourceGroupName, new ResourceGroup(location));
string vnetName = Recording.GenerateAssetName("azsmnet");
string subnet1Name = Recording.GenerateAssetName("azsmnet");
string subnet2Name = Recording.GenerateAssetName("azsmnet");
VirtualNetwork vnet = new VirtualNetwork()
{
Location = location,
AddressSpace = new AddressSpace()
{
AddressPrefixes = { "10.0.0.0/16", }
},
DhcpOptions = new DhcpOptions()
{
DnsServers = { "10.1.1.1", "10.1.2.4" }
},
Subnets = { new Subnet()
{
Name = subnet1Name, AddressPrefix = "10.0.0.0/24",
} }
};
VirtualNetworksCreateOrUpdateOperation putVnetResponseOperation = await NetworkManagementClient.VirtualNetworks.StartCreateOrUpdateAsync(resourceGroupName, vnetName, vnet);
await WaitForCompletionAsync(putVnetResponseOperation);
// Create a Subnet
// Populate paramters for a Subnet
Subnet subnet = new Subnet()
{
Name = subnet2Name,
AddressPrefix = "10.0.1.0/24",
};
#region Verification
SubnetsCreateOrUpdateOperation putSubnetResponseOperation = await NetworkManagementClient.Subnets.StartCreateOrUpdateAsync(resourceGroupName, vnetName, subnet2Name, subnet);
await WaitForCompletionAsync(putSubnetResponseOperation);
Response <VirtualNetwork> getVnetResponse = await NetworkManagementClient.VirtualNetworks.GetAsync(resourceGroupName, vnetName);
Assert.AreEqual(2, getVnetResponse.Value.Subnets.Count());
Response <Subnet> getSubnetResponse = await NetworkManagementClient.Subnets.GetAsync(resourceGroupName, vnetName, subnet2Name);
// Verify the getSubnetResponse
Assert.True(AreSubnetsEqual(getVnetResponse.Value.Subnets[1], getSubnetResponse));
AsyncPageable <Subnet> getSubnetListResponseAP = NetworkManagementClient.Subnets.ListAsync(resourceGroupName, vnetName);
List <Subnet> getSubnetListResponse = await getSubnetListResponseAP.ToEnumerableAsync();
// Verify ListSubnets
Assert.True(AreSubnetsEqual(getVnetResponse.Value.Subnets, getSubnetListResponse));
// Delete the subnet "subnet1"
await NetworkManagementClient.Subnets.StartDeleteAsync(resourceGroupName, vnetName, subnet2Name);
// Verify that the deletion was successful
getSubnetListResponseAP = NetworkManagementClient.Subnets.ListAsync(resourceGroupName, vnetName);
getSubnetListResponse = await getSubnetListResponseAP.ToEnumerableAsync();
Has.One.EqualTo(getSubnetListResponse);
Assert.AreEqual(subnet1Name, getSubnetListResponse.ElementAt(0).Name);
#endregion
}
public async Task SubnetRouteTableTest()
{
string resourceGroupName = Recording.GenerateAssetName("csmrg");
string location = await NetworkManagementTestUtilities.GetResourceLocation(ResourceManagementClient, "Microsoft.Network/routeTables");
await ResourceGroupsOperations.CreateOrUpdateAsync(resourceGroupName, new ResourceGroup(location));
string routeTableName = Recording.GenerateAssetName("azsmnet");
string route1Name = Recording.GenerateAssetName("azsmnet");
RouteTable routeTable = new RouteTable()
{
Location = location,
};
routeTable.Routes = new List <Route>();
Route route1 = new Route()
{
AddressPrefix = "192.168.1.0/24",
Name = route1Name,
NextHopIpAddress = "23.108.1.1",
NextHopType = RouteNextHopType.VirtualAppliance
};
routeTable.Routes.Add(route1);
// Put RouteTable
RouteTablesCreateOrUpdateOperation putRouteTableResponseOperation = await NetworkManagementClient.RouteTables.StartCreateOrUpdateAsync(resourceGroupName, routeTableName, routeTable);
Response <RouteTable> putRouteTableResponse = await WaitForCompletionAsync(putRouteTableResponseOperation);
Assert.AreEqual("Succeeded", putRouteTableResponse.Value.ProvisioningState.ToString());
// Get RouteTable
Response <RouteTable> getRouteTableResponse = await NetworkManagementClient.RouteTables.GetAsync(resourceGroupName, routeTableName);
// Verify that the subnet reference is null
Assert.Null(getRouteTableResponse.Value.Subnets);
// Create Vnet with subnet and add a route table
string vnetName = Recording.GenerateAssetName("azsmnet");
string subnetName = Recording.GenerateAssetName("azsmnet");
var vnet = new VirtualNetwork()
{
Location = location,
AddressSpace = new AddressSpace()
{
AddressPrefixes = new List <string>()
{
"10.0.0.0/16",
}
},
DhcpOptions = new DhcpOptions()
{
DnsServers = new List <string>()
{
"10.1.1.1", "10.1.2.4"
}
},
Subnets = new List <Subnet>()
{
new Subnet()
{
Name = subnetName,
AddressPrefix = "10.0.0.0/24",
RouteTable = new RouteTable()
{
Id = getRouteTableResponse.Value.Id,
}
}
}
};
VirtualNetworksCreateOrUpdateOperation putVnetResponseOperation = await NetworkManagementClient.VirtualNetworks.StartCreateOrUpdateAsync(resourceGroupName, vnetName, vnet);
Response <VirtualNetwork> putVnetResponse = await WaitForCompletionAsync(putVnetResponseOperation);
Assert.AreEqual("Succeeded", putVnetResponse.Value.ProvisioningState.ToString());
Response <Subnet> getSubnetResponse = await NetworkManagementClient.Subnets.GetAsync(resourceGroupName, vnetName, subnetName);
Assert.AreEqual(getSubnetResponse.Value.RouteTable.Id, getRouteTableResponse.Value.Id);
// Get RouteTable
getRouteTableResponse = await NetworkManagementClient.RouteTables.GetAsync(resourceGroupName, routeTableName);
Assert.AreEqual(1, getRouteTableResponse.Value.Subnets.Count);
Assert.AreEqual(getSubnetResponse.Value.Id, getRouteTableResponse.Value.Subnets[0].Id);
}
public async Task VirtualNetworkApiTest()
{
string resourceGroupName = Recording.GenerateAssetName("csmrg");
string location = await NetworkManagementTestUtilities.GetResourceLocation(ResourceManagementClient, "Microsoft.Network/virtualNetworks");
await ResourceGroupsOperations.CreateOrUpdateAsync(resourceGroupName, new ResourceGroup(location));
string vnetName = Recording.GenerateAssetName("azsmnet");
string subnet1Name = Recording.GenerateAssetName("azsmnet");
string subnet2Name = Recording.GenerateAssetName("azsmnet");
VirtualNetwork vnet = new VirtualNetwork()
{
Location = location,
AddressSpace = new AddressSpace()
{
AddressPrefixes = { "10.0.0.0/16", }
},
DhcpOptions = new DhcpOptions()
{
DnsServers = { "10.1.1.1", "10.1.2.4" }
},
Subnets = { new Subnet()
{
Name = subnet1Name, AddressPrefix = "10.0.1.0/24",
}, new Subnet()
{
Name = subnet2Name, AddressPrefix = "10.0.2.0/24",
} }
};
// Put Vnet
VirtualNetworksCreateOrUpdateOperation putVnetResponseOperation = await NetworkManagementClient.VirtualNetworks.StartCreateOrUpdateAsync(resourceGroupName, vnetName, vnet);
Response <VirtualNetwork> putVnetResponse = await WaitForCompletionAsync(putVnetResponseOperation);
Assert.AreEqual("Succeeded", putVnetResponse.Value.ProvisioningState.ToString());
// Get Vnet
Response <VirtualNetwork> getVnetResponse = await NetworkManagementClient.VirtualNetworks.GetAsync(resourceGroupName, vnetName);
Assert.AreEqual(vnetName, getVnetResponse.Value.Name);
Assert.NotNull(getVnetResponse.Value.ResourceGuid);
Assert.AreEqual("Succeeded", getVnetResponse.Value.ProvisioningState.ToString());
Assert.AreEqual("10.1.1.1", getVnetResponse.Value.DhcpOptions.DnsServers[0]);
Assert.AreEqual("10.1.2.4", getVnetResponse.Value.DhcpOptions.DnsServers[1]);
Assert.AreEqual("10.0.0.0/16", getVnetResponse.Value.AddressSpace.AddressPrefixes[0]);
Assert.AreEqual(subnet1Name, getVnetResponse.Value.Subnets[0].Name);
Assert.AreEqual(subnet2Name, getVnetResponse.Value.Subnets[1].Name);
// Get all Vnets
AsyncPageable <VirtualNetwork> getAllVnetsAP = NetworkManagementClient.VirtualNetworks.ListAsync(resourceGroupName);
List <VirtualNetwork> getAllVnets = await getAllVnetsAP.ToEnumerableAsync();
Assert.AreEqual(vnetName, getAllVnets.ElementAt(0).Name);
Assert.AreEqual("Succeeded", getAllVnets.ElementAt(0).ProvisioningState.ToString());
Assert.AreEqual("10.0.0.0/16", getAllVnets.ElementAt(0).AddressSpace.AddressPrefixes[0]);
Assert.AreEqual(subnet1Name, getAllVnets.ElementAt(0).Subnets[0].Name);
Assert.AreEqual(subnet2Name, getAllVnets.ElementAt(0).Subnets[1].Name);
// Get all Vnets in a subscription
AsyncPageable <VirtualNetwork> getAllVnetInSubscriptionAP = NetworkManagementClient.VirtualNetworks.ListAllAsync();
List <VirtualNetwork> getAllVnetInSubscription = await getAllVnetInSubscriptionAP.ToEnumerableAsync();
Assert.IsNotEmpty(getAllVnetInSubscription);
// Delete Vnet
VirtualNetworksDeleteOperation deleteOperation = await NetworkManagementClient.VirtualNetworks.StartDeleteAsync(resourceGroupName, vnetName);
await WaitForCompletionAsync(deleteOperation);
// Get all Vnets
getAllVnetsAP = NetworkManagementClient.VirtualNetworks.ListAsync(resourceGroupName);
getAllVnets = await getAllVnetsAP.ToEnumerableAsync();
Assert.IsEmpty(getAllVnets);
}
public async Task VirtualNetworkUsageTest()
{
string resourceGroupName = Recording.GenerateAssetName("csmrg");
string location = await NetworkManagementTestUtilities.GetResourceLocation(ResourceManagementClient, "Microsoft.Network/virtualNetworks");
await ResourceGroupsOperations.CreateOrUpdateAsync(resourceGroupName, new ResourceGroup(location));
string vnetName = Recording.GenerateAssetName("azsmnet");
string subnetName = Recording.GenerateAssetName("azsmnet");
VirtualNetwork vnet = new VirtualNetwork()
{
Location = location,
AddressSpace = new AddressSpace()
{
AddressPrefixes = { "10.0.0.0/16", }
},
DhcpOptions = new DhcpOptions()
{
DnsServers = { "10.1.1.1", "10.1.2.4" }
},
Subnets = { new Subnet()
{
Name = subnetName, AddressPrefix = "10.0.1.0/24"
} }
};
// Put Vnet
VirtualNetworksCreateOrUpdateOperation putVnetResponseOperation = await NetworkManagementClient.VirtualNetworks.StartCreateOrUpdateAsync(resourceGroupName, vnetName, vnet);
Response <VirtualNetwork> putVnetResponse = await WaitForCompletionAsync(putVnetResponseOperation);
Assert.AreEqual("Succeeded", putVnetResponse.Value.ProvisioningState.ToString());
Response <Subnet> getSubnetResponse = await NetworkManagementClient.Subnets.GetAsync(resourceGroupName, vnetName, subnetName);
// Get Vnet usage
AsyncPageable <VirtualNetworkUsage> listUsageResponseAP = NetworkManagementClient.VirtualNetworks.ListUsageAsync(resourceGroupName, vnetName);
List <VirtualNetworkUsage> listUsageResponse = await listUsageResponseAP.ToEnumerableAsync();
Assert.AreEqual(0.0, listUsageResponse[0].CurrentValue);
// Create Nic
string nicName = Recording.GenerateAssetName("azsmnet");
string ipConfigName = Recording.GenerateAssetName("azsmnet");
NetworkInterface nicParameters = new NetworkInterface()
{
Location = location,
Tags = { { "key", "value" } },
IpConfigurations =
{
new NetworkInterfaceIPConfiguration()
{
Name = ipConfigName,
PrivateIPAllocationMethod = IPAllocationMethod.Static,
PrivateIPAddress = "10.0.1.9",
Subnet = new Subnet()
{
Id = getSubnetResponse.Value.Id
}
}
}
};
NetworkInterfacesCreateOrUpdateOperation putNicResponseOperation = await NetworkManagementClient.NetworkInterfaces.StartCreateOrUpdateAsync(resourceGroupName, nicName, nicParameters);
await WaitForCompletionAsync(putNicResponseOperation);
// Get Vnet usage again
listUsageResponseAP = NetworkManagementClient.VirtualNetworks.ListUsageAsync(resourceGroupName, vnetName);
listUsageResponse = await listUsageResponseAP.ToEnumerableAsync();
Assert.AreEqual(1.0, listUsageResponse[0].CurrentValue);
// Delete Vnet and Nic
await NetworkManagementClient.NetworkInterfaces.StartDeleteAsync(resourceGroupName, nicName);
await NetworkManagementClient.VirtualNetworks.StartDeleteAsync(resourceGroupName, vnetName);
}
public async Task VirtualNetworkPeeringTest()
{
string resourceGroupName = Recording.GenerateAssetName("csmrg");
string location = await NetworkManagementTestUtilities.GetResourceLocation(ResourceManagementClient, "Microsoft.Network/virtualNetworks");
await ResourceGroupsOperations.CreateOrUpdateAsync(resourceGroupName, new ResourceGroup(location));
string vnet1Name = Recording.GenerateAssetName("azsmnet");
string vnet2Name = Recording.GenerateAssetName("azsmnet");
string subnet1Name = Recording.GenerateAssetName("azsmnet");
string subnet2Name = Recording.GenerateAssetName("azsmnet");
VirtualNetwork vnet = new VirtualNetwork()
{
Location = location,
AddressSpace = new AddressSpace()
{
AddressPrefixes = { "10.0.0.0/16", }
},
DhcpOptions = new DhcpOptions()
{
DnsServers = { "10.1.1.1", "10.1.2.4" }
},
Subnets = { new Subnet()
{
Name = subnet1Name, AddressPrefix = "10.0.1.0/24",
}, new Subnet()
{
Name = subnet2Name, AddressPrefix = "10.0.2.0/24"
} }
};
// Put Vnet
VirtualNetworksCreateOrUpdateOperation putVnetResponseOperation = await NetworkManagementClient.VirtualNetworks.StartCreateOrUpdateAsync(resourceGroupName, vnet1Name, vnet);
Response <VirtualNetwork> putVnetResponse = await WaitForCompletionAsync(putVnetResponseOperation);
Assert.AreEqual("Succeeded", putVnetResponse.Value.ProvisioningState.ToString());
// Get Vnet
Response <VirtualNetwork> getVnetResponse = await NetworkManagementClient.VirtualNetworks.GetAsync(resourceGroupName, vnet1Name);
Assert.AreEqual(vnet1Name, getVnetResponse.Value.Name);
Assert.NotNull(getVnetResponse.Value.ResourceGuid);
Assert.AreEqual("Succeeded", getVnetResponse.Value.ProvisioningState.ToString());
// Create vnet2
VirtualNetwork vnet2 = new VirtualNetwork()
{
Location = location,
AddressSpace = new AddressSpace()
{
AddressPrefixes = { "10.1.0.0/16", }
},
Subnets = { new Subnet()
{
Name = subnet1Name, AddressPrefix = "10.1.1.0/24"
} }
};
// Put Vnet2
VirtualNetworksCreateOrUpdateOperation putVnet2Operation = await NetworkManagementClient.VirtualNetworks.StartCreateOrUpdateAsync(resourceGroupName, vnet2Name, vnet2);
Response <VirtualNetwork> putVnet2 = await WaitForCompletionAsync(putVnet2Operation);
Assert.AreEqual("Succeeded", putVnet2.Value.ProvisioningState.ToString());
// Create peering object
var peering = new VirtualNetworkPeering()
{
AllowForwardedTraffic = true,
RemoteVirtualNetwork = new SubResource {
Id = putVnet2.Value.Id
}
};
// Create Peering
await NetworkManagementClient.VirtualNetworkPeerings.StartCreateOrUpdateAsync(resourceGroupName, vnet1Name, "peer1", peering);
// Get Peering
Response <VirtualNetworkPeering> getPeer = await NetworkManagementClient.VirtualNetworkPeerings.GetAsync(resourceGroupName, vnet1Name, "peer1");
Assert.AreEqual("peer1", getPeer.Value.Name);
Assert.True(getPeer.Value.AllowForwardedTraffic);
Assert.True(getPeer.Value.AllowVirtualNetworkAccess);
Assert.False(getPeer.Value.AllowGatewayTransit);
Assert.NotNull(getPeer.Value.RemoteVirtualNetwork);
Assert.AreEqual(putVnet2.Value.Id, getPeer.Value.RemoteVirtualNetwork.Id);
// List Peering
AsyncPageable <VirtualNetworkPeering> listPeerAP = NetworkManagementClient.VirtualNetworkPeerings.ListAsync(resourceGroupName, vnet1Name);
List <VirtualNetworkPeering> listPeer = await listPeerAP.ToEnumerableAsync();
Has.One.EqualTo(listPeer);
Assert.AreEqual("peer1", listPeer[0].Name);
Assert.True(listPeer[0].AllowForwardedTraffic);
Assert.True(listPeer[0].AllowVirtualNetworkAccess);
Assert.False(listPeer[0].AllowGatewayTransit);
Assert.NotNull(listPeer[0].RemoteVirtualNetwork);
Assert.AreEqual(putVnet2.Value.Id, listPeer[0].RemoteVirtualNetwork.Id);
// Get peering from GET vnet
Response <VirtualNetwork> peeringVnet = await NetworkManagementClient.VirtualNetworks.GetAsync(resourceGroupName, vnet1Name);
Assert.AreEqual(vnet1Name, peeringVnet.Value.Name);
Has.One.EqualTo(peeringVnet.Value.VirtualNetworkPeerings);
Assert.AreEqual("peer1", peeringVnet.Value.VirtualNetworkPeerings[0].Name);
Assert.True(peeringVnet.Value.VirtualNetworkPeerings[0].AllowForwardedTraffic);
Assert.True(peeringVnet.Value.VirtualNetworkPeerings[0].AllowVirtualNetworkAccess);
Assert.False(peeringVnet.Value.VirtualNetworkPeerings[0].AllowGatewayTransit);
Assert.NotNull(peeringVnet.Value.VirtualNetworkPeerings[0].RemoteVirtualNetwork);
Assert.AreEqual(putVnet2.Value.Id, peeringVnet.Value.VirtualNetworkPeerings[0].RemoteVirtualNetwork.Id);
// Delete Peering
VirtualNetworkPeeringsDeleteOperation deleteOperation = await NetworkManagementClient.VirtualNetworkPeerings.StartDeleteAsync(resourceGroupName, vnet1Name, "peer1");
await WaitForCompletionAsync(deleteOperation);
listPeerAP = NetworkManagementClient.VirtualNetworkPeerings.ListAsync(resourceGroupName, vnet1Name);
listPeer = await listPeerAP.ToEnumerableAsync();
Assert.IsEmpty(listPeer);
peeringVnet = await NetworkManagementClient.VirtualNetworks.GetAsync(resourceGroupName, vnet1Name);
Assert.AreEqual(vnet1Name, peeringVnet.Value.Name);
Assert.IsEmpty(peeringVnet.Value.VirtualNetworkPeerings);
// Delete Vnets
await NetworkManagementClient.VirtualNetworks.StartDeleteAsync(resourceGroupName, vnet1Name);
await NetworkManagementClient.VirtualNetworks.StartDeleteAsync(resourceGroupName, vnet2Name);
}
public async Task VirtualNetworkCheckIpAddressAvailabilityTest()
{
string resourceGroupName = Recording.GenerateAssetName("csmrg");
string location = await NetworkManagementTestUtilities.GetResourceLocation(ResourceManagementClient, "Microsoft.Network/virtualNetworks");
await ResourceGroupsOperations.CreateOrUpdateAsync(resourceGroupName, new ResourceGroup(location));
string vnetName = Recording.GenerateAssetName("azsmnet");
string subnetName = Recording.GenerateAssetName("azsmnet");
VirtualNetwork vnet = new VirtualNetwork()
{
Location = location,
AddressSpace = new AddressSpace()
{
AddressPrefixes = { "10.0.0.0/16", }
},
DhcpOptions = new DhcpOptions()
{
DnsServers = { "10.1.1.1", "10.1.2.4" }
},
Subnets = { new Subnet()
{
Name = subnetName, AddressPrefix = "10.0.1.0/24"
} }
};
// Put Vnet
VirtualNetworksCreateOrUpdateOperation putVnetResponseOperation = await NetworkManagementClient.VirtualNetworks.StartCreateOrUpdateAsync(resourceGroupName, vnetName, vnet);
Response <VirtualNetwork> putVnetResponse = await WaitForCompletionAsync(putVnetResponseOperation);
Assert.AreEqual("Succeeded", putVnetResponse.Value.ProvisioningState.ToString());
Response <Subnet> getSubnetResponse = await NetworkManagementClient.Subnets.GetAsync(resourceGroupName, vnetName, subnetName);
// Create Nic
string nicName = Recording.GenerateAssetName("azsmnet");
string ipConfigName = Recording.GenerateAssetName("azsmnet");
NetworkInterface nicParameters = new NetworkInterface()
{
Location = location,
Tags = { { "key", "value" } },
IpConfigurations =
{
new NetworkInterfaceIPConfiguration()
{
Name = ipConfigName,
PrivateIPAllocationMethod = IPAllocationMethod.Static,
PrivateIPAddress = "10.0.1.9",
Subnet = new Subnet()
{
Id = getSubnetResponse.Value.Id
}
}
}
};
NetworkInterfacesCreateOrUpdateOperation putNicResponseOperation = await NetworkManagementClient.NetworkInterfaces.StartCreateOrUpdateAsync(resourceGroupName, nicName, nicParameters);
await WaitForCompletionAsync(putNicResponseOperation);
// Check Ip Address availability API
Response <IPAddressAvailabilityResult> responseAvailable = await NetworkManagementClient.VirtualNetworks.CheckIPAddressAvailabilityAsync(resourceGroupName, vnetName, "10.0.1.10");
Assert.True(responseAvailable.Value.Available);
Assert.IsEmpty(responseAvailable.Value.AvailableIPAddresses);
Response <IPAddressAvailabilityResult> responseTaken = await NetworkManagementClient.VirtualNetworks.CheckIPAddressAvailabilityAsync(resourceGroupName, vnetName, "10.0.1.9");
Assert.False(responseTaken.Value.Available);
Assert.AreEqual(5, responseTaken.Value.AvailableIPAddresses.Count);
await NetworkManagementClient.NetworkInterfaces.StartDeleteAsync(resourceGroupName, nicName);
await NetworkManagementClient.VirtualNetworks.StartDeleteAsync(resourceGroupName, vnetName);
}
