public void DeleteNetwork()
{
using (var httpTest = new HttpTest())
{
Identifier networkId = Guid.NewGuid();
httpTest.RespondWith((int)HttpStatusCode.NoContent, "All gone!");
_cloudNetworkService.DeleteNetwork(networkId);
httpTest.ShouldHaveCalled("*/networks/" + networkId);
}
}
public async Task UserAgentTest()
{
using (var httpTest = new HttpTest())
{
RackspaceNet.Configure();
await "http://api.com".GetAsync();
var userAgent = httpTest.CallLog[0].Request.Headers.UserAgent.ToString();
Assert.Contains("rackspace.net", userAgent);
Assert.Contains("openstack.net", userAgent);
}
}
public async void UserAgentWithApplicationSuffixTest()
{
using (var httpTest = new HttpTest())
{
RackspaceNet.Configure(configure: options => options.UserAgents.Add(new ProductInfoHeaderValue("(unit-tests)")));
await "http://api.com".GetAsync();
var userAgent = httpTest.CallLog[0].Request.Headers.UserAgent.ToString();
Assert.Contains("rackspace.net", userAgent);
Assert.Contains("unit-tests", userAgent);
}
}
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 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 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 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 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 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 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 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 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 async Task UseBothOpenStackAndRackspace_RackspaceConfiguredFirst()
{
using (var httpTest = new HttpTest())
{
RackspaceNet.Configure();
OpenStackNet.Configure();
await "http://api.com".GetAsync();
var userAgent = httpTest.CallLog[0].Request.Headers.UserAgent.ToString();
var rackspaceMatches = new Regex("rackspace").Matches(userAgent);
Assert.Equal(1, rackspaceMatches.Count);
var openstackMatches = new Regex("openstack").Matches(userAgent);
Assert.Equal(1, openstackMatches.Count);
}
}
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 async Task CheckIfPayerIsActiveSendsProperRequest()
{
using (var httpTest = new HttpTest())
{
httpTest.RespondWithJson(new
{
access_token = Settings.AccessToken,
expires_in = 3600,
token_type = "access_token"
})
.RespondWithJson(new { result = true });
var config = new MomoConfig
{
UserId = Settings.UserId,
UserSecret = Settings.UserSecretKey,
SubscriptionKey = Settings.SubscriptionKey
};
var disbursements = new DisbursementsClient(config);
var result = await disbursements.IsAccountHolderActive(new Party("0777000000", PartyIdType.Msisdn));
httpTest.ShouldHaveCalled(Settings.BaseUri.AppendPathSegment(TokenPath))
.WithVerb(HttpMethod.Post);
httpTest.ShouldHaveCalled(
Settings.BaseUri.AppendPathSegment($"/disbursement/v1_0/accountholder/msisdn/0777000000/active"))
.WithVerb(HttpMethod.Get)
.WithHeader("Authorization", $"Bearer {Settings.AccessToken}")
.WithHeader("Ocp-Apim-Subscription-Key", Settings.SubscriptionKey)
.WithHeader("X-Target-Environment", "sandbox");
Assert.True(result);
}
}
public void Test_Some_Http_Calling_Method()
{
using (var httpTest = new HttpTest())
{
httpTest.ShouldHaveCalled("")
.WithOAuthBearerToken("")
.Times(1);
}
using (var httpTest = new HttpTest())
{
// Arrange.
httpTest.RespondWith("OK", 200);
// Act.
// await CreateTodoAsync();
// Assert.
httpTest.ShouldHaveCalled("api/todos*")
.WithVerb(HttpMethod.Post)
.WithContentType("application/json");
}
}
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.Contains("createImage", httpTest.CallLog.First(x => x.Url.EndsWith("/action")).RequestBody);
Assert.NotNull(result);
Assert.Equal(imageId, result.Id);
}
}
public async Task can_allow_redirect_secure_to_insecure(bool allow)
{
HttpTest
.RespondWith("", 301, new { Location = "http://insecure.com/next" })
.RespondWith("done!");
var fc = new FlurlClient();
if (allow) // test that false is default (don't set explicitly)
{
fc.Settings.Redirects.AllowSecureToInsecure = true;
}
await fc.Request("https://secure.com").GetAsync();
if (allow)
{
HttpTest.ShouldHaveCalled("http://insecure.com/next");
}
else
{
HttpTest.ShouldNotHaveCalled("http://insecure.com/next");
}
}
public async Task can_auto_redirect()
{
HttpTest
.RespondWith("", 302, new { Location = "http://redir.com/foo" })
.RespondWith("", 302, new { Location = "/redir2" })
.RespondWith("", 302, new { Location = "redir3?x=1&y=2#foo" })
.RespondWith("", 302, new { Location = "//otherredir.com/bar/?a=b" })
.RespondWith("done!");
var resp = await "http://start.com".PostStringAsync("foo!").ReceiveString();
Assert.AreEqual("done!", resp);
HttpTest.ShouldHaveMadeACall().Times(5);
HttpTest.ShouldHaveCalled("http://start.com").WithVerb(HttpMethod.Post).WithRequestBody("foo!")
.With(call => call.RedirectedFrom == null);
HttpTest.ShouldHaveCalled("http://redir.com/foo").WithVerb(HttpMethod.Get).WithRequestBody("")
.With(call => call.RedirectedFrom.Request.Url.ToString() == "http://start.com");
HttpTest.ShouldHaveCalled("http://redir.com/redir2").WithVerb(HttpMethod.Get).WithRequestBody("")
.With(call => call.RedirectedFrom.Request.Url.ToString() == "http://redir.com/foo");
HttpTest.ShouldHaveCalled("http://redir.com/redir2/redir3?x=1&y=2#foo").WithVerb(HttpMethod.Get).WithRequestBody("")
.With(call => call.RedirectedFrom.Request.Url.ToString() == "http://redir.com/redir2");
HttpTest.ShouldHaveCalled("http://otherredir.com/bar/?a=b#foo").WithVerb(HttpMethod.Get).WithRequestBody("")
.With(call => call.RedirectedFrom.Request.Url.ToString() == "http://redir.com/redir2/redir3?x=1&y=2#foo");
}
public void GetServerMetadata()
{
using (var httpTest = new HttpTest())
{
Identifier serverId = "1";
httpTest.RespondWithJson(new ServerSummaryCollection {
new ServerSummary {
Id = serverId
}
});
httpTest.RespondWithJson(new ServerMetadata {
["stuff"] = "things"
});
var servers = _compute.ListServerSummaries();
ServerMetadata result = servers.First().GetMetadata();
httpTest.ShouldHaveCalled($"*/servers/{serverId}/metadata");
Assert.NotNull(result);
Assert.Equal(1, result.Count);
Assert.True(result.ContainsKey("stuff"));
Assert.IsType <ComputeApi>(((IServiceResource)result).Owner);
}
}
public async Task GetSchools_SiteIsAvailable_ReturnsSchools()
{
var timeout = TimeSpan.FromSeconds(5);
var service = new SchoolsParser(timeout);
using (var httpTest = new HttpTest())
{
httpTest.RespondWith(await File.ReadAllTextAsync("TestData/Parsers/schools.html"));
var result = await service.GetSchools();
var first = result.First();
httpTest.ShouldHaveCalled(Constants.EndPoint)
.WithVerb(HttpMethod.Get)
.Times(1);
result.Should().NotBeEmpty().And
.HaveCount(13);
first.Id.Should().Be(15);
first.Name.Should().Be("Высшая инженерная школа");
first.Url.Should().Be("https://ruz.narfu.ru/?groups&institution=15");
}
}
public void TestReadPropertyMultipleOneIdOneAttribute()
{
using (var httpTest = new HttpTest())
{
httpTest.RespondWithJson(new { accessToken = "faketoken", expires = "2030-01-01T00:00:00Z" });
traditionalClient.TryLogin("username", "password");
httpTest.RespondWith("{ \"item\": { \"" + mockAttributeName + "\": \"stringvalue\" } }");
List <Guid> ids = new List <Guid>()
{
mockid
};
List <string> attributes = new List <string>()
{
mockAttributeName
};
IEnumerable <Variant> results = traditionalClient.ReadPropertyMultiple(ids, attributes);
httpTest.ShouldHaveCalled($"https://hostname/api/V2/objects/{mockid}")
.WithVerb(HttpMethod.Get)
.Times(1);
Assert.AreEqual(1, results.Count());
}
}
public void MasMultipleMarketDataWindow()
{
using (var httpTest = new HttpTest())
{
var qs = new QueryService(_cfg);
var mas = qs.CreateMarketAssessment()
.ForMarketData(new int[] { 100000001, 100000002, 100000003 })
.ForProducts(new string[] { "M+1", "GY+1" })
.InRelativePeriodRange(Period.FromWeeks(2), Period.FromDays(20))
.ExecuteAsync().Result;
httpTest.ShouldHaveCalled($"{_cfg.BaseAddress}query/v1.0/mas/P2W/P20D"
.SetQueryParam("id", new int[] { 100000001, 100000002, 100000003 })
.SetQueryParam("p", new string[] { "M+1", "GY+1" }))
.WithVerb(HttpMethod.Get)
.Times(1);
}
using (var httpTest = new HttpTest())
{
var qs = new QueryService(_cfg);
var mas = qs.CreateMarketAssessment()
.ForMarketData(new int[] { 100000001, 100000002, 100000003 })
.ForProducts(new string[] { "M+1", "GY+1" })
.InRelativePeriodRange(Period.FromWeeks(2), Period.FromMonths(6))
.ExecuteAsync().Result;
httpTest.ShouldHaveCalled($"{_cfg.BaseAddress}query/v1.0/mas/P2W/P6M"
.SetQueryParam("id", new int[] { 100000001, 100000002, 100000003 })
.SetQueryParam("p", new string[] { "M+1", "GY+1" }))
.WithVerb(HttpMethod.Get)
.Times(1);
}
}
public async Task GetDetailedViewQueryAsync()
{
// Arrange
using var httpTest = new HttpTest();
SetupViewQueryResponse(httpTest);
var options = new CouchViewOptions <string[]>
{
Key = new[] { "Luke", "Skywalker" },
Skip = 10
};
var queries = new[]
{
options,
options
};
// Act
var results = await _rebels.GetDetailedViewQueryAsync <string[], RebelView>("jedi", "by_name", queries);
// Assert
Assert.Equal(2, results.Length);
Assert.All(results, result =>
{
Assert.Equal(10, result.Offset);
Assert.Equal(20, result.TotalRows);
var rebel = Assert.Single(result.Rows);
Assert.Equal("luke", rebel.Id);
Assert.Equal(new[] { "Luke", "Skywalker" }, rebel.Key);
Assert.Equal(3, rebel.Value.NumberOfBattles);
});
httpTest
.ShouldHaveCalled("http://localhost/rebels/_design/jedi/_view/by_name/queries")
.WithVerb(HttpMethod.Post)
.WithRequestBody(@"{""queries"":[{""key"":[""Luke"",""Skywalker""],""skip"":10},{""key"":[""Luke"",""Skywalker""],""skip"":10}]}");
}
public async Task ExpectedValue_ShouldCallTheCorrectUrlByAwaitingImmediately()
{
using (var http = new HttpTest())
{
http.RespondWithJson(Fixtures.CompareAndDelete.DefaultResponse)
.RespondWithJson(Fixtures.CompareAndDelete.DefaultResponse);
var req = Etcd.ClientFor(Fixtures.EtcdUrl.ToUri())
.Atomic.CompareAndDelete(Fixtures.CompareAndDelete.Path)
.WithExpectedValue(Fixtures.CompareAndDelete.ExpectedValue);
await req;
await req.Execute();
http.Should()
.HaveCalled(
Fixtures.EtcdUrl
.AppendPathSegments(Constants.Etcd.Path_Keys, Fixtures.CompareAndDelete.Path)
.SetQueryParam(Constants.Etcd.Parameter_PrevValue, Fixtures.CompareAndDelete.ExpectedValue)
)
.WithVerb(HttpMethod.Delete)
.Times(2);
}
}
public void TestReadPropertyObjectWithReliabilityPriorityStringNoValueField()
{
using (var httpTest = new HttpTest())
{
httpTest.RespondWithJson(new { accessToken = "faketoken", expires = "2030-01-01T00:00:00Z" });
traditionalClient.TryLogin("username", "password");
httpTest.RespondWith("{ \"item\": { \"" + mockAttributeName + "\": { " +
"\"property\": \"stringvalue\", \"property2\": \"stringvalue2\", " +
"\"reliability\": \"reliabilityEnumSet.noInput\", \"priority\": \"writePriorityEnumSet.priorityDefault\"} } }");
Variant result = traditionalClient.ReadProperty(mockid, mockAttributeName);
httpTest.ShouldHaveCalled($"https://hostname/api/V2/objects/{mockid}/attributes/{mockAttributeName}")
.WithVerb(HttpMethod.Get)
.Times(1);
Assert.AreEqual(1, result.NumericValue);
Assert.AreEqual("Unsupported Data Type", result.StringValue);
Assert.AreEqual(false, result.BooleanValue);
Assert.AreEqual(null, result.ArrayValue);
Assert.AreEqual(null, result.Priority);
Assert.AreEqual("reliabilityEnumSet.reliable", result.Reliability);
Assert.AreEqual(true, result.IsReliable);
}
}
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 async Task Context_CreateIndex_Test()
{
using var httpTest = new HttpTest();
httpTest.RespondWithJson(new
{
Id = "176694",
Ok = true,
Rev = "1-54f8e950cc338d2385d9b0cda2fd918e"
});
await using var context = new MyDeathStarContext();
await context.Rebels.IndexProvider.CreateAsync(index =>
{
index.IndexName = "test-index";
index.Fields = x => new { x.Name, x.Age };
});
var call = httpTest.CallLog.First();
Assert.NotNull(call);
Assert.Equal(@"{""name"":""test-index"",""index"":{""fields"":[""Name"",""Age""]},""type"":""json""}", call.RequestBody);
}
public async Task FetchPlayerIdPlayerNotFound()
{
using (var httpTest = new HttpTest())
{
//Arrange
var playerName = "TestingPlayer";
var regionName = "eune";
var player = new SummonerDTO();
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, 404);
//Act
await Assert.ThrowsAsync <PlayerNotFoundException>(() => riotApiService.FetchPlayerId(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);
}
}
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 can_set_error_callback(bool markExceptionHandled)
{
var callbackCalled = false;
using (var test = new HttpTest()) {
test.RespondWith("server error", 500);
GetSettings().OnError = call => {
Assert.NotNull(call.Response); // verifies that callback is running after HTTP call is made
callbackCalled = true;
call.ExceptionHandled = markExceptionHandled;
};
Assert.IsFalse(callbackCalled);
try {
await GetRequest().GetAsync();
Assert.IsTrue(callbackCalled, "OnError was never called");
Assert.IsTrue(markExceptionHandled, "ExceptionHandled was marked false in callback, but exception was not propagated.");
}
catch (FlurlHttpException) {
Assert.IsTrue(callbackCalled, "OnError was never called");
Assert.IsFalse(markExceptionHandled, "ExceptionHandled was marked true in callback, but exception was propagated.");
}
}
}
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 async Task Search_Metadata()
{
using (var httpTest = new HttpTest())
{
var fakeJson =
TestHelper.LoadJsonFileToObject(@"Testdata\\Metadata\\GetMetadataInfoByMetadataSearch.json");
httpTest.RespondWithJson(fakeJson);
var address = "VBSI675LOU33SWOVGLSSCQLAKL2QRGJA5AZOFU6N";
var targetKey = "359BAB30BF217A592372FADBE1F39C36C7717AC58A592324826A8E50B6829C69";
var metadataInfo = await _metadataHttp.SearchMetadata(new MetadataQueryParams(1, Order.ASC, 1, Address.CreateFromRawAddress(address), null, targetKey, null));
metadataInfo.Entries.Should().NotBeEmpty();
// metadataInfo.Fields.Should().HaveCount(2);
// metadataInfo.Type.Should().BeEquivalentTo(MetadataType.MOSAIC);
metadataInfo.Entries.Single(ap => ap.ValueSize == 1);
metadataInfo.Entries.Single(ap => ap.Value == "74657374");
metadataInfo.Entries.Single(ap => ap.TargetKey == "359BAB30BF217A592372FADBE1F39C36C7717AC58A592324826A8E50B6829C69");
metadataInfo.Paginations.PageNumber.Equals(1);
metadataInfo.Paginations.PageSize.Equals(1);
}
}
public void ReadTimeTransformBaseWithTimeTransformID()
{
using (var httpTest = new HttpTest())
{
var mds = new MetadataService(_cfg);
var mdq = mds.ReadTimeTransformBaseAsync(1).ConfigureAwait(true).GetAwaiter().GetResult();
httpTest.ShouldHaveCalled($"{_cfg.BaseAddress}v2.1/timeTransform/entity/1")
.WithVerb(HttpMethod.Get)
.Times(1);
}
using (var httpTest = new HttpTest())
{
var mds = new MetadataService(_cfg);
var mdq = mds.ReadTimeTransformBaseAsync(2).ConfigureAwait(true).GetAwaiter().GetResult();
httpTest.ShouldHaveCalled($"{_cfg.BaseAddress}v2.1/timeTransform/entity/2")
.WithVerb(HttpMethod.Get)
.Times(1);
}
}
public async Task can_setup_multiple_responses()
{
HttpTest
.RespondWith("one")
.RespondWith("two")
.RespondWith("three");
HttpTest.ShouldNotHaveMadeACall();
await "http://www.api.com/1".GetAsync();
await "http://www.api.com/2".GetAsync();
await "http://www.api.com/3".GetAsync();
var calls = HttpTest.CallLog;
Assert.AreEqual(3, calls.Count);
Assert.AreEqual("one", await calls[0].Response.Content.ReadAsStringAsync());
Assert.AreEqual("two", await calls[1].Response.Content.ReadAsStringAsync());
Assert.AreEqual("three", await calls[2].Response.Content.ReadAsStringAsync());
HttpTest.ShouldHaveMadeACall();
HttpTest.ShouldHaveCalled("http://www.api.com/*").WithVerb(HttpMethod.Get).Times(3);
HttpTest.ShouldNotHaveCalled("http://www.otherapi.com/*");
}
public async Task GetDetailListUrlShouldReturnAnAbilityList()
{
var faker = new Faker();
var fakeUrl = faker.Internet.Url();
var fakeUrlList = new List <string>()
{
fakeUrl
};
var fakeAbility = AutoFaker.Generate <Ability>();
var fakeAbilityList = new List <Ability>()
{
fakeAbility
};
using var httpTest = new HttpTest();
httpTest.ForCallsTo(fakeUrl)
.WithVerb(HttpMethod.Get)
.RespondWithJson(fakeAbility);
var result = await _resourceService.GetDetailListAsync <Ability>(fakeUrlList);
result.Should().BeEquivalentTo(fakeAbilityList);
}
public async Task FindAsync_Exception_ReturnsFailure()
{
// arrange
const string CARD_NAME = "cardname1";
_mockRateLimit.Setup(x => x.IsTurnedOn).Returns(false);
_mockHeaderManager.Setup(x => x.Update(It.IsAny <IReadOnlyNameValueList <string> >()));
var cardDto = new CardDto()
{
Name = CARD_NAME
};
var rootCardList = new RootCardDto()
{
Card = cardDto,
};
_mockModelMapper.Setup(x => x.MapCard(It.IsAny <CardDto>())).Throws(new Exception());
using var httpTest = new HttpTest();
httpTest.RespondWithJson(rootCardList);
var service = new CardService(
_mockHeaderManager.Object,
_mockModelMapper.Object,
ApiVersion.V1,
_mockRateLimit.Object);
// act
var result = await service.FindAsync("12345");
// assert
Assert.False(result.IsSuccess);
_mockRepository.VerifyAll();
}
public void AuctWithTimeZone_FilterId()
{
using (var httpTest = new HttpTest())
{
var qs = new QueryService(_cfg);
var act = qs.CreateAuction()
.ForFilterId(1)
.InAbsoluteDateRange(new LocalDate(2018, 1, 1), new LocalDate(2018, 1, 10))
.InTimezone("UTC")
.ExecuteAsync().Result;
httpTest.ShouldHaveCalledPath($"{_cfg.BaseAddress}query/v1.0/auction/2018-01-01/2018-01-10")
.WithVerb(HttpMethod.Get)
.WithQueryParam("filterId", 1)
.WithQueryParam("tz", "UTC")
.Times(1);
}
using (var httpTest = new HttpTest())
{
var qs = new QueryService(_cfg);
var act = qs.CreateAuction()
.ForFilterId(1)
.InAbsoluteDateRange(new LocalDate(2018, 1, 1), new LocalDate(2018, 1, 10))
.InTimezone("WET")
.ExecuteAsync().Result;
httpTest.ShouldHaveCalledPath($"{_cfg.BaseAddress}query/v1.0/auction/2018-01-01/2018-01-10")
.WithVerb(HttpMethod.Get)
.WithQueryParam("filterId", 1)
.WithQueryParam("tz", "WET")
.Times(1);
}
}
public async Task Upsert_ShouldUsedPassedValueConverter()
{
var dto = Fixtures.Dto.SimpleDataContract();
var converter = new XmlValueConverter();
var expected = converter.Write(dto);
using (var http = new HttpTest())
{
http.RespondWithJson(Fixtures.Key.DefaultResponse);
await Etcd.ClientFor(Fixtures.EtcdUrl.ToUri())
.UpsertKey(Fixtures.Key.Path)
.WithValue(dto, converter);
http.Should()
.HaveCalled(
Fixtures.EtcdUrl
.AppendPathSegments(Constants.Etcd.Path_Keys, Fixtures.Key.Path)
)
.WithVerb(HttpMethod.Put)
.WithRequestBody(Fixtures.Key.DefaultRequest(expected))
.Times(1);
}
}
public async Task Get_ShouldUsePassedValueConverter()
{
var dto = Fixtures.Dto.SimpleDataContract();
var converter = new XmlValueConverter();
var expected = converter.Write(dto);
using (var http = new HttpTest())
{
http.RespondWithJson(Fixtures.Key.UpsertResponse(Fixtures.Key.Path, expected));
var response = await Etcd.ClientFor(Fixtures.EtcdUrl.ToUri())
.GetKey(Fixtures.Key.Path);
http.Should()
.HaveCalled(
Fixtures.EtcdUrl
.AppendPathSegments(Constants.Etcd.Path_Keys, Fixtures.Key.Path)
)
.WithVerb(HttpMethod.Get)
.Times(1);
response.Should().NotBeNull();
response.Data.Should().NotBeNull();
response.Data.RawValue.Should().NotBeNullOrWhiteSpace();
response.Data.RawValue.Should().Be(expected);
SimpleDataContractDto responseDto = null;
Action getValue = () => responseDto = response.Data.GetValue <SimpleDataContractDto>(converter);
getValue.ShouldNotThrow();
responseDto.Should().NotBeNull();
responseDto.Id.Should().Be(dto.Id);
responseDto.Name.Should().Be(dto.Name);
}
}
public async Task EbayRestClient_ShouldCorrectlyAdd_AuthTokenToRequest()
{
var moqAuth = Substitute.For <IOAuth2Authenticator>();
moqAuth.GetTokenAsync().Returns(new Token
{
AccessToken = "randomtoken"
});
var restClient = new EbayRestClient
{
OAuth2Authenticator = moqAuth
};
IFlurlRequest flurl = "/some/path"
.AppendPathSegment($"to", fullyEncode: true)
.AppendPathSegment($"ebay", fullyEncode: true)
.WithHeader("header", "value")
.WithHeaders(
new
{
Content_Type = "application/json",
}, replaceUnderscoreWithHyphen: true);
using (var httpTest = new HttpTest())
{
var response = await restClient.Request <object>(flurl);
httpTest
.ShouldHaveCalled("https://api.ebay.com/some/path/to/ebay")
.WithContentType("application/json")
.WithHeader("Authorization", "Bearer randomtoken")
.WithHeader("header", "value")
.Times(1);
}
}
public async Task Cookie()
{
var token = "cm9vdDo1MEJCRkYwMjq0LO0ylOIwShrgt8y-UkhI-c6BGw";
using var httpTest = new HttpTest();
// Cookie response
var cookieResponse = new HttpResponseMessage();
cookieResponse.Headers.Add("Content-Typ", "application/json");
cookieResponse.Headers.Add("Set-Cookie", $"AuthSession={token}; Version=1; Path=/; HttpOnly");
cookieResponse.Content = new StringContent("{}");
httpTest.ResponseQueue.Enqueue(cookieResponse);
SetupListResponse(httpTest);
await using var client = new CouchClient("http://localhost", s => s.UseCookieAuthentication("root", "relax"));
var rebels = client.GetDatabase <Rebel>();
var all = await rebels.ToListAsync();
var authCookie = httpTest.CallLog
.Single(c => c.Request.RequestUri.ToString().Contains("_session"))
.FlurlRequest.Cookies.Single(c => c.Key == "AuthSession").Value;
Assert.Equal(token, authCookie.Value);
}
public async Task CallWebServiceGet_RateLimitOn_Success()
{
// arrange
var URL = new Uri("http://fake/url");
_mockRateLimit.Setup(x => x.IsTurnedOn).Returns(true);
_mockRateLimit.Setup(x => x.Delay(2000)).ReturnsAsync(1);
_mockRateLimit.Setup(x => x.AddApiCall());
var card = new CardDto()
{
Id = "12345"
};
var rootCard = new RootCardDto()
{
Card = card,
};
using var httpTest = new HttpTest();
httpTest.RespondWithJson(rootCard);
_mockHeaderManager.Setup(x => x.Update(It.IsAny <IReadOnlyNameValueList <string> >()));
_mockHeaderManager.Setup(x => x.Get <int>(ResponseHeader.RatelimitLimit)).Returns(2000);
var service = new ServiceBaseTestObject(
_mockHeaderManager.Object,
_mockModelMapper.Object,
_mockRateLimit.Object);
// act
var result = await service.CallWebServiceGetTestMethod(URL);
// assert
Assert.Equal(card.Id, result.Card.Id);
_mockRepository.VerifyAll();
}
public async Task GetChangesAsync_WithIdsFilter()
{
using var httpTest = new HttpTest();
// Arrange
SetFeedResponse(httpTest);
httpTest.RespondWithJson(new { ok = true });
var docId = Guid.NewGuid().ToString();
var filter = ChangesFeedFilter.DocumentIds(new[]
{
docId
});
// Act
var newR = await _rebels.GetChangesAsync(null, filter);
// Assert
httpTest
.ShouldHaveCalled("http://localhost/rebels/_changes")
.WithQueryParamValue("filter", "_doc_ids")
.WithJsonBody <ChangesFeedFilterDocuments>(f => f.DocumentIds.Contains(docId))
.WithVerb(HttpMethod.Post);
}
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);
}
}
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 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 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 WhenDeleteNetwork_Returns404NotFound_ShouldConsiderRequestSuccessful()
{
using (var httpTest = new HttpTest())
{
Identifier networkId = Guid.NewGuid();
httpTest.RespondWith((int)HttpStatusCode.NotFound, "Not here, boss...");
_cloudNetworkService.DeleteNetwork(networkId);
httpTest.ShouldHaveCalled("*/networks/" + networkId);
}
}
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 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 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()
{
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 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 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 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 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);
}
}
