public void AssignPublicIP()
{
using (var httpTest = new HttpTest())
{
Identifier serverId = Guid.NewGuid();
Identifier id = Guid.NewGuid();
httpTest.RespondWithJson(new PublicIP {Id = id});
httpTest.RespondWithJson(new PublicIP {Id = id, Server = new PublicIPServerAssociation {ServerId = serverId}});
var ip = _rackConnectService.GetPublicIP(id);
ip.Assign(serverId);
httpTest.ShouldHaveCalled($"*/public_ips/{id}");
Assert.NotNull(ip.Server);
Assert.Equal(serverId, ip.Server.ServerId);
}
}
public void AssignPublicIP_RetriesWhenTheServerIsNotFound()
{
using (var httpTest = new HttpTest())
{
Identifier serverId = Guid.NewGuid();
Identifier id = Guid.NewGuid();
httpTest.RespondWithJson(new PublicIP { Id = id });
httpTest.RespondWith((int)HttpStatusCode.Conflict, $"Cloud Server {serverId} does not exist");
httpTest.RespondWithJson(new PublicIP { Id = id, Server = new PublicIPServerAssociation { ServerId = serverId } });
var ip = _rackConnectService.GetPublicIP(id);
ip.Assign(serverId);
httpTest.ShouldHaveCalled($"*/public_ips/{id}");
Assert.NotNull(ip.Server);
Assert.Equal(serverId, ip.Server.ServerId);
}
}
public void DeletePublicIP()
{
using (var httpTest = new HttpTest())
{
Identifier id = Guid.NewGuid();
httpTest.RespondWithJson(new PublicIP {
Id = id
});
_rackConnectService.DeletePublicIP(id);
httpTest.ShouldHaveCalled($"*/public_ips/{id}");
}
}
public void AssignPublicIP()
{
using (var httpTest = new HttpTest())
{
Identifier serverId = Guid.NewGuid();
Identifier id = Guid.NewGuid();
httpTest.RespondWithJson(new PublicIP {
Id = id
});
httpTest.RespondWithJson(new PublicIP {
Id = id, Server = new PublicIPServerAssociation {
ServerId = serverId
}
});
var ip = _rackConnectService.GetPublicIP(id);
ip.Assign(serverId);
httpTest.ShouldHaveCalled($"*/public_ips/{id}");
Assert.NotNull(ip.Server);
Assert.Equal(serverId, ip.Server.ServerId);
}
}
public void DeveChamarEndpointDeCriaçãoPassandoTítulo()
{
using var httpTest = new HttpTest();
httpTest.RespondWithJson(new { id = 1, titulo = "Minha tarefa", concluida = false });
var api = new TarefasAPI(new HttpClient(new FakeHttpClientMessageHandler()));
api.CriarTarefa(new Tarefa("Minha tarefa"));
httpTest.ShouldHaveCalled("http://localhost:5000/api/Tarefas")
.WithVerb(HttpMethod.Post)
.WithContentType("application/json")
.WithRequestBody("{\"titulo\":\"Minha tarefa\"}")
.Times(1);
}
public void GetFlavorExtension()
{
using (var httpTest = new HttpTest())
{
Identifier flavorId = Guid.NewGuid();
httpTest.RespondWithJson(new FlavorSummaryCollection
{
new FlavorSummary {
Id = flavorId
}
});
httpTest.RespondWithJson(new Flavor {
Id = flavorId
});
var results = _compute.ListFlavorSummaries();
var flavorRef = results.First();
var result = flavorRef.GetFlavor();
Assert.NotNull(result);
Assert.Equal(flavorId, result.Id);
}
}
public async Task Compact()
{
using (var httpTest = new HttpTest())
{
// Operation response
httpTest.RespondWithJson(new { ok = true });
await _rebels.CompactAsync();
httpTest
.ShouldHaveCalled("http://localhost/rebels/_compact")
.WithVerb(HttpMethod.Post);
}
}
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 GetFirstPageAccidentStatistics_WhenThePageIsLessThanOne()
{
var accidentStatistics = AutoFixture.CreateMany <AccidentStatistic>();
HttpTest.RespondWithJson(accidentStatistics, 200);
var actual = await TransportForLondonClient.GetAccidentStatistics(year : 2016, page : -1, pageSize : 5);
actual.Should().NotBeNull();
actual.Data.Should().NotBeNull();
actual.Total.Should().Be(3);
actual.Page.Should().Be(1);
actual.PageSize.Should().Be(3);
}
public async void GetFirstPageAccidentStatisticsCorrect()
{
var accidentStatistics = AutoFixture.CreateMany <AccidentStatistic>();
HttpTest.RespondWithJson(accidentStatistics, 200);
var actual = await TransportForLondonClient.GetAccidentStatistics(2016, 1, 5);
actual.Should().NotBeNull();
actual.Data.Should().NotBeNull();
actual.Total.Should().Be(3);
actual.Page.Should().Be(1);
actual.PageSize.Should().Be(3);
}
public void GetVncConsole(string typeName)
{
var type = StringEnumeration.FromDisplayName <RemoteConsoleType>(typeName);
using (var httpTest = new HttpTest())
{
Identifier serverId = Guid.NewGuid();
httpTest.RespondWithJson(new Server {
Id = serverId
});
httpTest.RespondWithJson(new RemoteConsole {
Type = type
});
var server = _compute.GetServer(serverId);
var result = server.GetVncConsole(RemoteConsoleType.NoVnc);
httpTest.ShouldHaveCalled($"*/servers/{serverId}/action");
Assert.Contains("os-getVNCConsole", httpTest.CallLog.Last().RequestBody);
Assert.NotNull(result);
Assert.Equal(type, result.Type);
}
}
public void GetVolume()
{
using (var httpTest = new HttpTest())
{
Identifier volumeId = Guid.NewGuid();
Identifier serverId = Guid.NewGuid();
httpTest.RespondWithJson(new Server {
Id = serverId, AttachedVolumes = { new ServerVolumeReference {
Id = volumeId
} }
});
httpTest.RespondWithJson(new ServerVolume {
Id = volumeId, DeviceName = "/dev/vdd"
});
var server = _compute.GetServer(serverId);
var result = server.AttachedVolumes[0].GetServerVolume();
httpTest.ShouldHaveCalled($"*/servers/{serverId}/os-volume_attachments/{volumeId}");
Assert.NotNull(result);
Assert.Equal(volumeId, result.Id);
}
}
public void GetNetwork()
{
using (var httpTest = new HttpTest())
{
Identifier id = Guid.NewGuid();
httpTest.RespondWithJson(new NetworkReference { Id = id });
var result = _rackConnectService.GetNetwork(id);
httpTest.ShouldHaveCalled($"*/cloud_networks/{id}");
Assert.NotNull(result);
Assert.Equal(id, result.Id);
}
}
public void UpdateServerExtension()
{
using (var httpTest = new HttpTest())
{
Identifier serverId = Guid.NewGuid();
httpTest.RespondWithJson(new Server {
Id = serverId, Name = "{old-name}"
});
var lastModified = DateTimeOffset.Now;
httpTest.RespondWithJson(new Server {
Id = serverId, Name = "{new-name}", LastModified = lastModified
});
var server = _compute.GetServer(serverId);
server.Name = "{new-name}";
server.Update();
Assert.Equal(serverId, server.Id);
Assert.Equal("{new-name}", server.Name);
Assert.Equal(lastModified, server.LastModified);
Assert.IsType <ComputeApi>(((IServiceResource)server).Owner);
}
}
public void GetPorts()
{
using (var httpTest = new HttpTest())
{
Identifier portId = Guid.NewGuid();
httpTest.RespondWithJson(new Port { Id = portId });
var port = _cloudNetworkService.GetPort(portId);
httpTest.ShouldHaveCalled("*/ports/" + portId);
Assert.NotNull(port);
Assert.Equal(portId, port.Id);
}
}
public void GetNetwork()
{
using (var httpTest = new HttpTest())
{
Identifier networkId = Guid.NewGuid();
httpTest.RespondWithJson(new Network { Id = networkId });
var network = _cloudNetworkService.GetNetwork(networkId);
httpTest.ShouldHaveCalled("*/networks/" + networkId);
Assert.NotNull(network);
Assert.Equal(networkId, network.Id);
}
}
public void AttachVolume()
{
using (var httpTest = new HttpTest())
{
Identifier volumeId = Guid.NewGuid();
Identifier serverId = Guid.NewGuid();
httpTest.RespondWithJson(new Server {
Id = serverId
});
httpTest.RespondWithJson(new ServerVolume {
Id = volumeId, DeviceName = "/dev/vdd"
});
var server = _compute.GetServer(serverId);
var result = server.AttachVolume(new ServerVolumeDefinition(volumeId));
httpTest.ShouldHaveCalled($"*/servers/{serverId}/os-volume_attachments");
Assert.NotNull(result);
Assert.Equal(volumeId, result.Id);
Assert.True(server.AttachedVolumes.Any(v => v.Id == volumeId));
Assert.IsType <ComputeApi>(((IServiceResource)result).Owner);
}
}
public async Task RetrieveShouldReturnNullForHttp404()
{
using (var httpTest = new HttpTest())
{
httpTest.RespondWithJson(new { }, 404);
var validationClient = new EmailValidationsRestClient(new DummyRestClientFactory());
var validationId = Guid.Parse("a3706a81-87da-4762-a135-dabaac6e6971");
var response = await validationClient.GetAsync(validationId);
Assert.Null(response);
}
}
public async Task Get_Exchange_Mosaic()
{
using (var httpTest = new HttpTest())
{
var fakeJson =
TestHelper.LoadJsonFileToArray(@"Testdata\\Exchange\\GetExchangeMosaic.json");
httpTest.RespondWithJson(fakeJson);
var exchange_mosaic = await _exchangeHttp.GetExchangeMosaic();
exchange_mosaic.Select(i => i.Mosaicid).Should().NotBeNull();
}
}
public async Task can_get_json_dynamic_list()
{
HttpTest.RespondWithJson(new[] {
new { id = 1, name = "Frank" },
new { id = 2, name = "Claire" }
});
var data = await "http://some-api.com".GetJsonListAsync();
Assert.AreEqual(1, data[0].id);
Assert.AreEqual("Frank", data[0].name);
Assert.AreEqual(2, data[1].id);
Assert.AreEqual("Claire", data[1].name);
}
public async Task can_get_error_json_untyped()
{
HttpTest.RespondWithJson(new { code = 999, message = "our server crashed" }, 500);
try {
await "http://api.com".GetStringAsync();
}
catch (FlurlHttpException ex) {
var error = ex.GetResponseJson(); // error is a dynamic this time
Assert.IsNotNull(error);
Assert.AreEqual(999, error.code);
Assert.AreEqual("our server crashed", error.message);
}
}
public async Task CreateOrUpdate()
{
using var httpTest = new HttpTest();
httpTest.RespondWithJson(new { Id = "xxx", Ok = true, Rev = "xxx" });
var r = new Rebel {
Name = "Luke", Id = "1"
};
var newR = await _rebels.AddOrUpdateAsync(r);
httpTest
.ShouldHaveCalled("http://localhost/rebels/1")
.WithVerb(HttpMethod.Put);
}
public async Task GetDivisionsNull()
{
using (var httpTest = new HttpTest())
{
//Arrange
var playerName = "TestingPlayer";
var regionName = "eune";
var player = new SummonerDTO
{
Id = Guid.NewGuid().ToString()
};
var leagueEntryDTOs = new LeagueEntryDTO[0];
var mockMemoryCache = new Mock <IMemoryCache>();
var mockIConfigration = new Mock <IConfiguration>();
mockIConfigration.Setup(c => c[Constants.RIOT_APIKEY]).Returns("RiotApiKey");
var riotApiService = new RiotApiService(mockMemoryCache.Object, mockIConfigration.Object);
httpTest.RespondWithJson(player, 200);
httpTest.RespondWithJson(leagueEntryDTOs, 200);
//Act
var result = await riotApiService.GetDivisions(playerName, regionName);
//Assert
httpTest.ShouldHaveCalled($"https://eun1.api.riotgames.com/lol/summoner/v4/summoners/by-name/{playerName}")
.WithQueryParams("api_key")
.WithVerb(HttpMethod.Get)
.Times(1);
httpTest.ShouldHaveCalled($"https://eun1.api.riotgames.com/lol/league/v4/entries/by-summoner/{player.Id}")
.WithQueryParams("api_key")
.WithVerb(HttpMethod.Get)
.Times(1);
Assert.Equal("Player got no division on any queue", result);
}
}
public async Task Context_Index_NotToOverride()
{
using var httpTest = new HttpTest();
httpTest.RespondWithJson(new
{
Indexes = new []
{
new {
ddoc = Guid.NewGuid().ToString(),
name = "skywalkers",
def = new {
fields = new[] {
new Dictionary <string, string> {
{ "surname", "asc" }
}
}
}
}
}
});
httpTest.RespondWithJson(new
{
docs = new object[] {
new {
Id = "176694",
Rev = "1-54f8e950cc338d2385d9b0cda2fd918e",
Name = "Luke"
}
}
});
await using var context = new MyDeathStarContext();
var result = await context.Rebels.ToListAsync();
Assert.NotEmpty(result);
Assert.Equal("Luke", result[0].Name);
}
public async Task CanLoginOn170(string token, string user, string password)
{
_http.ResponseQueue.Clear();
_http.RespondWithJson(new SystemInfo {
Version = "v1.7.0-rc.0"
});
_http.RespondWith("", cookies: new { sid = token });
await client.Login(user, password);
Assert.Equal(token, client.SessionToken);
_http.ShouldHaveCalled("*/c/login").WithVerb(HttpMethod.Post).WithRequestBody($"principal={user}&password={password}").Times(1);
}
public async Task GetMasteryNull()
{
using (var httpTest = new HttpTest())
{
//Arrange
var playerName = "TestingPlayer";
var regionName = "eune";
var championName = "Unexisting Champion";
var player = new SummonerDTO
{
Id = Guid.NewGuid().ToString()
};
var championDTOs = new ChampionDTO[]
{
new ChampionDTO
{
Name = "Test"
}
};
var memoryCache = new MemoryCache(new MemoryCacheOptions());
var mockIConfigration = new Mock <IConfiguration>();
mockIConfigration.Setup(c => c[Constants.RIOT_APIKEY]).Returns("RiotApiKey");
var riotApiService = new RiotApiService(memoryCache, mockIConfigration.Object);
httpTest.RespondWithJson(player, 200);
httpTest.RespondWithJson(championDTOs, 200);
//Act
await Assert.ThrowsAsync <ChampionNotFoundException>(() => riotApiService.GetMastery(playerName, regionName, championName));
//Assert
httpTest.ShouldHaveCalled($"http://raw.communitydragon.org/latest/plugins/rcp-be-lol-game-data/global/default/v1/champion-summary.json")
.WithVerb(HttpMethod.Get)
.Times(1);
}
}
public void ListNetworks()
{
using (var httpTest = new HttpTest())
{
Identifier id = Guid.NewGuid();
httpTest.RespondWithJson(new[] { new NetworkReference { Id = id } });
var results = _rackConnectService.ListNetworks();
httpTest.ShouldHaveCalled($"*/cloud_networks");
Assert.NotNull(results);
Assert.Equal(1, results.Count());
Assert.Equal(id, results.First().Id);
}
}
public async Task Should_Return_The_Receipt_From_Block()
{
using (var httpTest = new HttpTest())
{
var fakeJson =
TestHelper.LoadJsonFileToObject(@"Testdata\\Block\\GetReceiptFromBlock.json");
httpTest.RespondWithJson(fakeJson);
var receipts = await _blockchainHttp.GetBlockReceipts(2830);
receipts.MosaicResolutionStatements.Should().HaveCountGreaterThan(0);
receipts.TransactionStatement.Should().HaveCountGreaterThan(0);
}
}
public void GetImageMetadata()
{
using (var httpTest = new HttpTest())
{
Identifier imageId = "1";
httpTest.RespondWithJson(new ImageSummaryCollection {
new ImageSummary {
Id = imageId
}
});
httpTest.RespondWithJson(new ImageMetadata {
["stuff"] = "things"
});
var imageReferences = _compute.ListImageSummaries();
ImageMetadata result = imageReferences.First().GetMetadata();
httpTest.ShouldHaveCalled($"*/images/{imageId}/metadata");
Assert.NotNull(result);
Assert.Single(result);
Assert.True(result.ContainsKey("stuff"));
Assert.IsType <ComputeApi>(((IServiceResource)result).Owner);
}
}
public async Task Delete()
{
using var httpTest = new HttpTest();
// Operation response
httpTest.RespondWithJson(new { ok = true });
var r = new Rebel {
Name = "Luke", Id = "1", Rev = "1"
};
await _rebels.RemoveAsync(r);
httpTest
.ShouldHaveCalled("http://localhost/rebels/1?rev=1")
.WithVerb(HttpMethod.Delete);
}
public void ImportKeyPair()
{
using (var httpTest = new HttpTest())
{
const string name = "keypair-name";
httpTest.RespondWithJson(new KeyPairSummary {
Name = name
});
KeyPairSummary result = _computeService.ImportKeyPair(new KeyPairDefinition(name, Guid.NewGuid().ToString()));
httpTest.ShouldHaveCalled("*/os-keypairs");
Assert.NotNull(result);
Assert.Equal(name, result.Name);
}
}
public async Task Get_Transaction_By_Hash_Should_Return_MosaicSupplyChange_Transaction()
{
using (var httpTest = new HttpTest())
{
var fakeJson = TestHelper.LoadJsonFileToObject(@"Testdata\\Transactions\\DecreaseMosaicSupplyTransaction.json");
httpTest.RespondWithJson(fakeJson);
const string transactionHash = "EE59F16783514F00C5B0E6F46E528BDE8170DD27D38C54DB2A82815D1407A52C";
var transaction = await _transactionHttp.GetTransaction(transactionHash);
transaction.Should().BeOfType <MosaicSupplyChangeTransaction>();
}
}
public void DeleteKeyPair(HttpStatusCode responseCode)
{
using (var httpTest = new HttpTest())
{
httpTest.RespondWithJson(new KeyPair {
Name = "keypair-name"
});
httpTest.RespondWith((int)responseCode, "All gone!");
KeyPairSummary result = _computeService.GetKeyPair("keypair-name");
result.Delete();
httpTest.ShouldHaveCalled("*/os-keypairs");
}
}
public void CreateNetwork()
{
using (var httpTest = new HttpTest())
{
Identifier networkId = Guid.NewGuid();
httpTest.RespondWithJson(new Network{Id = networkId});
var definition = new NetworkDefinition();
var network = _cloudNetworkService.CreateNetwork(definition);
httpTest.ShouldHaveCalled("*/networks");
Assert.NotNull(network);
Assert.Equal(networkId, network.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 GetKeyPair()
{
using (var httpTest = new HttpTest())
{
const string name = "keypair-name";
httpTest.RespondWithJson(new KeyPair {
Name = name
});
KeyPair result = _computeService.GetKeyPair(name);
httpTest.ShouldHaveCalled($"*/os-keypairs/{name}");
Assert.NotNull(result);
Assert.Equal(name, result.Name);
}
}
public void Single_Exception()
{
using var httpTest = new HttpTest();
httpTest.RespondWithJson(new
{
Docs = new List <Rebel>
{
new Rebel(),
new Rebel()
}
});
var ex = Assert.Throws <InvalidOperationException>(() => _rebels.Single());
Assert.Equal("Sequence contains more than one element", ex.Message);
}
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 = _cloudNetworkService.CreatePort(definition);
httpTest.ShouldHaveCalled("*/ports");
Assert.NotNull(port);
Assert.Equal(portId, port.Id);
}
}
public void CreatePublicIP()
{
using (var httpTest = new HttpTest())
{
string serverId = Guid.NewGuid().ToString();
Identifier id = Guid.NewGuid();
httpTest.RespondWithJson(new PublicIP { Id = id });
var ipRequest = new PublicIPCreateDefinition {ServerId = serverId};
var result = _rackConnectService.CreatePublicIP(ipRequest);
httpTest.ShouldHaveCalled($"*/public_ips");
Assert.NotNull(result);
Assert.Equal(id, result.Id);
Assert.NotNull(((IServiceResource<RackConnectService>)result).Owner);
}
}
public void WaitUntilActive()
{
using (var httpTest = new HttpTest())
{
Identifier id = Guid.NewGuid();
httpTest.RespondWithJson(new PublicIP {Id = id, Status = PublicIPStatus.Creating});
httpTest.RespondWithJson(new PublicIP {Id = id, Status = PublicIPStatus.Active, PublicIPv4Address = "10.0.0.1"});
var ip = _rackConnectService.GetPublicIP(id);
ip.WaitUntilActive();
Assert.NotNull(ip);
Assert.Equal(id, ip.Id);
Assert.NotNull(ip.PublicIPv4Address);
}
}
public void ListPorts()
{
using (var httpTest = new HttpTest())
{
Identifier portId = Guid.NewGuid();
httpTest.RespondWithJson(new PortCollection {Ports = {new Port {Id = portId}}});
var ports = _cloudNetworkService.ListPorts();
httpTest.ShouldHaveCalled("*/ports");
Assert.NotNull(ports);
Assert.Equal(1, ports.Count());
Assert.Equal(portId, ports.First().Id);
}
}
public void PageNetworks()
{
using (var httpTest = new HttpTest())
{
Identifier networkId = Guid.NewGuid();
httpTest.RespondWithJson(new NetworkCollection
{
Networks = {new Network {Id = networkId}},
NetworksLinks = {new Link("next", "http://api.com/next")}
});
IPage<Network> networks = _cloudNetworkService.ListNetworks(networkId, 10);
httpTest.ShouldHaveCalled(string.Format($"*/networks?marker={networkId}&limit=10"));
Assert.NotNull(networks);
Assert.Equal(1, networks.Count());
Assert.Equal(networkId, networks.First().Id);
Assert.True(networks.HasNextPage);
}
}
public void ListNetworks()
{
using (var httpTest = new HttpTest())
{
Identifier networkId = Guid.NewGuid();
httpTest.RespondWithJson(new NetworkCollection {Networks = {new Network {Id = networkId}}});
var networks = _cloudNetworkService.ListNetworks();
httpTest.ShouldHaveCalled("*/networks");
Assert.NotNull(networks);
Assert.Equal(1, networks.Count());
Assert.Equal(networkId, networks.First().Id);
}
}
public void DeletePublicIP()
{
using (var httpTest = new HttpTest())
{
Identifier id = Guid.NewGuid();
httpTest.RespondWithJson(new PublicIP { Id = id });
_rackConnectService.DeletePublicIP(id);
httpTest.ShouldHaveCalled($"*/public_ips/{id}");
}
}
public void ListPersistentPublicIPs()
{
using (var httpTest = new HttpTest())
{
Identifier id = Guid.NewGuid();
httpTest.RespondWithJson(new[] { new PublicIP { Id = id } });
var results = _rackConnectService.ListPublicIPs(new ListPublicIPsFilter { IsRetained = true });
httpTest.ShouldHaveCalled($"*/public_ips?retain=True");
Assert.NotNull(results);
Assert.Equal(1, results.Count());
Assert.Equal(id, results.First().Id);
}
}
public void ListPublicIPs()
{
using (var httpTest = new HttpTest())
{
Identifier id = Guid.NewGuid();
httpTest.RespondWithJson(new[] {new PublicIP {Id = id}});
var results = _rackConnectService.ListPublicIPs();
httpTest.ShouldHaveCalled($"*/public_ips");
Assert.NotNull(results);
Assert.Equal(1, results.Count());
Assert.Equal(id, results.First().Id);
Assert.All(results.OfType<IServiceResource<RackConnectService>>(), ip => Assert.NotNull(ip.Owner));
}
}
public void ListPublicIPsForServer()
{
using (var httpTest = new HttpTest())
{
string serverId = Guid.NewGuid().ToString();
Identifier id = Guid.NewGuid();
httpTest.RespondWithJson(new[] {new PublicIP {Id = id}});
var results = _rackConnectService.ListPublicIPs(new ListPublicIPsFilter {ServerId = serverId});
httpTest.ShouldHaveCalled($"*/public_ips?cloud_server_id={serverId}");
Assert.NotNull(results);
Assert.Equal(1, results.Count());
Assert.Equal(id, results.First().Id);
}
}
public void UpdatePublicIP()
{
using (var httpTest = new HttpTest())
{
Identifier id = Guid.NewGuid();
httpTest.RespondWithJson(new PublicIP { Id = id });
var result = _rackConnectService.UpdatePublicIP(id, new PublicIPUpdateDefinition());
httpTest.ShouldHaveCalled($"*/public_ips/{id}");
Assert.NotNull(result);
Assert.Equal(id, result.Id);
Assert.NotNull(((IServiceResource<RackConnectService>)result).Owner);
}
}
public void WaitUntilActive_ThrowsException_WhenAddFails()
{
using (var httpTest = new HttpTest())
{
Identifier id = Guid.NewGuid();
httpTest.RespondWithJson(new PublicIP { Id = id, Status = PublicIPStatus.Creating });
httpTest.RespondWithJson(new PublicIP { Id = id, Status = PublicIPStatus.CreateFailed, StatusDetails = "No IP for you!"});
var ip = _rackConnectService.GetPublicIP(id);
Assert.Throws<ServiceOperationFailedException>(() => ip.WaitUntilActive());
}
}
public void WaitUntilDeleted_AcceptsNotFoundExceptionAsSuccess()
{
using (var httpTest = new HttpTest())
{
Identifier id = Guid.NewGuid();
httpTest.RespondWithJson(new PublicIP { Id = id, Status = PublicIPStatus.Active });
httpTest.RespondWith((int) HttpStatusCode.NoContent, "All gone!");
httpTest.RespondWith((int) HttpStatusCode.NotFound, "Not here, boss!");
var ip = _rackConnectService.GetPublicIP(id);
ip.Delete();
ip.WaitUntilDeleted();
}
}
public void WaitUntilDeleted_ThrowsException_WhenDeleteFails()
{
using (var httpTest = new HttpTest())
{
Identifier id = Guid.NewGuid();
httpTest.RespondWithJson(new PublicIP { Id = id, Status = PublicIPStatus.Active });
httpTest.RespondWithJson(new PublicIP { Id = id, Status = PublicIPStatus.Active });
httpTest.RespondWith(JObject.Parse(@"{'status':'REMOVE_FAILED'}").ToString());
var ip = _rackConnectService.GetPublicIP(id);
ip.Delete();
Assert.Throws<ServiceOperationFailedException>(() =>ip.WaitUntilDeleted());
}
}
public void CreatePublicIP_RetriesWhenTheServerIsNotFound()
{
using (var httpTest = new HttpTest())
{
string serverId = Guid.NewGuid().ToString();
Identifier id = Guid.NewGuid();
httpTest.RespondWith((int)HttpStatusCode.Conflict, $"Cloud Server {serverId} does not exist");
httpTest.RespondWithJson(new PublicIP { Id = id });
var ipRequest = new PublicIPCreateDefinition { ServerId = serverId };
var result = _rackConnectService.CreatePublicIP(ipRequest);
httpTest.ShouldHaveCalled($"*/public_ips");
Assert.NotNull(result);
Assert.Equal(id, result.Id);
Assert.NotNull(((IServiceResource<RackConnectService>)result).Owner);
}
}
public void PagePorts()
{
using (var httpTest = new HttpTest())
{
Identifier portId = Guid.NewGuid();
httpTest.RespondWithJson(new PortCollection
{
Ports = { new Port { Id = portId } },
PortsLinks = { new Link("next", "http://api.com/next") }
});
IPage<Port> ports = _cloudNetworkService.ListPorts(portId, 10);
httpTest.ShouldHaveCalled(string.Format($"*/ports?marker={portId}&limit=10"));
Assert.NotNull(ports);
Assert.Equal(1, ports.Count());
Assert.Equal(portId, ports.First().Id);
Assert.True(ports.HasNextPage);
}
}
public void UpdatePort()
{
using (var httpTest = new HttpTest())
{
Identifier portId = Guid.NewGuid();
httpTest.RespondWithJson(new Port { Id = portId });
var definition = new PortUpdateDefinition { Name = "new subnet name" };
var port = _cloudNetworkService.UpdatePort(portId, definition);
httpTest.ShouldHaveCalled("*/ports/" + portId);
Assert.NotNull(port);
Assert.Equal(portId, port.Id);
}
}
