public async Task WhenResponseContentTypeContainsCharsetThenCanDeserialize(string contentType, string content)
{
var expectedResponse = new HttpConnectResponse <TestType>(HttpStatusCode.OK);
expectedResponse.Content = new HttpConnectResponseContent();
expectedResponse.Content.Headers.ContentType = new ContentTypeHeader(contentType);
expectedResponse.Content.Content = content;
expectedResponse.Data = new TestType {
Name = "openwrks"
};
expectedResponse.Status = HttpConnectResponseStatus.Completed;
var client = new HttpConnectClient((pipline) =>
{
pipline.Use(next => ctx =>
{
ctx.Response = expectedResponse;
return(Task.CompletedTask);
});
});
var actualResponse = await client.GetAsync <TestType>(new Uri("https://www.example.com"), CancellationToken.None);
actualResponse.Should().BeEquivalentTo(expectedResponse);
}
public async Task WhenRequestUsesRelativeUriAndNoBaseUrlThenThrows()
{
var client = new HttpConnectClient();
Exception ex = await Assert.ThrowsAsync <InvalidOperationException>(
() => client.GetAsync(new Uri("/relative/url", UriKind.Relative), CancellationToken.None));
}
public async Task WhenDeserializationThrowsThenCapturedInResponseException(string contentType, string content)
{
var expectedResponse = new HttpConnectResponse <TestType>(HttpStatusCode.OK);
expectedResponse.Content = new HttpConnectResponseContent();
expectedResponse.Content.Headers.ContentType = new ContentTypeHeader(contentType);
expectedResponse.Content.Content = content;
expectedResponse.Status = HttpConnectResponseStatus.Completed;
var client = new HttpConnectClient((pipline) =>
{
pipline.Use(next => ctx =>
{
ctx.Response = expectedResponse;
return(Task.CompletedTask);
});
});
var actualResponse = await client.SendAsync <TestType>(
new HttpConnectRequest(HttpMethod.Get, new Uri("https://www.example.com")),
CancellationToken.None);
actualResponse.IsSuccess.Should().BeFalse();
actualResponse.Exception.Should().NotBeNull();
actualResponse.Data.Should().BeNull();
}
public async Task WhenClientIsSetupWithBaseUrlAndRequestUsesRelativeUriTheRequestUriUpdatedWithBaseUrl()
{
var client = new HttpConnectClient(new Uri("https://www.example.com"));
var request = new HttpConnectRequest(HttpMethod.Get, new Uri("/relative/url", UriKind.Relative));
await client.SendAsync <int>(request, CancellationToken.None);
request.RequestUri.Should().Be(new Uri("https://www.example.com/relative/url"));
}
public async Task WhenBuiltWithMiddlewareThatThrowsExceptionThenReturnsExceptionInResponse()
{
Exception expectedException = new Exception("test exception");
var client = new HttpConnectClient((pipline) =>
{
pipline.Use(next => ctx =>
{
throw expectedException;
});
});
var actualResponse = await client.GetAsync <int>(new Uri("https://www.example.com"), CancellationToken.None);
actualResponse.Exception.Should().Be(expectedException);
}
public async Task WhenBuiltWithMiddlewareThatThrowsExceptionThenRequestStatusIsError()
{
Exception expectedException = new Exception("test exception");
var client = new HttpConnectClient((pipline) =>
{
pipline.Use(next => ctx =>
{
throw expectedException;
});
});
var actualResponse = await client.SendAsync <int>(new HttpConnectRequest(HttpMethod.Get, new Uri("https://www.example.com")), CancellationToken.None);
actualResponse.Status.Should().Be(HttpConnectResponseStatus.Error);
}
public async Task WhenClientIsSetupWithBaseUrlAndRequestUsesRelativeUriTheRequestUriUpdatedWithBaseUrl()
{
HttpConnectRequest request = null;
var client = new HttpConnectClient(new Uri("https://www.example.com"), (pipeline) =>
{
pipeline.Use((next) => (ctx) =>
{
request = ctx.Request;
return(Task.CompletedTask);
});
});
await client.GetAsync(new Uri("/relative/url", UriKind.Relative), CancellationToken.None);
request.RequestUri.Should().Be(new Uri("https://www.example.com/relative/url"));
}
public async Task WhenBuiltWithSimpleMiddlewareThenReturnsExpectedResponse()
{
var expectedResponse = new HttpConnectResponse(HttpStatusCode.OK);
var client = new HttpConnectClient((pipline) =>
{
pipline.Use(next => ctx =>
{
ctx.Response = expectedResponse;
return(Task.CompletedTask);
});
});
var actualResponse = await client.GetAsync(new Uri("https://www.example.com"), CancellationToken.None);
actualResponse.Should().Be(expectedResponse);
}
public async Task WhenMiddlewareReturnsNonSuccessStatusCodeThenResponseIsNotSuccessful(HttpStatusCode statusCode)
{
var expectedResponse = new HttpConnectResponse <int>(statusCode);
var client = new HttpConnectClient((pipline) =>
{
pipline.Use(next => ctx =>
{
ctx.Response = expectedResponse;
return(Task.CompletedTask);
});
});
var actualResponse = await client.GetAsync <int>(new Uri("https://www.example.com"), CancellationToken.None);
actualResponse.IsSuccess.Should().BeFalse();
}
public async Task WhenBuiltWithMultipleMiddlewaresThenAllMiddlewareExecuted()
{
int executionCounter = 0;
Func <HttpConnectRequestDelegate, HttpConnectRequestDelegate> middleware =
(next) => (ctx) => { executionCounter++; return(next(ctx)); };
var client = new HttpConnectClient((pipline) =>
{
pipline.Use(middleware);
pipline.Use(middleware);
pipline.Use(middleware);
pipline.Use(middleware);
pipline.Use(middleware);
pipline.Use(middleware);
pipline.Use(middleware);
pipline.Use(middleware);
});
await client.GetAsync <int>(new Uri("https://www.example.com"), CancellationToken.None);
executionCounter.Should().Be(8);
}
public async Task WhenBuiltWithMiddlewareThatThrowsExceptionAfterResponseHasBeenSetThenOriginalResponseReturnedWithError()
{
HttpConnectResponse expectedResponse = new HttpConnectResponse(HttpStatusCode.Unauthorized);
Exception expectedException = new Exception("test exception");
var client = new HttpConnectClient((pipline) =>
{
pipline.Use(next => ctx =>
{
ctx.Response = expectedResponse;
return(next(ctx));
});
pipline.Use(next => ctx =>
{
throw expectedException;
});
});
var actualResponse = await client.GetAsync(new Uri("https://www.example.com"), CancellationToken.None);
actualResponse.Should().BeEquivalentTo(expectedResponse);
actualResponse.Status.Should().Be(HttpConnectResponseStatus.Error);
}
public async Task WhenMiddlewareReturnsNonSuccessResponseThenDoesNotDeserializeResponse(HttpStatusCode statusCode)
{
var expectedResponse = new HttpConnectResponse <int>(statusCode);
expectedResponse.Content = new HttpConnectResponseContent();
expectedResponse.Content.Headers.ContentType = new ContentTypeHeader("application/json");
expectedResponse.Content.Content = "{\"error\":\"test_error\"";
expectedResponse.Data = default;
expectedResponse.Status = HttpConnectResponseStatus.Completed;
var client = new HttpConnectClient((pipline) =>
{
pipline.Use(next => ctx =>
{
ctx.Response = expectedResponse;
return(Task.CompletedTask);
});
});
var actualResponse = await client.GetAsync <int>(new Uri("https://www.example.com"), CancellationToken.None);
actualResponse.Should().BeEquivalentTo(expectedResponse);
}
public async Task WhenBuiltWithSimpleMiddlewareThenReturnsExpectedResponse()
{
var expectedResponse = new HttpConnectResponse <int>(HttpStatusCode.OK);
expectedResponse.Content = new HttpConnectResponseContent();
expectedResponse.Content.Headers.ContentType = new ContentTypeHeader("application/json");
expectedResponse.Content.Content = "1";
expectedResponse.Data = 1;
expectedResponse.Status = HttpConnectResponseStatus.Completed;
var client = new HttpConnectClient((pipline) =>
{
pipline.Use(next => ctx =>
{
ctx.Response = expectedResponse;
return(Task.CompletedTask);
});
});
var actualResponse = await client.GetAsync <int>(new Uri("https://www.example.com"), CancellationToken.None);
actualResponse.Should().BeEquivalentTo(expectedResponse);
}
public async Task WhenResponseContentTypeCannotBeDeserializedThenReturnsDefault(string contentType, string content)
{
var expectedResponse = new HttpConnectResponse <string>(HttpStatusCode.OK);
expectedResponse.Content = new HttpConnectResponseContent();
expectedResponse.Content.Headers.ContentType = new ContentTypeHeader(contentType);
expectedResponse.Content.Content = content;
expectedResponse.Data = null;
expectedResponse.Status = HttpConnectResponseStatus.Completed;
var client = new HttpConnectClient((pipline) =>
{
pipline.Use(next => ctx =>
{
ctx.Response = expectedResponse;
return(Task.CompletedTask);
});
});
var actualResponse = await client.SendAsync <string>(new HttpConnectRequest(HttpMethod.Get, new Uri("https://www.example.com")), CancellationToken.None);
actualResponse.Should().BeEquivalentTo(expectedResponse);
}
public async Task WhenRequestIsNullTheThrows()
{
var client = new HttpConnectClient();
await Assert.ThrowsAsync <ArgumentNullException>(() => client.SendAsync(null, CancellationToken.None));
}
