public async Task ShouldCallTheCorrectUrlByAwaitingImmediately()
{
using (var http = new HttpTest())
{
http.RespondWithJson(Fixtures.Cluster.CreateResponse(Fixtures.EtcdUrl.ToUri()));
var member = await Etcd.ClientFor(Fixtures.EtcdUrl.ToUri())
.Cluster
.CreateMember()
.WithPeerUri(Fixtures.EtcdUrl.ToUri());
http.Should()
.HaveCalled(
Fixtures.EtcdUrl
.AppendPathSegment(Constants.Etcd.Path_Members)
)
.WithVerb(HttpMethod.Post)
.WithContentType(Constants.Http.ContentType_ApplicationJson)
.Times(1);
member.Should().NotBeNull();
member.PeerUrls.Should()
.NotBeEmpty()
.And
.ContainSingle(x => Fixtures.EtcdUrl.ToUri().Equals(x));
}
}
public async Task ShouldCallTheCorrectUrlByAwaitingImmediately()
{
using (var http = new HttpTest())
{
http.RespondWithJson(
Fixtures.Cluster.ClusterMembersResponse(
Fixtures.Cluster.ClusterMemberResponse(),
Fixtures.Cluster.ClusterMemberResponse(),
Fixtures.Cluster.ClusterMemberResponse(),
Fixtures.Cluster.ClusterMemberResponse(),
Fixtures.Cluster.ClusterMemberResponse()
));
var members = await Etcd.ClientFor(Fixtures.EtcdUrl.ToUri())
.Cluster
.GetMembers();
http.Should()
.HaveCalled(
Fixtures.EtcdUrl
.AppendPathSegment(Constants.Etcd.Path_Members)
)
.WithVerb(HttpMethod.Get)
.Times(1);
members.Should().NotBeNull()
.And
.HaveCount(5);
}
}
public async Task ShouldCallTheCorrectUrlByAwaitingImmediately()
{
using (var http = new HttpTest())
{
http.RespondWithJson(Fixtures.Cluster.ClusterMemberResponse(new[] {Fixtures.EtcdUrl.ToUri()}, new[] {Fixtures.EtcdUrl.ToUri()}));
var leader = await Etcd.ClientFor(Fixtures.EtcdUrl.ToUri())
.Cluster
.GetLeader();
http.Should()
.HaveCalled(
Fixtures.EtcdUrl
.AppendPathSegment(Constants.Etcd.Path_Members_Leader)
)
.WithVerb(HttpMethod.Get)
.Times(1);
leader.Should().NotBeNull();
leader.PeerUrls.Should()
.NotBeEmpty()
.And
.ContainSingle(x => Fixtures.EtcdUrl.ToUri().Equals(x));
leader.ClientUrls.Should()
.NotBeEmpty()
.And
.ContainSingle(x => Fixtures.EtcdUrl.ToUri().Equals(x));
}
}
public async Task ExpectedValue_ShouldCallTheCorrectUrlByAwaitingImmediately()
{
using (var http = new HttpTest())
{
http.RespondWithJson(Fixtures.CompareAndSwap.DefaultResponse)
.RespondWithJson(Fixtures.CompareAndSwap.DefaultResponse);
var req = Etcd.ClientFor(Fixtures.EtcdUrl.ToUri())
.Atomic.CompareAndSwap(Fixtures.CompareAndSwap.Path)
.WithExpectedValue(Fixtures.CompareAndSwap.ExpectedValue)
.WithNewValue(Fixtures.CompareAndSwap.NewValue);
await req;
await req.Execute();
http.Should()
.HaveCalled(
Fixtures.EtcdUrl
.AppendPathSegments(Constants.Etcd.Path_Keys, Fixtures.CompareAndSwap.Path)
.SetQueryParam(Constants.Etcd.Parameter_PrevValue, Fixtures.CompareAndSwap.ExpectedValue)
)
.WithVerb(HttpMethod.Put)
.WithRequestBody(Fixtures.CompareAndSwap.DefaultRequest())
.Times(2);
}
}
public void when_GetTransaction_is_called_and_not_found_then_we_should_get_a_NotFoundException()
{
using (HttpTest httpTest = new HttpTest())
{
httpTest.RespondWithJson(404, new { message = "Not Found" });
var signhostApiClient = new SignHostApiClient(settings);
Func<Task> getTransaction = () => signhostApiClient.GetTransaction("transaction Id");
getTransaction.ShouldThrow<ErrorHandling.NotFoundException>();
}
}
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 void when_GetTransaction_is_called_and_the_authorization_is_bad_then_we_should_get_a_BadAuthorizationException()
{
using (HttpTest httpTest = new HttpTest()) {
httpTest.RespondWithJson(401, new { message = "unauthorized" });
var signhostApiClient = new SignHostApiClient(settings);
Func<Task> getTransaction = () => signhostApiClient.GetTransaction("transaction Id");
getTransaction.ShouldThrow<UnauthorizedAccessException>();
}
}
public void ListFlavors()
{
using (var httpTest = new HttpTest())
{
var cdnService = new ContentDeliveryNetworkService(Stubs.AuthenticationProvider, DefaultRegion);
httpTest.RespondWithJson(new FlavorCollection(new[] {new Flavor()}));
var flavors = cdnService.ListFlavors();
Assert.NotNull(flavors);
Assert.Equal(1, flavors.Count());
}
}
public void GetFlavor()
{
using (var httpTest = new HttpTest())
{
var cdnService = new ContentDeliveryNetworkService(Stubs.AuthenticationProvider, DefaultRegion);
httpTest.RespondWithJson(new Flavor {Id = "flavor-id"});
var flavor = cdnService.GetFlavor("flavor-id");
Assert.NotNull(flavor);
Assert.Equal("flavor-id", flavor.Id);
}
}
public void when_GetTransaction_is_called_and_unkownerror_like_418_occures_then_we_should_get_a_SignhostException()
{
using (HttpTest httpTest = new HttpTest())
{
httpTest.RespondWithJson(418, new { message = "418 I'm a teapot" });
var signhostApiClient = new SignHostApiClient(settings);
Func<Task> getTransaction = () => signhostApiClient.GetTransaction("transaction Id");
getTransaction.ShouldThrow<ErrorHandling.SignhostRestApiClientException>()
.WithMessage("*418*");
}
}
public void FindServiceOnAPage()
{
using (var httpTest = new HttpTest())
{
httpTest.RespondWithJson(new ServiceCollection(new[] {new Service()})
{
Links = new[] {new Link("next", "http://api.com/next")}
});
httpTest.RespondWithJson(new ServiceCollection(new[] {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 async Task Get_ShouldCallTheCorrectUrlByAwaitingImmediately()
{
using (var http = new HttpTest())
{
http.RespondWithJson(Fixtures.Key.DefaultResponse);
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);
}
}
public void ShouldThrowExistingPeerAddressExceptionOnDuplicatePeerAddress()
{
using (var http = new HttpTest())
{
http.RespondWithJson(HttpStatusCode.Conflict, Fixtures.CreateErrorMessage(Constants.Etcd.ErrorCode_ExistingPeerAddress));
Func<Task> action = async () =>
{
await Etcd.ClientFor(Fixtures.EtcdUrl.ToUri())
.Cluster
.CreateMember()
.WithPeerUri(Fixtures.EtcdUrl.ToUri());
};
action.ShouldThrowExactly<ExistingPeerAddressException>()
.And
.IsExistingPeerAddress.Should().BeTrue();
}
}
public async Task Get_ShouldCallTheCorrectUrlWithQuorumTrueOption()
{
using (var http = new HttpTest())
{
http.RespondWithJson(Fixtures.Key.DefaultResponse);
await Etcd.ClientFor(Fixtures.EtcdUrl.ToUri())
.GetKey(Fixtures.Key.Path)
.WithQuorum();
http.Should()
.HaveCalled(
Fixtures.EtcdUrl
.AppendPathSegments(Constants.Etcd.Path_Keys, Fixtures.Key.Path)
.SetQueryParam(Constants.Etcd.Parameter_Quorum, Constants.Etcd.Parameter_True)
)
.WithVerb(HttpMethod.Get)
.Times(1);
}
}
public async Task ShouldCallTheCorrectUrlByAwaitingImmediately()
{
using (var http = new HttpTest())
{
http.RespondWithJson(
Fixtures.Cluster.ClusterMemberResponse(
peerUris : new[]
{
Fixtures.EtcdUrl.ToUri(),
Fixtures.EtcdUrl.ToUri()
}));
var memberId = StaticRandom.Instance.Next().ToString();
var member = await Etcd.ClientFor(Fixtures.EtcdUrl.ToUri())
.Cluster
.UpdateMemberPeerUrls()
.WithMemberId(memberId)
.WithPeerUri(Fixtures.EtcdUrl.ToUri(), Fixtures.EtcdUrl.ToUri());
http.Should()
.HaveCalled(
Fixtures.EtcdUrl
.AppendPathSegment(Constants.Etcd.Path_Members)
.AppendPathSegment(memberId)
)
.WithVerb(HttpMethod.Put)
.WithContentType(Constants.Http.ContentType_ApplicationJson)
.Times(1);
member.Should().NotBeNull();
member.PeerUrls
.Should()
.HaveCount(2)
.And
.ContainInOrder(
Fixtures.EtcdUrl.ToUri(),
Fixtures.EtcdUrl.ToUri()
);
}
}
public async Task ShouldCallTheCorrectUrlByAwaitingImmediately()
{
using (var http = new HttpTest())
{
http.RespondWithJson(Fixtures.Queue.DefaultResponse);
await Etcd.ClientFor(Fixtures.EtcdUrl.ToUri())
.Atomic
.Enqueue(Fixtures.Queue.Path)
.WithValue(Fixtures.Queue.DefaultValue);
http.Should()
.HaveCalled(
Fixtures.EtcdUrl
.AppendPathSegments(Constants.Etcd.Path_Keys, Fixtures.Queue.Path)
)
.WithVerb(HttpMethod.Post)
.WithRequestBody(Fixtures.Queue.DefaultRequest())
.Times(1);
}
}
public async Task ShouldCallTheCorrectUrlByAwaitingImmediately()
{
var expected = true;
using (var http = new HttpTest())
{
http.RespondWithJson(Fixtures.Cluster.ClusterHealthResponse(expected));
var healthResult = await Etcd.ClientFor(Fixtures.EtcdUrl.ToUri())
.Cluster
.GetHealth();
http.Should()
.HaveCalled(Fixtures.EtcdUrl.AppendPathSegment(Constants.Etcd.Path_Health))
.WithVerb(HttpMethod.Get)
.Times(1);
healthResult.Should().NotBeNull();
healthResult.Value.Should()
.Be(expected);
}
}
public async Task Get_ShouldUseConfiguredValueConverter()
{
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 client = Etcd.ClientFor(Fixtures.EtcdUrl.ToUri());
client.Configure(x => x.ValueConverter = converter);
var response = await client
.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>();
getValue.ShouldNotThrow();
responseDto.Should().NotBeNull();
responseDto.Id.Should().Be(dto.Id);
responseDto.Name.Should().Be(dto.Name);
}
}
public async Task ShouldCallTheCorrectUrlWithTtlOptionUsingTimeSpan()
{
var expectedTtlValue = TimeSpan.FromMinutes(3) + TimeSpan.FromSeconds(16);
using (var http = new HttpTest())
{
http.RespondWithJson(Fixtures.Queue.DefaultResponse);
var result = await Etcd.ClientFor(Fixtures.EtcdUrl.ToUri())
.Atomic
.Enqueue(Fixtures.Queue.Path)
.WithValue(Fixtures.Queue.DefaultValue)
.WithTimeToLive(expectedTtlValue);
http.Should()
.HaveCalled(
Fixtures.EtcdUrl
.AppendPathSegments(Constants.Etcd.Path_Keys, Fixtures.Queue.Path)
)
.WithVerb(HttpMethod.Post)
.WithRequestBody(Fixtures.Key.TtlTimeSpanRequest(Fixtures.Queue.DefaultValue, expectedTtlValue))
.Times(1);
}
}
public async Task ShouldCallTheCorrectUrlByAwaitingImmediately()
{
using (var http = new HttpTest())
{
http.RespondWithJson(Fixtures.Cluster.CreateResponse(Fixtures.EtcdUrl.ToUri()));
var memberId = StaticRandom.Instance.Next();
await Etcd.ClientFor(Fixtures.EtcdUrl.ToUri())
.Cluster
.DeleteMember()
.WithMemberId(memberId.ToString());
http.Should()
.HaveCalled(
Fixtures.EtcdUrl
.AppendPathSegment(Constants.Etcd.Path_Members)
.AppendPathSegment(memberId.ToString())
)
.WithVerb(HttpMethod.Delete)
.Times(1);
}
}
public void when_CreateTransaction_is_called_with_invalid_email_then_we_should_get_a_BadRequestException()
{
using (HttpTest httpTest = new HttpTest())
{
httpTest.RespondWithJson(400, new { message = "Bad Request" });
var signhostApiClient = new SignHostApiClient(settings);
Signer testSigner = new Signer();
testSigner.Email = "firstname.lastnamegmail.com";
Transaction testTransaction = new Transaction();
testTransaction.Signers.Add(testSigner);
Func<Task> getTransaction = () => signhostApiClient.CreateTransaction(testTransaction);
getTransaction.ShouldThrow<ErrorHandling.BadRequestException>();
httpTest.ShouldHaveCalled($"{settings.Endpoint}transaction")
.WithVerb(HttpMethod.Post)
.WithContentType("application/json")
.Times(1);
}
}
public void when_a_function_is_called_with_a_wrong_endpoint_we_should_get_a_SignhostRestApiClientException()
{
using (HttpTest httpTest = new HttpTest())
{
httpTest.RespondWithJson(502, new { message = "Bad Gateway" });
var signhostApiClient = new SignHostApiClient(settings);
Func<Task> getTransaction = () => signhostApiClient.GetTransaction("transaction Id");
getTransaction.ShouldThrow<ErrorHandling.SignhostRestApiClientException>();
}
}
public void WaitForServiceDeleted_ThrowsAnException_WhenTheOperationFailed()
{
using (var httpTest = new HttpTest())
{
var failedServiceDeployment = new Service
{
Status = ServiceStatus.Failed,
Errors = new[] { new ServiceError { Message = "Random error." } }
};
httpTest.RespondWithJson(failedServiceDeployment);
var ex = Assert.Throws<ServiceOperationFailedException>(() => _cdnService.WaitForServiceDeleted("failed-service-id"));
Assert.NotEmpty(ex.Errors);
}
}
public async void WaitForServiceDeleted_StopsWhenTimeoutIsReached()
{
using (var httpTest = new HttpTest())
{
httpTest.RespondWithJson(new Service { Status = ServiceStatus.CreateInProgress });
await Assert.ThrowsAsync<TimeoutException>(() => _cdnService.WaitForServiceDeletedAsync("service-id", TimeSpan.FromSeconds(5), TimeSpan.FromSeconds(1)));
}
}
public void WaitForServiceDeleted_StopsWhenUserTokenIsCancelled()
{
using (var httpTest = new HttpTest())
{
httpTest.RespondWithJson(new Service { Status = ServiceStatus.DeleteInProgress });
var timedToken = new CancellationTokenSource(TimeSpan.FromSeconds(1));
Assert.ThrowsAsync<TaskCanceledException>(() => _cdnService.WaitForServiceDeletedAsync("service-id", Timeout.InfiniteTimeSpan, Timeout.InfiniteTimeSpan, null, timedToken.Token));
}
}
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 WaitForServiceDeployed()
{
using (var httpTest = new HttpTest())
{
httpTest.RespondWithJson(new Service { Status = ServiceStatus.CreateInProgress });
httpTest.RespondWithJson(new Service { Status = ServiceStatus.UpdateInProgress });
httpTest.RespondWithJson(new Service { Status = ServiceStatus.Deployed });
var service = _cdnService.WaitForServiceDeployed("service-id", TimeSpan.FromMilliseconds(1));
Assert.NotNull(service);
}
}
public void when_GetTransaction_is_called_and_there_is_an_InternalServerError_then_we_should_get_a_InternalServerErrorException()
{
using (HttpTest httpTest = new HttpTest())
{
httpTest.RespondWithJson(500, new { message = "Internal Server Error" });
var signhostApiClient = new SignHostApiClient(settings);
Func<Task> getTransaction = () => signhostApiClient.GetTransaction("transaction Id");
getTransaction.ShouldThrow<ErrorHandling.InternalServerErrorException>();
}
}
public void Watch_ShouldStopPollingWhenSubscriptionIsDisposed()
{
using (var http = new HttpTest())
{
http.RespondWithJson(Fixtures.Watch.DefaultResponse)
.RespondWithJson(Fixtures.Watch.DefaultResponse)
.RespondWithJson(Fixtures.Watch.DefaultResponse)
.RespondWithJson(Fixtures.Watch.DefaultResponse)
.RespondWithJson(Fixtures.Watch.DefaultResponse);
Etcd.ClientFor(Fixtures.EtcdUrl.ToUri())
.Watch(Fixtures.Watch.Path)
.SubscribeFor(3)
.Wait();
http.Should()
.HaveCalled(
Fixtures.EtcdUrl
.AppendPathSegment(Constants.Etcd.Path_Keys)
.AppendPathSegment(Fixtures.Watch.Path)
.SetQueryParam(Constants.Etcd.Parameter_Wait, Constants.Etcd.Parameter_True)
)
.WithVerb(HttpMethod.Get);
http.CallLog.Should()
.HaveCount(3);
}
}
public async Task Upsert_ShouldCallTheCorrectUrlWithTtlOption()
{
using (var http = new HttpTest())
{
http.RespondWithJson(Fixtures.Key.DefaultResponse);
await Etcd.ClientFor(Fixtures.EtcdUrl.ToUri())
.UpsertKey(Fixtures.Key.Path)
.WithValue(Fixtures.Key.DefaultValue)
.WithTimeToLive(Fixtures.Key.DefaultTtl);
http.Should()
.HaveCalled(
Fixtures.EtcdUrl
.AppendPathSegments(Constants.Etcd.Path_Keys, Fixtures.Key.Path)
)
.WithVerb(HttpMethod.Put)
.WithRequestBody(Fixtures.Key.TtlRequest())
.Times(1);
}
}
