public async void When401AuthenticationFailsMultipleTimes_ThrowException()
{
using (var httpTest = new HttpTest())
{
httpTest.RespondWith((int)HttpStatusCode.Unauthorized, "Your token has expired");
httpTest.RespondWith((int)HttpStatusCode.Unauthorized, "Your token has expired");
var service = new ContentDeliveryNetworkService(Stubs.AuthenticationProvider, "DFW");
await Assert.ThrowsAsync<FlurlHttpException>(() => service.GetFlavorAsync("flavor-id"));
}
}
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 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 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 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 DetachVolume()
{
using (var httpTest = new HttpTest())
{
Identifier volumeId = Guid.NewGuid();
Identifier serverId = Guid.NewGuid();
httpTest.RespondWithJson(new Server
{
Id = serverId,
AttachedVolumes = { new ServerVolume { Id = volumeId, DeviceName = "/dev/vdd" } }
});
httpTest.RespondWith((int)HttpStatusCode.Accepted, "Roger that, good buddy");
var server = _compute.GetServer(serverId);
ServerVolumeReference attachedVolume = server.AttachedVolumes[0];
attachedVolume.Detach();
httpTest.ShouldHaveCalled($"*/servers/{serverId}/os-volume_attachments/{volumeId}");
Assert.False(server.AttachedVolumes.Any(v => v.Id == volumeId));
}
}
public void RebootServer()
{
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);
server.Reboot(new RebootServerRequest {Type = RebootType.Hard});
httpTest.ShouldHaveCalled($"*/servers/{serverId}/action");
string lastRequest = httpTest.CallLog.Last().RequestBody;
Assert.True(lastRequest.Contains("reboot"));
Assert.True(lastRequest.Contains("HARD"));
}
}
public void ResumeServer()
{
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);
server.Resume();
httpTest.ShouldHaveCalled($"*/servers/{serverId}/action");
Assert.True(httpTest.CallLog.Last().RequestBody.Contains("resume"));
}
}
public void DeleteService()
{
using (var httpTest = new HttpTest())
{
httpTest.RespondWith((int)HttpStatusCode.NoContent, "All gone!");
_cdnService.DeleteService("service-id");
}
}
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 WhenDeleteServer_Returns404NotFound_ShouldConsiderRequestSuccessful()
{
using (var httpTest = new HttpTest())
{
Identifier serverId = Guid.NewGuid();
httpTest.RespondWith((int)HttpStatusCode.NotFound, "Not here, boss...");
_compute.DeleteServer(serverId);
httpTest.ShouldHaveCalled($"*/servers/{serverId}");
}
}
public void DisassociateFloatingIPFromServer()
{
var compute = new ComputeService(Stubs.AuthenticationProvider, "region");
using (var httpTest = new HttpTest())
{
Identifier serverId = Guid.NewGuid();
const string ip = "10.0.0.1";
httpTest.RespondWithJson(new Server
{
Id = serverId,
Addresses =
{
["network1"] = new List<ServerAddress>
{
new ServerAddress {IP = ip, Type = AddressType.Floating}
}
}
});
httpTest.RespondWith((int)HttpStatusCode.OK, "ip disassociated!");
var server = compute.GetServer(serverId);
server.DisassociateFloatingIP(ip);
Assert.Null(server.Addresses["network1"].FirstOrDefault(a => a.IP == ip && a.Type == AddressType.Floating));
}
}
public void DeleteServer()
{
using (var httpTest = new HttpTest())
{
Identifier serverId = Guid.NewGuid();
httpTest.RespondWith((int)HttpStatusCode.NoContent, "All gone!");
_compute.DeleteServer(serverId);
httpTest.ShouldHaveCalled($"*/servers/{serverId}");
}
}
public void DeleteServerExtension()
{
using (var httpTest = new HttpTest())
{
Identifier serverId = Guid.NewGuid();
httpTest.RespondWithJson(new Server {Id = serverId});
httpTest.RespondWith((int)HttpStatusCode.NoContent, "All gone!");
httpTest.RespondWithJson(new Server { Id = serverId, Status = ServerStatus.Deleted});
var server =_compute.GetServer(serverId);
server.Delete();
Assert.NotEqual(server.Status, ServerStatus.Deleted);
server.WaitUntilDeleted();
Assert.Equal(server.Status, ServerStatus.Deleted);
}
}
public void WhenIPurgeANonExistingAsset_TheOperationShouldBeConsideredSuccessful()
{
using (var httpTest = new HttpTest())
{
httpTest.RespondWith((int)HttpStatusCode.NotFound, "Nothing to see here!");
_cdnService.PurgeCachedAsset("service-id", "missing-asset");
}
}
public void WhenIDeleteANonExistingService_TheOperationShouldBeConsideredSuccessful()
{
using (var httpTest = new HttpTest())
{
httpTest.RespondWith((int)HttpStatusCode.NotFound, "Nothing to see here!");
_cdnService.DeleteService("bad-service-id");
}
}
public void WaitForServiceDeleted()
{
using (var httpTest = new HttpTest())
{
httpTest.RespondWithJson(new Service { Status = ServiceStatus.DeleteInProgress });
httpTest.RespondWith((int)HttpStatusCode.NotFound, "All gone!");
_cdnService.WaitForServiceDeleted("service-id", TimeSpan.FromMilliseconds(1));
}
}
public void GetConsoleOutput()
{
const string output = "FAKE CONSOLE OUTPUT\nANOTHER\nLAST LINE";
using (var httpTest = new HttpTest())
{
Identifier serverId = Guid.NewGuid();
httpTest.RespondWithJson(new Server { Id = serverId });
httpTest.RespondWith(JObject.Parse("{'output': '" + output + "'}").ToString());
var server = _compute.GetServer(serverId);
var result = server.GetConsoleOutput();
httpTest.ShouldHaveCalled($"*/servers/{serverId}/action");
Assert.Contains("os-getConsoleOutput", httpTest.CallLog.Last().RequestBody);
Assert.Equal(output, result);
}
}
public void DeleteServerMetadata(HttpStatusCode responseCode)
{
using (var httpTest = new HttpTest())
{
Identifier serverId = Guid.NewGuid();
const string key = "stuff";
httpTest.RespondWithJson(new Server
{
Id = serverId,
Metadata =
{
[key] = "things"
}
});
httpTest.RespondWith((int)responseCode, "All gone!");
var server = _compute.GetServer(serverId);
server.Metadata.Delete(key);
Assert.False(server.Metadata.ContainsKey(key));
httpTest.ShouldHaveCalled($"*/servers/{serverId}/metadata/{key}");
}
}
public void CancelResizeServer()
{
using (var httpTest = new HttpTest())
{
Identifier flavorId = "1";
Identifier serverId = Guid.NewGuid();
httpTest.RespondWithJson(new Server { Id = serverId });
httpTest.RespondWith((int)HttpStatusCode.Accepted, "Roger that, good buddy!");
httpTest.RespondWith((int)HttpStatusCode.Accepted, "Roger that, good buddy!");
var server = _compute.GetServer(serverId);
server.Resize(flavorId);
server.CancelResize();
httpTest.ShouldHaveCalled($"*/servers/{serverId}/action");
Assert.Contains("revertResize", httpTest.CallLog.Last().RequestBody);
}
}
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 DeleteFloatingIP(HttpStatusCode responseCode)
{
using (var httpTest = new HttpTest())
{
Identifier floatingIPId = Guid.NewGuid();
httpTest.RespondWith((int)responseCode, "All gone!");
_networking.DeleteFloatingIP(floatingIPId);
httpTest.ShouldHaveCalled($"*/floatingips/{floatingIPId}");
}
}
public void WaitForVolumeDeleted()
{
using (var httpTest = new HttpTest())
{
Identifier volumeId = Guid.NewGuid();
httpTest.RespondWithJson(new Volume { Id = volumeId, Status = VolumeStatus.Available });
httpTest.RespondWith((int)HttpStatusCode.Accepted, "All gone!");
httpTest.RespondWithJson(new Volume { Id = volumeId, Status = VolumeStatus.Deleting });
httpTest.RespondWith((int)HttpStatusCode.NotFound, "Not here, boss!");
var result = _compute.GetVolume(volumeId);
result.Delete();
result.WaitUntilDeleted();
}
}
public void DeleteVolume(HttpStatusCode responseCode)
{
using (var httpTest = new HttpTest())
{
Identifier volumeId = Guid.NewGuid();
httpTest.RespondWithJson(new Volume { Id = volumeId });
httpTest.RespondWith((int)responseCode, "All gone!");
var volume = _compute.GetVolume(volumeId);
volume.Delete();
httpTest.ShouldHaveCalled($"*/os-volumes/{volumeId}");
}
}
public void SnapshotServer()
{
using (var httpTest = new HttpTest())
{
Identifier serverId = Guid.NewGuid();
Identifier imageId = Guid.NewGuid();
httpTest.RespondWithJson(new Server { Id = serverId });
httpTest.RespondWith((int)HttpStatusCode.Accepted, "Roger that, boss");
httpTest.ResponseQueue.Last().Headers.Location = new Uri($"http://api.example.com/images/{imageId}");
httpTest.RespondWithJson(new Image { Id = imageId });
var server = _compute.GetServer(serverId);
Image result = server.Snapshot(new SnapshotServerRequest("{image-name"));
httpTest.ShouldHaveCalled($"*/servers/{serverId}/action");
Assert.True(httpTest.CallLog.First(x => x.Url.EndsWith("/action")).RequestBody.Contains("createImage"));
Assert.NotNull(result);
Assert.Equal(imageId, result.Id);
}
}
public void WaitForServerDeleted()
{
using (var httpTest = new HttpTest())
{
Identifier serverId = Guid.NewGuid();
httpTest.RespondWithJson(new Server { Id = serverId, Status = ServerStatus.Active });
httpTest.RespondWith((int)HttpStatusCode.NoContent, "All gone!");
httpTest.RespondWithJson(new Server { Id = serverId, Status = ServerStatus.Deleted });
var result = _compute.GetServer(serverId);
result.Delete();
result.WaitUntilDeleted();
Assert.Equal(ServerStatus.Deleted, result.Status);
}
}
public void DeleteVolumeSnapshot(HttpStatusCode responseCode)
{
using (var httpTest = new HttpTest())
{
Identifier snapshotId = Guid.NewGuid();
httpTest.RespondWithJson(new VolumeSnapshot { Id = snapshotId });
httpTest.RespondWith((int)responseCode, "All gone!");
var snapshot = _compute.GetVolumeSnapshot(snapshotId);
snapshot.Delete();
httpTest.ShouldHaveCalled($"*/os-snapshots/{snapshotId}");
}
}
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 WaitForServerDeleted_Returns404NotFound_ShouldConsiderRequestSuccessful()
{
using (var httpTest = new HttpTest())
{
Identifier serverId = Guid.NewGuid();
httpTest.RespondWithJson(new Server { Id = serverId, Status = ServerStatus.Active });
httpTest.RespondWith((int)HttpStatusCode.NoContent, "All gone!");
httpTest.RespondWith((int)HttpStatusCode.NotFound, "Nothing here, boss");
var result = _compute.GetServer(serverId);
result.Delete();
result.WaitUntilDeleted();
Assert.Equal(ServerStatus.Deleted, result.Status);
}
}