|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Http.Features;
using Microsoft.AspNetCore.Routing;
namespace Microsoft.AspNetCore.Builder.Extensions;
public class MapPathMiddlewareTests
{
private static Task Success(HttpContext context)
{
context.Response.StatusCode = 200;
context.Items["test.PathBase"] = context.Request.PathBase.Value;
context.Items["test.Path"] = context.Request.Path.Value;
return Task.FromResult<object?>(null);
}
private static void UseSuccess(IApplicationBuilder app)
{
app.Run(Success);
}
private static Task NotImplemented(HttpContext context)
{
throw new NotImplementedException();
}
private static void UseNotImplemented(IApplicationBuilder app)
{
app.Run(NotImplemented);
}
[Fact]
public void NullArguments_ArgumentNullException()
{
var builder = new ApplicationBuilder(serviceProvider: null!);
var noMiddleware = new ApplicationBuilder(serviceProvider: null!).Build();
var noOptions = new MapOptions();
Assert.Throws<ArgumentNullException>(() => builder.Map("/foo", configuration: null!));
Assert.Throws<ArgumentNullException>(() => new MapMiddleware(noMiddleware, null!));
}
[Theory]
[InlineData("/foo", "", "/foo", "/foo", "")]
[InlineData("/foo", "", "/foo/", "/foo", "/")]
[InlineData("/foo", "/Bar", "/foo", "/Bar/foo", "")]
[InlineData("/foo", "/Bar", "/foo/cho", "/Bar/foo", "/cho")]
[InlineData("/foo", "/Bar", "/foo/cho/", "/Bar/foo", "/cho/")]
[InlineData("/foo/cho", "/Bar", "/foo/cho", "/Bar/foo/cho", "")]
[InlineData("/foo/cho", "/Bar", "/foo/cho/do", "/Bar/foo/cho", "/do")]
[InlineData("/foo%42/cho", "/Bar%42", "/foo%42/cho/do%42", "/Bar%42/foo%42/cho", "/do%42")]
public async Task PathMatchFunc_BranchTaken(string matchPath, string basePath, string requestPath, string expectedPathBase, string expectedPath)
{
HttpContext context = CreateRequest(basePath, requestPath);
var builder = new ApplicationBuilder(serviceProvider: null!);
builder.Map(new PathString(matchPath), UseSuccess);
var app = builder.Build();
await app.Invoke(context);
Assert.Equal(200, context.Response.StatusCode);
Assert.Equal(basePath, context.Request.PathBase.Value);
Assert.Equal(requestPath, context.Request.Path.Value);
Assert.Equal(expectedPathBase, (string)context.Items["test.PathBase"]!);
Assert.Equal(expectedPath, context.Items["test.Path"]);
}
[Theory]
[InlineData("/foo", "", "/foo")]
[InlineData("/foo", "", "/foo/")]
[InlineData("/foo", "/Bar", "/foo")]
[InlineData("/foo", "/Bar", "/foo/cho")]
[InlineData("/foo", "/Bar", "/foo/cho/")]
[InlineData("/foo/cho", "/Bar", "/foo/cho")]
[InlineData("/foo/cho", "/Bar", "/foo/cho/do")]
[InlineData("/foo", "", "/Foo")]
[InlineData("/foo", "", "/Foo/")]
[InlineData("/foo", "/Bar", "/Foo")]
[InlineData("/foo", "/Bar", "/Foo/Cho")]
[InlineData("/foo", "/Bar", "/Foo/Cho/")]
[InlineData("/foo/cho", "/Bar", "/Foo/Cho")]
[InlineData("/foo/cho", "/Bar", "/Foo/Cho/do")]
public async Task PathMatchAction_BranchTaken(string matchPath, string basePath, string requestPath)
{
HttpContext context = CreateRequest(basePath, requestPath);
var builder = new ApplicationBuilder(serviceProvider: null!);
builder.Map(matchPath, subBuilder => subBuilder.Run(Success));
var app = builder.Build();
await app.Invoke(context);
Assert.Equal(200, context.Response.StatusCode);
Assert.Equal(string.Concat(basePath, requestPath.AsSpan(0, matchPath.Length)), (string)context.Items["test.PathBase"]!);
Assert.Equal(requestPath.Substring(matchPath.Length), context.Items["test.Path"]);
}
[Theory]
[InlineData("/foo", "", "/foo")]
[InlineData("/foo", "", "/foo/")]
[InlineData("/foo", "/Bar", "/foo")]
[InlineData("/foo", "/Bar", "/foo/cho")]
[InlineData("/foo", "/Bar", "/foo/cho/")]
[InlineData("/foo/cho", "/Bar", "/foo/cho")]
[InlineData("/foo/cho", "/Bar", "/foo/cho/do")]
[InlineData("/foo", "", "/Foo")]
[InlineData("/foo", "", "/Foo/")]
[InlineData("/foo", "/Bar", "/Foo")]
[InlineData("/foo", "/Bar", "/Foo/Cho")]
[InlineData("/foo", "/Bar", "/Foo/Cho/")]
[InlineData("/foo/cho", "/Bar", "/Foo/Cho")]
[InlineData("/foo/cho", "/Bar", "/Foo/Cho/do")]
public async Task PathMatchAction_BranchTaken_WithPreserveMatchedPathSegment(string matchPath, string basePath, string requestPath)
{
HttpContext context = CreateRequest(basePath, requestPath);
var builder = new ApplicationBuilder(serviceProvider: null!);
builder.Map(matchPath, true, subBuilder => subBuilder.Run(Success));
var app = builder.Build();
await app.Invoke(context);
Assert.Equal(200, context.Response.StatusCode);
Assert.Equal(basePath, (string)context.Items["test.PathBase"]!);
Assert.Equal(requestPath, context.Items["test.Path"]);
}
[Theory]
[InlineData("/")]
[InlineData("/foo/")]
[InlineData("/foo/cho/")]
public void MatchPathWithTrailingSlashThrowsException(string matchPath)
{
Assert.Throws<ArgumentException>(() => new ApplicationBuilder(serviceProvider: null!).Map(matchPath, map => { }).Build());
}
[Theory]
[InlineData("/foo", "", "")]
[InlineData("/foo", "/bar", "")]
[InlineData("/foo", "", "/bar")]
[InlineData("/foo", "/foo", "")]
[InlineData("/foo", "/foo", "/bar")]
[InlineData("/foo", "", "/bar/foo")]
[InlineData("/foo/bar", "/foo", "/bar")]
public async Task PathMismatchFunc_PassedThrough(string matchPath, string basePath, string requestPath)
{
HttpContext context = CreateRequest(basePath, requestPath);
var builder = new ApplicationBuilder(serviceProvider: null!);
builder.Map(matchPath, UseNotImplemented);
builder.Run(Success);
var app = builder.Build();
await app.Invoke(context);
Assert.Equal(200, context.Response.StatusCode);
Assert.Equal(basePath, context.Request.PathBase.Value);
Assert.Equal(requestPath, context.Request.Path.Value);
}
[Theory]
[InlineData("/foo", "", "")]
[InlineData("/foo", "/bar", "")]
[InlineData("/foo", "", "/bar")]
[InlineData("/foo", "/foo", "")]
[InlineData("/foo", "/foo", "/bar")]
[InlineData("/foo", "", "/bar/foo")]
[InlineData("/foo/bar", "/foo", "/bar")]
public async Task PathMismatchAction_PassedThrough(string matchPath, string basePath, string requestPath)
{
HttpContext context = CreateRequest(basePath, requestPath);
var builder = new ApplicationBuilder(serviceProvider: null!);
builder.Map(matchPath, UseNotImplemented);
builder.Run(Success);
var app = builder.Build();
await app.Invoke(context);
Assert.Equal(200, context.Response.StatusCode);
Assert.Equal(basePath, context.Request.PathBase.Value);
Assert.Equal(requestPath, context.Request.Path.Value);
}
[Fact]
public async Task ChainedRoutes_Success()
{
var builder = new ApplicationBuilder(serviceProvider: null!);
builder.Map("/route1", map =>
{
map.Map("/subroute1", UseSuccess);
map.Run(NotImplemented);
});
builder.Map("/route2/subroute2", UseSuccess);
var app = builder.Build();
HttpContext context = CreateRequest(string.Empty, "/route1");
await Assert.ThrowsAsync<NotImplementedException>(() => app.Invoke(context));
context = CreateRequest(string.Empty, "/route1/subroute1");
await app.Invoke(context);
Assert.Equal(200, context.Response.StatusCode);
Assert.Equal(string.Empty, context.Request.PathBase.Value);
Assert.Equal("/route1/subroute1", context.Request.Path.Value);
context = CreateRequest(string.Empty, "/route2");
await app.Invoke(context);
Assert.Equal(404, context.Response.StatusCode);
Assert.Equal(string.Empty, context.Request.PathBase.Value);
Assert.Equal("/route2", context.Request.Path.Value);
context = CreateRequest(string.Empty, "/route2/subroute2");
await app.Invoke(context);
Assert.Equal(200, context.Response.StatusCode);
Assert.Equal(string.Empty, context.Request.PathBase.Value);
Assert.Equal("/route2/subroute2", context.Request.Path.Value);
context = CreateRequest(string.Empty, "/route2/subroute2/subsub2");
await app.Invoke(context);
Assert.Equal(200, context.Response.StatusCode);
Assert.Equal(string.Empty, context.Request.PathBase.Value);
Assert.Equal("/route2/subroute2/subsub2", context.Request.Path.Value);
}
[Fact]
public void ApplicationBuilderMapOverloadPreferredOverEndpointBuilderGivenStringPathAndImplicitLambdaParameterType()
{
var mockWebApplication = new MockWebApplication();
mockWebApplication.Map("/foo", app => { });
Assert.True(mockWebApplication.UseCalled);
}
[Fact]
public void ApplicationBuilderMapOverloadPreferredOverEndpointBuilderGivenStringPathAndExplicitLambdaParameterType()
{
var mockWebApplication = new MockWebApplication();
mockWebApplication.Map("/foo", (IApplicationBuilder app) => { });
Assert.True(mockWebApplication.UseCalled);
}
private HttpContext CreateRequest(string basePath, string requestPath)
{
HttpContext context = new DefaultHttpContext();
context.Request.PathBase = new PathString(basePath);
context.Request.Path = new PathString(requestPath);
return context;
}
private class MockWebApplication : IApplicationBuilder, IEndpointRouteBuilder
{
public bool UseCalled { get; set; }
public IServiceProvider ApplicationServices { get => throw new NotImplementedException(); set => throw new NotImplementedException(); }
public IFeatureCollection ServerFeatures => throw new NotImplementedException();
public IDictionary<string, object?> Properties => throw new NotImplementedException();
public IServiceProvider ServiceProvider => throw new NotImplementedException();
public ICollection<EndpointDataSource> DataSources => throw new NotImplementedException();
public IApplicationBuilder CreateApplicationBuilder() => throw new NotImplementedException();
public IApplicationBuilder New() => this;
public IApplicationBuilder Use(Func<RequestDelegate, RequestDelegate> middleware)
{
UseCalled = true;
return this;
}
public RequestDelegate Build()
{
return context => Task.CompletedTask;
}
}
}
|