/// <summary>
/// Construct a new ProtoRequestMessage with the given path.
/// </summary>
/// <param name="server"></param>
/// <param name="path"></param>
public RequestBuilder(TestServer server, string path)
{
if (server == null)
{
throw new ArgumentNullException(nameof(server));
}
_server = server;
_req = new ProtoRequestMessage(ProtoMethod.Get, path);
}
public async Task Get_Fallback_FileName(string path)
{
// Arrange
var request = new ProtoRequestMessage(ProtoMethod.Get, path);
// Act
var response = await _client.SendAsync(request);
// Assert
Assert.Equal(ProtoStatusCode.NotFound, response.StatusCode);
}
public async Task Routing_CanRouteRequest_ToBranchRouter(string branch)
{
// Arrange
var message = new ProtoRequestMessage(ProtoMethod.Get, $"{branch}/api/get/5");
// Act
var response = await _client.SendAsync(message);
// Assert
Assert.Equal(ProtoStatusCode.OK, response.StatusCode);
Assert.Equal($"{branch} - API Get 5", await response.Content.ReadAsStringAsync());
}
public async Task Routing_CanRouteRequest_ToSpecificMiddleware()
{
// Arrange
var message = new ProtoRequestMessage(ProtoMethod.Get, "api/middleware");
// Act
var response = await _client.SendAsync(message);
// Assert
Assert.Equal(ProtoStatusCode.OK, response.StatusCode);
Assert.Equal($"Middleware!", await response.Content.ReadAsStringAsync());
}
public async Task Routing_CanRouteRequestDelegate_ToSpecificProtoVerb()
{
// Arrange
var message = new ProtoRequestMessage(ProtoMethod.Get, "api/get/5");
// Act
var response = await _client.SendAsync(message);
// Assert
Assert.Equal(ProtoStatusCode.OK, response.StatusCode);
Assert.Equal($"API Get 5", await response.Content.ReadAsStringAsync());
}
public async Task Get_Fallback_NonFileName(string path)
{
// Arrange
var request = new ProtoRequestMessage(ProtoMethod.Get, path);
// Act
var response = await _client.SendAsync(request);
var responseContent = await response.Content.ReadAsStringAsync();
// Assert
Assert.Equal(ProtoStatusCode.OK, response.StatusCode);
Assert.Equal("FallbackDefaultPattern", responseContent);
}
public async Task Get_HelloWorld()
{
// Arrange
var request = new ProtoRequestMessage(ProtoMethod.Get, "helloworld");
// Act
var response = await _client.SendAsync(request);
var responseContent = await response.Content.ReadAsStringAsync();
// Assert
Assert.Equal(ProtoStatusCode.OK, response.StatusCode);
Assert.Equal("Hello World", responseContent);
}
public async Task Get_MatchWildcardDomainAndPort(string baseAddress)
{
// Arrange
var request = new ProtoRequestMessage(ProtoMethod.Get, "api/DomainWildcard");
// Act
var client = CreateClient(baseAddress);
var response = await client.SendAsync(request);
var responseContent = await response.Content.ReadAsStringAsync();
// Assert
Assert.Equal(ProtoStatusCode.OK, response.StatusCode);
Assert.Equal("*.0.0.1:5000,*.0.0.1:5001", responseContent);
}
public async Task Routing_CanRouteRequest_ToDefaultHandler(string httpVerb)
{
// Arrange
var message = new ProtoRequestMessage(new ProtoMethod(httpVerb), "api/all/Joe/Duf");
var expectedBody = $"Verb = {httpVerb} - Path = /api/all/Joe/Duf - Route values - [name, Joe], [lastName, Duf]";
// Act
var response = await _client.SendAsync(message);
// Assert
Assert.Equal(ProtoStatusCode.OK, response.StatusCode);
var body = await response.Content.ReadAsStringAsync();
Assert.Equal(expectedBody, body);
}
/// <summary>
/// This adapts ProtoRequestMessages to ASP.NET Core requests, dispatches them through the pipeline, and returns the
/// associated ProtoResponseMessage.
/// </summary>
/// <param name="request"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
protected override async Task <ProtoResponseMessage> SendAsync(
ProtoRequestMessage request,
CancellationToken cancellationToken)
{
if (request == null)
{
throw new ArgumentNullException(nameof(request));
}
var contextBuilder = new ProtoContextBuilder(_application, AllowSynchronousIO);
Stream responseBody = null;
var requestContent = request.Content ?? new StreamContent(Stream.Null);
var body = await requestContent.ReadAsStreamAsync();
contextBuilder.Configure(context =>
{
var req = context.Request;
req.Protocol = "HTTP/" + request.Version.ToString(fieldCount: 2);
req.Method = request.Method.ToString();
req.Scheme = request.RequestUri.Scheme;
foreach (var header in request.Headers)
{
req.Headers.Append(header.Key, header.Value.ToArray());
}
if (!req.Host.HasValue)
{
// If Host wasn't explicitly set as a header, let's infer it from the Uri
req.Host = HostString.FromUriComponent(request.RequestUri);
if (request.RequestUri.IsDefaultPort)
{
req.Host = new HostString(req.Host.Host);
}
}
req.Path = PathString.FromUriComponent(request.RequestUri);
req.PathBase = PathString.Empty;
if (req.Path.StartsWithSegments(_pathBase, out var remainder))
{
req.Path = remainder;
req.PathBase = _pathBase;
}
req.QueryString = QueryString.FromUriComponent(request.RequestUri);
if (requestContent != null)
{
foreach (var header in requestContent.Headers)
{
req.Headers.Append(header.Key, header.Value.ToArray());
}
}
if (body.CanSeek)
{
// This body may have been consumed before, rewind it.
body.Seek(0, SeekOrigin.Begin);
}
req.Body = new AsyncStreamWrapper(body, () => contextBuilder.AllowSynchronousIO);
responseBody = context.Response.Body;
});
var httpContext = await contextBuilder.SendAsync(cancellationToken);
var response = new ProtoResponseMessage();
response.StatusCode = (ProtoStatusCode)httpContext.Response.StatusCode;
response.ReasonPhrase = httpContext.Features.Get <IProtoResponseFeature>().ReasonPhrase;
response.RequestMessage = request;
response.Content = new StreamContent(responseBody);
foreach (var header in httpContext.Response.Headers)
{
if (!response.Headers.TryAddWithoutValidation(header.Key, (IEnumerable <string>)header.Value))
{
bool success = response.Content.Headers.TryAddWithoutValidation(header.Key, (IEnumerable <string>)header.Value);
Contract.Assert(success, "Bad header");
}
}
return(response);
}
public async Task UseRouter_MapGet_MatchesRequest(Action <IRouteBuilder> routeBuilder, ProtoRequestMessage request, string expected)
{
// Arrange
var gamehostbuilder = new GameHostBuilder();
gamehostbuilder
.ConfigureServices(services => services.AddRouting())
.Configure(app =>
{
app.UseRouter(routeBuilder);
});
var testServer = new TestServer(gamehostbuilder);
var client = testServer.CreateClient();
// Act
var response = await client.SendAsync(request);
// Assert
Assert.Equal(ProtoStatusCode.OK, response.StatusCode);
var actual = await response.Content.ReadAsStringAsync();
Assert.Equal(expected, actual);
}
