public void FindServiceOnAPage()
{
using (var httpTest = new HttpTest())
{
httpTest.RespondWithJson(new ServiceCollection
{
Services = {new Service()},
ServiceLinks = {new Link("next", "http://api.com/next")}
});
httpTest.RespondWithJson(new ServiceCollection
{
Services = {new Service {Name = "MyService"}}
});
var currentPage = _cdnService.ListServices();
Service myService;
do
{
myService = currentPage.FirstOrDefault(x => x.Name == "MyService");
if (myService != null)
break;
currentPage = currentPage.GetNextPage();
} while (currentPage.Any());
Assert.NotNull(myService);
}
}
public void SerializeListServerOptionsInUrl()
{
using (var httpTest = new HttpTest())
{
httpTest.RespondWithJson(new ServerSummaryCollection());
_compute.ListServerSummaries(new ServerListOptions());
httpTest.ShouldNotHaveCalled("*metadata*");
}
}
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 GetService()
{
using (var httpTest = new HttpTest())
{
httpTest.RespondWithJson(new Service{Id = "service-id"});
var service = _cdnService.GetService("service-id");
Assert.NotNull(service);
Assert.Equal("service-id", service.Id);
}
}
public async void When401UnauthorizedIsReturned_RetryRequest()
{
using (var httpTest = new HttpTest())
{
httpTest.RespondWith((int)HttpStatusCode.Unauthorized, "Your token has expired");
httpTest.RespondWithJson(new Flavor());
var service = new ContentDeliveryNetworkService(Stubs.AuthenticationProvider, "DFW");
var flavor = await service.GetFlavorAsync("flavor-id");
Assert.NotNull(flavor);
}
}
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 GetPorts()
{
using (var httpTest = new HttpTest())
{
Identifier portId = Guid.NewGuid();
httpTest.RespondWithJson(new Port { Id = portId });
var port = _networkingService.GetPort(portId);
httpTest.ShouldHaveCalled("*/ports/" + portId);
Assert.NotNull(port);
Assert.Equal(portId, port.Id);
}
}
public void DeleteServerGroup(HttpStatusCode responseCode)
{
using (var httpTest = new HttpTest())
{
Identifier serverGroupId = Guid.NewGuid();
httpTest.RespondWithJson(new ServerGroup { Id = serverGroupId });
httpTest.RespondWith((int)responseCode, "All gone!");
var serverGroup = _compute.GetServerGroup(serverGroupId);
serverGroup.Delete();
httpTest.ShouldHaveCalled($"*/os-server-groups/{serverGroupId}");
}
}
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 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);
}
}
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 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 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 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 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 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 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 CreateServerMetadata()
{
using (var httpTest = new HttpTest())
{
const string key = "stuff";
Identifier serverId = "1";
httpTest.RespondWithJson(new Server { Id = serverId });
var server = _compute.GetServer(serverId);
server.Metadata.Create(key, "things");
Assert.True(server.Metadata.ContainsKey(key));
httpTest.ShouldHaveCalled($"*/servers/{serverId}/metadata/{key}");
}
}
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 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 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 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 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 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 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 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 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);
}
}