278 lines
9.8 KiB
C#
278 lines
9.8 KiB
C#
using System;
|
|
using System.Diagnostics;
|
|
using System.Linq;
|
|
using Xunit;
|
|
using Xunit.Abstractions;
|
|
|
|
namespace Rackspace.CloudNetworks.v2
|
|
{
|
|
public class CloudNetworkServiceTests : IDisposable
|
|
{
|
|
private readonly CloudNetworkService _networkingService;
|
|
private readonly CloudNetworksTestDataManager _testData;
|
|
|
|
public CloudNetworkServiceTests(ITestOutputHelper testLog)
|
|
{
|
|
var testOutput = new XunitTraceListener(testLog);
|
|
Trace.Listeners.Add(testOutput);
|
|
RackspaceNet.Tracing.Http.Listeners.Add(testOutput);
|
|
|
|
var authenticationProvider = TestIdentityProvider.GetIdentityProvider();
|
|
_networkingService = new CloudNetworkService(authenticationProvider, "IAD");
|
|
|
|
_testData = new CloudNetworksTestDataManager(_networkingService);
|
|
}
|
|
|
|
public void Dispose()
|
|
{
|
|
Trace.Listeners.Clear();
|
|
RackspaceNet.Tracing.Http.Listeners.Clear();
|
|
|
|
_testData.Dispose();
|
|
}
|
|
|
|
#region Networks
|
|
|
|
[Fact]
|
|
public async void CreateNetworkTest()
|
|
{
|
|
var definition = _testData.BuildNetwork();
|
|
|
|
Trace.WriteLine(string.Format("Creating network named: {0}", definition.Name));
|
|
var network = await _testData.CreateNetwork(definition);
|
|
|
|
Trace.WriteLine("Verifying network matches requested definition...");
|
|
Assert.NotNull(network);
|
|
Assert.Equal(definition.Name, network.Name);
|
|
Assert.True(network.IsUp);
|
|
Assert.False(network.IsShared);
|
|
Assert.Equal(NetworkStatus.Active, network.Status);
|
|
}
|
|
|
|
[Fact]
|
|
public async void UpdateNetworkTest()
|
|
{
|
|
Network network = await _testData.CreateNetwork();
|
|
|
|
var networkUpdate = new NetworkDefinition
|
|
{
|
|
Name = string.Format("{0}-updated", network.Name)
|
|
};
|
|
|
|
Trace.WriteLine("Updating the network...");
|
|
network = await _networkingService.UpdateNetworkAsync(network.Id, networkUpdate);
|
|
|
|
Trace.WriteLine("Verifying network was updated as requested...");
|
|
Assert.NotNull(network);
|
|
Assert.Equal(networkUpdate.Name, network.Name);
|
|
}
|
|
|
|
[Fact]
|
|
public async void ListNetworksTest()
|
|
{
|
|
var networks = await _testData.CreateNetworks();
|
|
|
|
Trace.WriteLine("Listing networks...");
|
|
var results = await _networkingService.ListNetworksAsync();
|
|
|
|
Trace.WriteLine("Verifying list of networks...");
|
|
Assert.NotNull(results);
|
|
Assert.All(networks, network => Assert.True(results.Any(x => x.Id == network.Id)));
|
|
|
|
Trace.WriteLine("Getting the first page of networks...");
|
|
var pagedResults = await _networkingService.ListNetworksAsync(pageSize: 1);
|
|
Assert.Equal(1, pagedResults.Count());
|
|
}
|
|
|
|
[Fact]
|
|
public async void GetNetworkTest()
|
|
{
|
|
var network = await _testData.CreateNetwork();
|
|
|
|
Trace.WriteLine("Retrieving network...");
|
|
var result = await _networkingService.GetNetworkAsync(network.Id);
|
|
|
|
Trace.WriteLine("Verifying network...");
|
|
Assert.NotNull(result);
|
|
Assert.Equal(network.Id, result.Id);
|
|
}
|
|
#endregion
|
|
|
|
#region Subnets
|
|
[Fact]
|
|
public async void CreateSubnetTest()
|
|
{
|
|
var network = await _testData.CreateNetwork();
|
|
var definition = new SubnetCreateDefinition(network.Id, IPVersion.IPv4, "192.168.3.0/24")
|
|
{
|
|
Name = TestData.GenerateName(),
|
|
GatewayIP = "192.168.3.1",
|
|
AllocationPools =
|
|
{
|
|
new AllocationPool("192.168.3.10", "192.168.3.50")
|
|
},
|
|
Nameservers =
|
|
{
|
|
"8.8.8.8"
|
|
},
|
|
HostRoutes =
|
|
{
|
|
new HostRoute("1.2.3.4/24", "10.0.0.1")
|
|
}
|
|
};
|
|
|
|
Trace.WriteLine(string.Format("Creating subnet named: {0}", definition.Name));
|
|
var subnet = await _testData.CreateSubnet(definition);
|
|
|
|
Trace.WriteLine("Verifying subnet matches requested definition...");
|
|
Assert.NotNull(subnet);
|
|
Assert.Equal(definition.NetworkId, subnet.NetworkId);
|
|
Assert.Equal(definition.Name, subnet.Name);
|
|
Assert.Equal(definition.CIDR, subnet.CIDR);
|
|
Assert.Equal(definition.IPVersion, subnet.IPVersion);
|
|
Assert.Equal(definition.GatewayIP, subnet.GatewayIP);
|
|
Assert.Equal(definition.AllocationPools, subnet.AllocationPools);
|
|
Assert.Equal(definition.Nameservers, subnet.Nameservers);
|
|
Assert.Equal(definition.HostRoutes, subnet.HostRoutes);
|
|
}
|
|
|
|
[Fact]
|
|
public async void UpdateSubnetTest()
|
|
{
|
|
Network network = await _testData.CreateNetwork();
|
|
Subnet subnet = await _testData.CreateSubnet(network);
|
|
|
|
var networkUpdate = new SubnetUpdateDefinition
|
|
{
|
|
Name = string.Format("{0}-updated", subnet.Name)
|
|
};
|
|
|
|
Trace.WriteLine("Updating the subnet...");
|
|
subnet = await _networkingService.UpdateSubnetAsync(subnet.Id, networkUpdate);
|
|
|
|
Trace.WriteLine("Verifying subnet was updated as requested...");
|
|
Assert.NotNull(subnet);
|
|
Assert.Equal(networkUpdate.Name, subnet.Name);
|
|
}
|
|
|
|
[Fact]
|
|
public async void ListSubnetsTest()
|
|
{
|
|
var network = await _testData.CreateNetwork();
|
|
var subnets = await _testData.CreateSubnets(network);
|
|
|
|
Trace.WriteLine("Listing subnets...");
|
|
var results = await _networkingService.ListSubnetsAsync();
|
|
|
|
Trace.WriteLine("Verifying list of subnets...");
|
|
Assert.NotNull(results);
|
|
Assert.All(subnets, subnet => Assert.True(results.Any(x => x.Id == subnet.Id)));
|
|
|
|
Trace.WriteLine("Getting the first page of subnets...");
|
|
var pagedResults = await _networkingService.ListSubnetsAsync(pageSize: 1);
|
|
Assert.Equal(1, pagedResults.Count());
|
|
}
|
|
|
|
[Fact]
|
|
public async void GetSubnetTest()
|
|
{
|
|
var network = await _testData.CreateNetwork();
|
|
var subnet = await _testData.CreateSubnet(network);
|
|
|
|
Trace.WriteLine("Retrieving subnet...");
|
|
var result = await _networkingService.GetSubnetAsync(subnet.Id);
|
|
|
|
Trace.WriteLine("Verifying subnet...");
|
|
Assert.NotNull(result);
|
|
Assert.Equal(subnet.Id, result.Id);
|
|
|
|
}
|
|
#endregion
|
|
|
|
#region Ports
|
|
[Fact]
|
|
public async void CreatePortTests()
|
|
{
|
|
var network = await _testData.CreateNetwork();
|
|
var subnet = await _testData.CreateSubnet(network);
|
|
|
|
var portIdAddress = subnet.CIDR.Replace("0/24", "2");
|
|
var definition = new PortCreateDefinition(network.Id)
|
|
{
|
|
Name = TestData.GenerateName(),
|
|
FixedIPs =
|
|
{
|
|
new IPAddressAssociation(subnet.Id, portIdAddress)
|
|
}
|
|
};
|
|
|
|
Trace.WriteLine(string.Format("Creating port named: {0}", definition.Name));
|
|
var port = await _testData.CreatePort(definition);
|
|
|
|
Trace.WriteLine("Verifying port matches requested definition...");
|
|
Assert.NotNull(port);
|
|
Assert.NotNull(port.Id);
|
|
Assert.Equal(definition.Name, port.Name);
|
|
Assert.Equal(definition.NetworkId, port.NetworkId);
|
|
Assert.Equal(subnet.Id, port.FixedIPs.Single().SubnetId);
|
|
Assert.Equal(portIdAddress, port.FixedIPs.Single().IPAddress);
|
|
}
|
|
|
|
[Fact]
|
|
public async void UpdatePortTest()
|
|
{
|
|
Network network = await _testData.CreateNetwork();
|
|
var subnet = await _testData.CreateSubnet(network);
|
|
Port port = await _testData.CreatePort(network);
|
|
|
|
var portUpdate = new PortUpdateDefinition
|
|
{
|
|
Name = string.Format("{0}-updated", port.Name)
|
|
};
|
|
|
|
Trace.WriteLine("Updating the port...");
|
|
port = await _networkingService.UpdatePortAsync(port.Id, portUpdate);
|
|
|
|
Trace.WriteLine("Verifying port was updated as requested...");
|
|
Assert.NotNull(port);
|
|
Assert.Equal(portUpdate.Name, port.Name);
|
|
}
|
|
|
|
[Fact]
|
|
public async void ListPortsTest()
|
|
{
|
|
var network = await _testData.CreateNetwork();
|
|
var subnet = await _testData.CreateSubnet(network);
|
|
var ports = await _testData.CreatePorts(network);
|
|
|
|
Trace.WriteLine("Listing ports...");
|
|
var results = await _networkingService.ListPortsAsync();
|
|
|
|
Trace.WriteLine("Verifying list of ports...");
|
|
Assert.NotNull(results);
|
|
Assert.All(ports, port => Assert.True(results.Any(x => x.Id == port.Id)));
|
|
|
|
Trace.WriteLine("Getting the first page of ports...");
|
|
var pagedResults = await _networkingService.ListPortsAsync(pageSize: 1);
|
|
Assert.Equal(1, pagedResults.Count());
|
|
}
|
|
|
|
[Fact]
|
|
public async void GetPortTest()
|
|
{
|
|
var network = await _testData.CreateNetwork();
|
|
var subnet = await _testData.CreateSubnet(network);
|
|
var port = await _testData.CreatePort(network);
|
|
|
|
Trace.WriteLine("Retrieving port...");
|
|
var result = await _networkingService.GetPortAsync(port.Id);
|
|
|
|
Trace.WriteLine("Verifying port...");
|
|
Assert.NotNull(result);
|
|
Assert.Equal(port.Id, result.Id);
|
|
|
|
}
|
|
#endregion
|
|
}
|
|
}
|