public async Task GetDefaultQuotas()
{
using (var httpTest = new HttpTest())
{
httpTest.RespondWith(JObject.Parse(@"
{
'quota_set': {
'injected_file_content_bytes': 10240,
'metadata_items': 128,
'server_group_members': 10,
'server_groups': 10,
'ram': 51200,
'floating_ips': 10,
'key_pairs': 100,
'id': 'defaults',
'instances': 10,
'security_group_rules': 20,
'injected_files': 5,
'cores': 20,
'fixed_ips': -1,
'injected_file_path_bytes': 255,
'security_groups': 10
}
}").ToString());
var quotas = await _compute.GetDefaultQuotasAsync();
httpTest.ShouldHaveCalled("*/os-quota-sets/defaults");
Assert.NotNull(quotas);
Assert.Equal(100, quotas.KeyPairs);
Assert.Equal(-1, quotas.FixedIPs);
}
}
public void GetVolumeSnapshot()
{
using (var httpTest = new HttpTest())
{
Identifier snapshotId = Guid.NewGuid();
httpTest.RespondWithJson(new VolumeSnapshot { Id = snapshotId });
var result = _compute.GetVolumeSnapshot(snapshotId);
httpTest.ShouldHaveCalled($"*/os-snapshots/{snapshotId}");
Assert.NotNull(result);
Assert.Equal(snapshotId, result.Id);
}
}
public void GetNetwork()
{
using (var httpTest = new HttpTest())
{
Identifier networkId = Guid.NewGuid();
httpTest.RespondWithJson(new Network { Id = networkId });
var network = _networkingService.GetNetwork(networkId);
httpTest.ShouldHaveCalled("*/networks/" + networkId);
Assert.NotNull(network);
Assert.Equal(networkId, network.Id);
}
}
public void GetConsole()
{
using (var httpTest = new HttpTest())
{
Identifier serverId = Guid.NewGuid();
httpTest.RespondWithJson(new Console {Type = RemoteConsoleType.NoVnc});
Console result = _computeService.GetConsole(serverId, ConsoleProtocol.VNC, RemoteConsoleType.NoVnc);
httpTest.ShouldHaveCalled($"*/servers/{serverId}/remote-consoles");
Assert.NotNull(result);
Assert.Equal(RemoteConsoleType.NoVnc, result.Type);
}
}
public void CreateServerGroup()
{
using (var httpTest = new HttpTest())
{
Identifier serverGroupId = Guid.NewGuid();
httpTest.RespondWithJson(new ServerGroup {Id = serverGroupId});
var request = new ServerGroupDefinition("{name}", "{policy-name}");
var result = _compute.CreateServerGroup(request);
httpTest.ShouldHaveCalled("*/os-server-groups");
Assert.Equal(serverGroupId, result.Id);
Assert.IsType<ComputeApi>(((IServiceResource)result).Owner);
}
}
public void GetServerGroup()
{
using (var httpTest = new HttpTest())
{
Identifier serverGroupId = Guid.NewGuid();
httpTest.RespondWithJson(new ServerGroup { Id = serverGroupId });
var result = _compute.GetServerGroup(serverGroupId);
httpTest.ShouldHaveCalled($"*/os-server-groups/{serverGroupId}");
Assert.NotNull(result);
Assert.Equal(serverGroupId, result.Id);
Assert.IsType<ComputeApi>(((IServiceResource)result).Owner);
}
}
public void CreateVolume()
{
using (var httpTest = new HttpTest())
{
Identifier volumeId = Guid.NewGuid();
httpTest.RespondWithJson(new Volume {Id = volumeId});
var request = new VolumeDefinition(size: 1);
var result = _compute.CreateVolume(request);
httpTest.ShouldHaveCalled("*/os-volumes");
Assert.Equal(volumeId, result.Id);
Assert.IsType<ComputeApi>(((IServiceResource)result).Owner);
}
}
public void ListSubnets()
{
using (var httpTest = new HttpTest())
{
Identifier subnetId = Guid.NewGuid();
httpTest.RespondWithJson(new SubnetCollection(new[] {new Subnet {Id = subnetId}}));
var subnets = _networkingService.ListSubnets();
httpTest.ShouldHaveCalled("*/subnets");
Assert.NotNull(subnets);
Assert.Equal(1, subnets.Count());
Assert.Equal(subnetId, subnets.First().Id);
}
}
public void ListNetworks()
{
using (var httpTest = new HttpTest())
{
Identifier networkId = Guid.NewGuid();
httpTest.RespondWithJson(new NetworkCollection(new[] {new Network {Id = networkId}}));
var networks = _networkingService.ListNetworks();
httpTest.ShouldHaveCalled("*/networks");
Assert.NotNull(networks);
Assert.Equal(1, networks.Count());
Assert.Equal(networkId, networks.First().Id);
}
}
public void GetRouter()
{
using (var httpTest = new HttpTest())
{
Identifier routerId = Guid.NewGuid();
httpTest.RespondWithJson(new Router { Id = routerId });
var result = _networking.GetRouter(routerId);
httpTest.ShouldHaveCalled($"*/routers/{routerId}");
Assert.NotNull(result);
Assert.Equal(routerId, result.Id);
Assert.IsType<NetworkingApiBuilder>(((IServiceResource)result).Owner);
}
}
public void CreateNetwork()
{
using (var httpTest = new HttpTest())
{
Identifier networkId = Guid.NewGuid();
httpTest.RespondWithJson(new Network{Id = networkId});
var definition = new NetworkDefinition();
var network = _networkingService.CreateNetwork(definition);
httpTest.ShouldHaveCalled("*/networks");
Assert.NotNull(network);
Assert.Equal(networkId, network.Id);
}
}
public void GetVolume()
{
using (var httpTest = new HttpTest())
{
Identifier volumeId = Guid.NewGuid();
httpTest.RespondWithJson(new Volume { Id = volumeId });
var result = _compute.GetVolume(volumeId);
httpTest.ShouldHaveCalled($"*/os-volumes/{volumeId}");
Assert.NotNull(result);
Assert.Equal(volumeId, result.Id);
Assert.IsType<ComputeApi>(((IServiceResource)result).Owner);
}
}
public void CreateSubnet()
{
using (var httpTest = new HttpTest())
{
Identifier networkId = Guid.NewGuid();
Identifier subnetId = Guid.NewGuid();
httpTest.RespondWithJson(new Subnet { Id = subnetId });
var definition = new SubnetCreateDefinition(networkId, IPVersion.IPv4, "10.0.0.0/24");
var subnet = _networkingService.CreateSubnet(definition);
httpTest.ShouldHaveCalled("*/subnets");
Assert.NotNull(subnet);
Assert.Equal(subnetId, subnet.Id);
}
}
public void CreateNetworks()
{
using (var httpTest = new HttpTest())
{
httpTest.RespondWithJson(new NetworkCollection(new[] { new Network { Name = "network-1"}, new Network{Name = "network-2"} }));
var definitions = new[] {new NetworkDefinition(), new NetworkDefinition()};
var networks = _networkingService.CreateNetworks(definitions);
httpTest.ShouldHaveCalled("*/networks");
Assert.NotNull(networks);
Assert.Equal(2, networks.Count());
Assert.Equal("network-1", networks.First().Name);
Assert.Equal("network-2", networks.Last().Name);
}
}
public void CreateServer()
{
using (var httpTest = new HttpTest())
{
Identifier serverId = Guid.NewGuid();
httpTest.RespondWithJson(new Server {Id = serverId});
var definition = new ServerCreateDefinition("{name}", Guid.NewGuid(), "{flavor-id}");
var result = _compute.CreateServer(definition);
httpTest.ShouldHaveCalled("*/servers");
Assert.NotNull(result);
Assert.Equal(serverId,result.Id);
Assert.IsType<ComputeApi>(((IServiceResource)result).Owner);
}
}
public async Task EvacuateServer()
{
using (var httpTest = new HttpTest())
{
Identifier serverId = Guid.NewGuid();
httpTest.RespondWithJson(new Server { Id = serverId });
httpTest.RespondWith((int)HttpStatusCode.Accepted, "Roger that, boss");
var server = _compute.GetServer(serverId);
await server.EvacuateAsync(new EvacuateServerRequest(false));
httpTest.ShouldHaveCalled($"*/servers/{serverId}/action");
string lastRequest = httpTest.CallLog.Last().RequestBody;
Assert.True(lastRequest.Contains("evacuate"));
}
}
public void CreatePort()
{
using (var httpTest = new HttpTest())
{
Identifier networkId = Guid.NewGuid();
Identifier portId = Guid.NewGuid();
httpTest.RespondWithJson(new Port { Id = portId });
var definition = new PortCreateDefinition(networkId);
var port = _networkingService.CreatePort(definition);
httpTest.ShouldHaveCalled("*/ports");
Assert.NotNull(port);
Assert.Equal(portId, port.Id);
}
}
public void CreateRouter()
{
using (var httpTest = new HttpTest())
{
Identifier networkId = Guid.NewGuid();
Identifier routerId = Guid.NewGuid();
httpTest.RespondWithJson(new Router { Id = routerId, ExternalGateway = new ExternalGateway { ExternalNetworkId = networkId } });
var definition = new RouterCreateDefinition();
var result = _networking.CreateRouter(definition);
httpTest.ShouldHaveCalled("*/routers");
Assert.NotNull(result);
Assert.Equal(routerId, result.Id);
Assert.Equal(networkId, result.ExternalGateway.ExternalNetworkId);
Assert.IsType<NetworkingApiBuilder>(((IServiceResource)result).Owner);
}
}
public void ListServerAddresses()
{
using (var httpTest = new HttpTest())
{
Identifier serverId = Guid.NewGuid();
httpTest.RespondWithJson(new ServerCollection { new Server { Id = serverId } });
httpTest.RespondWithJson(new ServerAddressCollection {["ServiceNet"] = new List<ServerAddress> {new ServerAddress {IP = "192.168.1.189"}}});
var serverReferences = _compute.ListServerSummaries();
var results = serverReferences.First().ListAddresses();
httpTest.ShouldHaveCalled($"*/servers/{serverId}/ips");
Assert.NotNull(results);
Assert.True(results.ContainsKey("ServiceNet"));
var result = results["ServiceNet"].First();
Assert.Equal("192.168.1.189", result.IP);
}
}
public void ListServerGroups()
{
using (var httpTest = new HttpTest())
{
Identifier serverGroupId = Guid.NewGuid();
httpTest.RespondWithJson(new ServerGroupCollection
{
new ServerGroup {Id = serverGroupId}
});
var results = _compute.ListServerGroups();
httpTest.ShouldHaveCalled("*/os-server-groups");
Assert.Equal(1, results.Count());
var result = results.First();
Assert.Equal(serverGroupId, result.Id);
Assert.IsType<ComputeApi>(((IServiceResource)result).Owner);
}
}
public void ListRouters()
{
using (var httpTest = new HttpTest())
{
Identifier routerId = Guid.NewGuid();
httpTest.RespondWithJson(new RouterCollection
{
new Router { Id = routerId }
});
var results = _networking.ListRouters(new RouterListOptions { Status = RouterStatus.Active });
httpTest.ShouldHaveCalled("*/routers?status=ACTIVE");
Assert.Equal(1, results.Count());
var result = results.First();
Assert.Equal(routerId, result.Id);
Assert.IsType<NetworkingApiBuilder>(((IServiceResource)result).Owner);
}
}
public void CreatePorts()
{
using (var httpTest = new HttpTest())
{
httpTest.RespondWithJson(new PortCollection(new[] {new Port {Name = "port-1"}, new Port {Name = "port-2"}}));
Identifier networkId = Guid.NewGuid();
var definitions = new[]
{
new PortCreateDefinition(networkId),
new PortCreateDefinition(networkId)
};
var ports = _networkingService.CreatePorts(definitions);
httpTest.ShouldHaveCalled("*/ports");
Assert.NotNull(ports);
Assert.Equal(2, ports.Count());
Assert.Equal("port-1", ports.First().Name);
Assert.Equal("port-2", ports.Last().Name);
}
}
public void CreateSubnets()
{
using (var httpTest = new HttpTest())
{
Identifier networkId = Guid.NewGuid();
httpTest.RespondWithJson(new SubnetCollection(new[] { new Subnet { Name = "subnet-1" }, new Subnet { Name = "subnet-2" } }));
var definitions = new[]
{
new SubnetCreateDefinition(networkId, IPVersion.IPv4, "{cidr-1}"),
new SubnetCreateDefinition(networkId, IPVersion.IPv6, "{cidr-2}")
};
var subnets = _networkingService.CreateSubnets(definitions);
httpTest.ShouldHaveCalled("*/subnets");
Assert.NotNull(subnets);
Assert.Equal(2, subnets.Count());
Assert.Equal("subnet-1", subnets.First().Name);
Assert.Equal("subnet-2", subnets.Last().Name);
}
}
public void GetServerAddress()
{
using (var httpTest = new HttpTest())
{
Identifier serverId = Guid.NewGuid();
httpTest.RespondWithJson(new ServerCollection { new Server { Id = serverId } });
httpTest.RespondWithJson(new Dictionary<string, IList<ServerAddress>>
{
["private"] = new List<ServerAddress>
{
new ServerAddress {IP = "1.2.3.4"}
}
});
var serverReferences = _compute.ListServerSummaries();
var result = (serverReferences.First().GetAddress("private")).First();
httpTest.ShouldHaveCalled($"*/servers/{serverId}/ips/private");
Assert.NotNull(result);
Assert.Equal("1.2.3.4", result.IP);
}
}
public void DeleteNetwork()
{
using (var httpTest = new HttpTest())
{
Identifier networkId = Guid.NewGuid();
httpTest.RespondWith((int)HttpStatusCode.NoContent, "All gone!");
_networkingService.DeleteNetwork(networkId);
httpTest.ShouldHaveCalled("*/networks/" + networkId);
}
}
public void ListSecurityGroupRules()
{
using (var httpTest = new HttpTest())
{
Identifier securityGroupId = Guid.NewGuid();
Identifier securityGroupRuleId = Guid.NewGuid();
httpTest.RespondWithJson(new SecurityGroupRuleCollection
{
new SecurityGroupRule {Id = securityGroupRuleId, SecurityGroupId = securityGroupId}
});
var results = _networking.ListSecurityGroupRules();
httpTest.ShouldHaveCalled("*/security-group-rules");
Assert.Equal(1, results.Count());
var result = results.First();
Assert.Equal(securityGroupRuleId, result.Id);
Assert.Equal(securityGroupId, result.SecurityGroupId);
}
}
public void DeleteRouter(HttpStatusCode responseCode)
{
using (var httpTest = new HttpTest())
{
Identifier portId = Guid.NewGuid();
Identifier routerId = Guid.NewGuid();
httpTest.RespondWithJson(new Router { Id = routerId});
httpTest.RespondWithJson(new PortCollection
{
new Port {Id = portId}
});
httpTest.RespondWith((int)responseCode, "All gone!");
var router = _networking.GetRouter(routerId);
router.Delete();
httpTest.ShouldHaveCalled($"*/routers/{routerId}/remove_router_interface");
httpTest.ShouldHaveCalled($"*/routers/{routerId}");
}
}
public void WhenDeleteNetwork_Returns404NotFound_ShouldConsiderRequestSuccessful()
{
using (var httpTest = new HttpTest())
{
Identifier networkId = Guid.NewGuid();
httpTest.RespondWith((int)HttpStatusCode.NotFound, "Not here, boss...");
_networkingService.DeleteNetwork(networkId);
httpTest.ShouldHaveCalled("*/networks/" + networkId);
}
}
public void UpdateSubnet()
{
using (var httpTest = new HttpTest())
{
Identifier subnetId = Guid.NewGuid();
httpTest.RespondWithJson(new Subnet { Id = subnetId });
var definition = new SubnetUpdateDefinition { Name = "new subnet name" };
var subnet = _networkingService.UpdateSubnet(subnetId, definition);
httpTest.ShouldHaveCalled("*/subnets/" + subnetId);
Assert.NotNull(subnet);
Assert.Equal(subnetId, subnet.Id);
}
}
public void GetSubnets()
{
using (var httpTest = new HttpTest())
{
Identifier subnetId = Guid.NewGuid();
httpTest.RespondWithJson(new Subnet { Id = subnetId });
var subnet = _networkingService.GetSubnet(subnetId);
httpTest.ShouldHaveCalled("*/subnets/" + subnetId);
Assert.NotNull(subnet);
Assert.Equal(subnetId, subnet.Id);
}
}