public async Task Invoke_LogsCorrectValues_WhenNotHandled()
{
// Arrange
var expectedMessage = "Request did not match any routes";
var isHandled = false;
var sink = new TestSink(
TestSink.EnableWithTypeName <RouterMiddleware>,
TestSink.EnableWithTypeName <RouterMiddleware>);
var loggerFactory = new TestLoggerFactory(sink, enabled: true);
var httpContext = new DefaultHttpContext();
httpContext.RequestServices = new ServiceProvider();
RequestDelegate next = (c) =>
{
return(Task.FromResult <object>(null));
};
var router = new TestRouter(isHandled);
var middleware = new RouterMiddleware(next, loggerFactory, router);
// Act
await middleware.Invoke(httpContext);
// Assert
Assert.Empty(sink.Scopes);
var write = Assert.Single(sink.Writes);
Assert.Equal(expectedMessage, write.State?.ToString());
}
public async Task Invoke_DoesNotLog_WhenHandled()
{
// Arrange
var isHandled = true;
var sink = new TestSink(
TestSink.EnableWithTypeName <RouterMiddleware>,
TestSink.EnableWithTypeName <RouterMiddleware>);
var loggerFactory = new TestLoggerFactory(sink, enabled: true);
var httpContext = new DefaultHttpContext();
httpContext.RequestServices = new ServiceProvider();
RequestDelegate next = (c) =>
{
return(Task.FromResult <object>(null));
};
var router = new TestRouter(isHandled);
var middleware = new RouterMiddleware(next, loggerFactory, router);
// Act
await middleware.Invoke(httpContext);
// Assert
Assert.Empty(sink.Scopes);
Assert.Empty(sink.Writes);
}
public async void Invoke_DoesNotLog_WhenHandled()
{
// Arrange
var isHandled = true;
var sink = new TestSink(
TestSink.EnableWithTypeName<RouterMiddleware>,
TestSink.EnableWithTypeName<RouterMiddleware>);
var loggerFactory = new TestLoggerFactory(sink, enabled: true);
var httpContext = new DefaultHttpContext();
httpContext.RequestServices = new ServiceProvider();
RequestDelegate next = (c) =>
{
return Task.FromResult<object>(null);
};
var router = new TestRouter(isHandled);
var middleware = new RouterMiddleware(next, loggerFactory, router);
// Act
await middleware.Invoke(httpContext);
// Assert
Assert.Empty(sink.Scopes);
Assert.Empty(sink.Writes);
}
public async void Invoke_DoesNotLogWhenDisabledAndNotHandled()
{
// Arrange
var isHandled = false;
var sink = new TestSink(
TestSink.EnableWithTypeName <RouterMiddleware>,
TestSink.EnableWithTypeName <RouterMiddleware>);
var loggerFactory = new TestLoggerFactory(sink, enabled: false);
var httpContext = new DefaultHttpContext();
httpContext.ApplicationServices = new ServiceProvider();
httpContext.RequestServices = httpContext.ApplicationServices;
RequestDelegate next = (c) =>
{
return(Task.FromResult <object>(null));
};
var router = new TestRouter(isHandled);
var middleware = new RouterMiddleware(next, httpContext.ApplicationServices, loggerFactory, router);
// Act
await middleware.Invoke(httpContext);
// Assert
Assert.Single(sink.Scopes);
var scope = sink.Scopes[0];
Assert.Equal(typeof(RouterMiddleware).FullName, scope.LoggerName);
Assert.Equal("RouterMiddleware.Invoke", scope.Scope);
Assert.Empty(sink.Writes);
}
public async void Invoke_LogsCorrectValues_WhenNotHandled()
{
// Arrange
var expectedMessage = "Request did not match any routes.";
var isHandled = false;
var sink = new TestSink(
TestSink.EnableWithTypeName<RouterMiddleware>,
TestSink.EnableWithTypeName<RouterMiddleware>);
var loggerFactory = new TestLoggerFactory(sink, enabled: true);
var httpContext = new DefaultHttpContext();
httpContext.RequestServices = new ServiceProvider();
RequestDelegate next = (c) =>
{
return Task.FromResult<object>(null);
};
var router = new TestRouter(isHandled);
var middleware = new RouterMiddleware(next, loggerFactory, router);
// Act
await middleware.Invoke(httpContext);
// Assert
Assert.Empty(sink.Scopes);
Assert.Single(sink.Writes);
Assert.Equal(expectedMessage, sink.Writes[0].State?.ToString());
}
/// <summary>
///
/// </summary>
/// <param name="next">The next router in the pipeline. If using only the CoreXT router, this should be the
/// final '404' HTTP status based router. Note that using any other root level router other than the main router
/// middleware cannot be detected.</param>
/// <param name="loggerFactory">An injected logger for debugging purposes.</param>
/// <param name="router">This is usually a 'RouteCollection' object constructed when {RouteBuilder}.'Build()' is called.</param>
public MainRouterMiddleware(RequestDelegate next, ILoggerFactory loggerFactory, IRouter router)
{
_Next = next;
_Router = router;
_Logger = loggerFactory.CreateLogger <MainRouterMiddleware>();
_RouterMiddleware = new RouterMiddleware(next, loggerFactory, router);
}
private static async Task ReExecuteAsync(HttpContext context)
{
IRouter router = context.GetRouteData().Routers[0];
RouterMiddleware routerMiddleware = new RouterMiddleware(_ => Task.CompletedTask, context.RequestServices.GetRequiredService <ILoggerFactory>(), router);
await routerMiddleware.Invoke(context);
}
public override ValueTask Initialize(ILifetimeScope scope)
{
var host = scope.Resolve <WebServer>();
var variableRouter = scope.Resolve <VariableRouter>();
var formatRouter = scope.Resolve <FormatRouter>();
var formatWebsocketRouter = scope.Resolve <FormatWebSocketRouter>();
var variableWebsocketRouter = scope.Resolve <VariableWebSocketRouter>();
host.AddHandlers(handle => handle
.Use(RouterMiddleware.Route("/api/format", (route) => route.Use(formatRouter.Route)))
.Use(RouterMiddleware.Route("/api/variable", (route) => route.Use(variableRouter.Route)))
.Use(RouterMiddleware.Route("/ws/format", (route) => route.Use(formatWebsocketRouter.Route)))
.Use(RouterMiddleware.Route("/ws/variable", (route) => route.Use(variableWebsocketRouter.Route)))
);
host.Run();
return(default);
public async void Invoke_LogsCorrectValuesWhenHandled()
{
// Arrange
var isHandled = true;
var sink = new TestSink(
TestSink.EnableWithTypeName <RouterMiddleware>,
TestSink.EnableWithTypeName <RouterMiddleware>);
var loggerFactory = new TestLoggerFactory(sink, enabled: true);
var mockContext = new Mock <HttpContext>(MockBehavior.Strict);
mockContext.Setup(m => m.RequestServices.GetService(typeof(ILoggerFactory)))
.Returns(loggerFactory);
RequestDelegate next = (c) =>
{
return(Task.FromResult <object>(null));
};
var router = new TestRouter(isHandled);
var mockServiceProvider = new Mock <IServiceProvider>();
var middleware = new RouterMiddleware(next, mockServiceProvider.Object, router);
// Act
await middleware.Invoke(mockContext.Object);
// Assert
// exists a BeginScope, verify contents
Assert.Single(sink.Scopes);
var scope = sink.Scopes[0];
Assert.Equal(typeof(RouterMiddleware).FullName, scope.LoggerName);
Assert.Equal("RouterMiddleware.Invoke", scope.Scope);
Assert.Single(sink.Writes);
var write = sink.Writes[0];
Assert.Equal(typeof(RouterMiddleware).FullName, write.LoggerName);
Assert.Equal("RouterMiddleware.Invoke", write.Scope);
Assert.Equal(typeof(RouterMiddlewareInvokeValues), write.State.GetType());
var values = (RouterMiddlewareInvokeValues)write.State;
Assert.Equal("RouterMiddleware.Invoke", values.Name);
Assert.Equal(true, values.Handled);
}
public async void Invoke_LogsCorrectValuesWhenHandled()
{
// Arrange
var isHandled = true;
var sink = new TestSink(
TestSink.EnableWithTypeName <RouterMiddleware>,
TestSink.EnableWithTypeName <RouterMiddleware>);
var loggerFactory = new TestLoggerFactory(sink, enabled: true);
var httpContext = new DefaultHttpContext();
httpContext.ApplicationServices = new ServiceProvider();
httpContext.RequestServices = httpContext.ApplicationServices;
RequestDelegate next = (c) =>
{
return(Task.FromResult <object>(null));
};
var router = new TestRouter(isHandled);
var middleware = new RouterMiddleware(next, httpContext.ApplicationServices, loggerFactory, router);
// Act
await middleware.Invoke(httpContext);
// Assert
// exists a BeginScope, verify contents
Assert.Single(sink.Scopes);
var scope = sink.Scopes[0];
Assert.Equal(typeof(RouterMiddleware).FullName, scope.LoggerName);
Assert.Equal("RouterMiddleware.Invoke", scope.Scope);
Assert.Single(sink.Writes);
var write = sink.Writes[0];
Assert.Equal(typeof(RouterMiddleware).FullName, write.LoggerName);
Assert.Equal("RouterMiddleware.Invoke", write.Scope);
Assert.Equal(typeof(RouterMiddlewareInvokeValues), write.State.GetType());
var values = (RouterMiddlewareInvokeValues)write.State;
Assert.Equal("RouterMiddleware.Invoke", values.Name);
Assert.Equal(true, values.Handled);
}
public async Task RoutingFeatureSetInIRouter()
{
// Arrange
var services = new ServiceCollection();
services.AddLogging();
var httpContext = new DefaultHttpContext
{
RequestServices = services.BuildServiceProvider()
};
httpContext.Request.Path = "/foo/10";
var routeHandlerExecuted = false;
var handler = new RouteHandler(context =>
{
routeHandlerExecuted = true;
var routingFeature = context.Features.Get <IRoutingFeature>();
Assert.NotNull(routingFeature);
Assert.NotNull(context.Features.Get <IRouteValuesFeature>());
Assert.Single(routingFeature.RouteData.Values);
Assert.Single(context.Request.RouteValues);
Assert.True(routingFeature.RouteData.Values.ContainsKey("id"));
Assert.True(context.Request.RouteValues.ContainsKey("id"));
Assert.Equal("10", routingFeature.RouteData.Values["id"]);
Assert.Equal("10", context.Request.RouteValues["id"]);
Assert.Equal("10", context.GetRouteValue("id"));
Assert.Same(routingFeature.RouteData, context.GetRouteData());
return(Task.CompletedTask);
});
var route = new Route(handler, "/foo/{id}", Mock.Of <IInlineConstraintResolver>());
var middleware = new RouterMiddleware(context => Task.CompletedTask, NullLoggerFactory.Instance, route);
// Act
await middleware.Invoke(httpContext);
// Assert
Assert.True(routeHandlerExecuted);
}
public async void Invoke_DoesNotLogWhenDisabledAndNotHandled()
{
// Arrange
var isHandled = false;
var sink = new TestSink(
TestSink.EnableWithTypeName <RouterMiddleware>,
TestSink.EnableWithTypeName <RouterMiddleware>);
var loggerFactory = new TestLoggerFactory(sink, enabled: false);
var mockContext = new Mock <HttpContext>(MockBehavior.Strict);
mockContext.Setup(m => m.RequestServices.GetService(typeof(ILoggerFactory)))
.Returns(loggerFactory);
RequestDelegate next = (c) =>
{
return(Task.FromResult <object>(null));
};
var router = new TestRouter(isHandled);
var mockServiceProvider = new Mock <IServiceProvider>();
var middleware = new RouterMiddleware(next, mockServiceProvider.Object, router);
// Act
await middleware.Invoke(mockContext.Object);
// Assert
Assert.Single(sink.Scopes);
var scope = sink.Scopes[0];
Assert.Equal(typeof(RouterMiddleware).FullName, scope.LoggerName);
Assert.Equal("RouterMiddleware.Invoke", scope.Scope);
Assert.Empty(sink.Writes);
}
public static RouterMiddleware AddCommand(this RouterMiddleware routerMiddleware,
string command, MessageDelegate middleware)
{
return(routerMiddleware.AddTextRoute($@"^\/{command}(@.+)?(\s.+)*$", middleware));
}
