public async Task ServerWithSimpleStatusHandler()
{
await WithServerAndClient(Handlers.Status(419), async (server, client) =>
{
var resp = await client.GetAsync(server.Uri);
Assert.Equal(419, (int)resp.StatusCode);
});
}
public async Task StatusAsEnum() =>
await WithServerAndClient(Handlers.Status(HttpStatusCode.BadRequest), async (server, client) =>
{
var resp = await client.GetAsync(server.Uri);
Assert.Equal((int)HttpStatusCode.BadRequest, (int)resp.StatusCode);
AssertNoHeader(resp, "content-type");
Assert.Equal("", await resp.Content.ReadAsStringAsync());
});
public async Task SwitchHandlers()
{
await WithServerAndClient(Handlers.Switchable(out var switchable), async (server, client) =>
{
var resp1 = await client.GetAsync(server.Uri);
Assert.Equal(200, (int)resp1.StatusCode);
switchable.Target = Handlers.Status(400);
var resp2 = await client.GetAsync(server.Uri);
Assert.Equal(400, (int)resp2.StatusCode);
});
}
public async Task RequestWithBody()
{
await WithServerAndClient(Handlers.Status(200), async (server, client) =>
{
var req = new HttpRequestMessage(HttpMethod.Post, server.Uri.ToString() + "request/path");
req.Content = new StringContent("hello", Encoding.UTF8, "text/plain");
var resp = await client.SendAsync(req);
Assert.Equal(200, (int)resp.StatusCode);
var received = server.Recorder.RequireRequest();
Assert.Equal("POST", received.Method);
Assert.Equal("/request/path", received.Path);
Assert.Equal("hello", received.Body);
});
}
public async Task ChainStatusAndHeadersAndBody()
{
var handler = Handlers.Status(201)
.Then(Handlers.Header("name1", "value1"))
.Then(Handlers.Header("name2", "value2"))
.Then(Handlers.BodyString("text/plain", "hello"));
await WithServerAndClient(handler, async (server, client) =>
{
var resp = await client.GetAsync(server.Uri);
Assert.Equal(201, (int)resp.StatusCode);
AssertHeader(resp, "name1", "value1");
AssertHeader(resp, "name2", "value2");
AssertHeader(resp, "content-type", "text/plain");
Assert.Equal("hello", await resp.Content.ReadAsStringAsync());
});
}
public async Task RequestWithQueryString()
{
await WithServerAndClient(Handlers.Status(200), async (server, client) =>
{
var requestedUri = new Uri(server.Uri, "/request/path?a=b");
var req = new HttpRequestMessage(HttpMethod.Get, requestedUri);
req.Headers.Add("header-name", "header-value");
var resp = await client.SendAsync(req);
Assert.Equal(200, (int)resp.StatusCode);
var received = server.Recorder.RequireRequest();
Assert.Equal("GET", received.Method);
Assert.Equal(requestedUri, received.Uri);
Assert.Equal("/request/path", received.Path);
Assert.Equal("?a=b", received.Query);
Assert.Equal("header-value", received.Headers["header-name"]);
Assert.Equal("", received.Body);
});
}
#pragma warning restore CS1591
private async Task DoRequestAsync(IRequestContext ctx)
{
var matchedPath = false;
foreach (var route in _routes)
{
if ((route.Path != null && route.Path == ctx.RequestInfo.Path) ||
(route.PathPattern != null && route.PathPattern.IsMatch(ctx.RequestInfo.Path)))
{
matchedPath = true;
if (route.Method is null || route.Method.ToString().ToUpper() == ctx.RequestInfo.Method)
{
await route.Handler(ctx);
return;
}
}
}
await Handlers.Status(matchedPath? 405 : 404)(ctx);
}
public async Task MultipleServers()
{
using (var server1 = HttpServer.Start(Handlers.Status(200)))
{
using (var server2 = HttpServer.Start(Handlers.Status(419)))
{
Assert.NotEqual(server1.Uri, server2.Uri);
using (var client = new HttpClient())
{
var resp1 = await client.GetAsync(server1.Uri);
Assert.Equal(200, (int)resp1.StatusCode);
var resp2 = await client.GetAsync(server2.Uri);
Assert.Equal(419, (int)resp2.StatusCode);
}
}
}
}
public async Task ServerCanBeUsedAsFakeProxy()
{
var proxyResp = Handlers.Status(200).Then(Handlers.BodyString("text/plain", "hello"));
using (var fakeProxy = HttpServer.Start(proxyResp))
{
var proxyParam = new WebProxy(fakeProxy.Uri);
using (var client = new HttpClient(new HttpClientHandler {
Proxy = proxyParam
}, true))
{
var fakeTargetUri = new Uri("http://example/not/real");
var resp = await client.GetAsync(fakeTargetUri);
Assert.Equal(200, (int)resp.StatusCode);
Assert.Equal("hello", await resp.Content.ReadAsStringAsync());
var request = fakeProxy.Recorder.RequireRequest();
Assert.Equal("GET", request.Method);
Assert.Equal(fakeTargetUri, request.Uri);
Assert.Equal("/not/real", request.Path);
}
}
}
