public async void RouteAsync_Success_LogsCorrectValues()
{
// Arrange
var sink = new TestSink();
var loggerFactory = new TestLoggerFactory(sink);
var context = CreateRouteContext(loggerFactory: loggerFactory);
var handler = new MvcRouteHandler();
// Act
await handler.RouteAsync(context);
// Assert
Assert.Equal(1, sink.Scopes.Count);
var scope = sink.Scopes[0];
Assert.Equal(typeof(MvcRouteHandler).FullName, scope.LoggerName);
Assert.Equal("MvcRouteHandler.RouteAsync", scope.Scope);
// There is a record for IsEnabled and one for WriteCore.
Assert.Equal(2, sink.Writes.Count);
var enabled = sink.Writes[0];
Assert.Equal(typeof(MvcRouteHandler).FullName, enabled.LoggerName);
Assert.Equal("MvcRouteHandler.RouteAsync", enabled.Scope);
Assert.Null(enabled.State);
var write = sink.Writes[1];
Assert.Equal(typeof(MvcRouteHandler).FullName, write.LoggerName);
Assert.Equal("MvcRouteHandler.RouteAsync", write.Scope);
var values = Assert.IsType <MvcRouteHandlerRouteAsyncValues>(write.State);
Assert.Equal("MvcRouteHandler.RouteAsync", values.Name);
Assert.Equal(true, values.ActionSelected);
Assert.Equal(true, values.ActionInvoked);
Assert.Equal(true, values.Handled);
}
public async Task RouteAsync_FailOnNoInvoker_LogsCorrectValues()
{
// Arrange
var sink = new TestSink();
var loggerFactory = new TestLoggerFactory(sink);
var mockInvokerFactory = new Mock <IActionInvokerFactory>();
mockInvokerFactory.Setup(f => f.CreateInvoker(It.IsAny <ActionContext>()))
.Returns <IActionInvoker>(null);
var context = CreateRouteContext(
invokerFactory: mockInvokerFactory.Object,
loggerFactory: loggerFactory);
var handler = new MvcRouteHandler();
// Act
await Assert.ThrowsAsync <InvalidOperationException>(async() =>
await handler.RouteAsync(context));
// Assert
var scope = Assert.Single(sink.Scopes);
Assert.Equal(typeof(MvcRouteHandler).FullName, scope.LoggerName);
Assert.Equal("MvcRouteHandler.RouteAsync", scope.Scope);
Assert.Equal(1, sink.Writes.Count);
var write = sink.Writes[0];
Assert.Equal(typeof(MvcRouteHandler).FullName, write.LoggerName);
Assert.Equal("MvcRouteHandler.RouteAsync", write.Scope);
var values = Assert.IsType <MvcRouteHandlerRouteAsyncValues>(write.State);
Assert.Equal("MvcRouteHandler.RouteAsync", values.Name);
Assert.True(values.ActionSelected);
Assert.False(values.ActionInvoked);
Assert.False(values.Handled);
}
public async Task RouteAsync_FailOnNoAction_LogsCorrectValues()
{
// Arrange
var sink = new TestSink();
var loggerFactory = new TestLoggerFactory(sink);
var mockActionSelector = new Mock <IActionSelector>();
mockActionSelector.Setup(a => a.SelectAsync(It.IsAny <RouteContext>()))
.Returns(Task.FromResult <ActionDescriptor>(null));
var context = CreateRouteContext(
actionSelector: mockActionSelector.Object,
loggerFactory: loggerFactory);
var handler = new MvcRouteHandler();
// Act
await handler.RouteAsync(context);
// Assert
Assert.Equal(1, sink.Scopes.Count);
var scope = sink.Scopes[0];
Assert.Equal(typeof(MvcRouteHandler).FullName, scope.LoggerName);
Assert.Equal("MvcRouteHandler.RouteAsync", scope.Scope);
Assert.Equal(1, sink.Writes.Count);
var write = sink.Writes[0];
Assert.Equal(typeof(MvcRouteHandler).FullName, write.LoggerName);
Assert.Equal("MvcRouteHandler.RouteAsync", write.Scope);
var values = Assert.IsType <MvcRouteHandlerRouteAsyncValues>(write.State);
Assert.Equal("MvcRouteHandler.RouteAsync", values.Name);
Assert.Equal(false, values.ActionSelected);
Assert.Equal(false, values.ActionInvoked);
Assert.Equal(false, values.Handled);
}
public async Task RouteAsync_Success_LogsCorrectValues()
{
// Arrange
var sink = new TestSink();
var loggerFactory = new TestLoggerFactory(sink, enabled: true);
var displayName = "A.B.C";
var actionDescriptor = new Mock<ActionDescriptor>();
actionDescriptor.SetupGet(ad => ad.DisplayName)
.Returns(displayName);
var context = CreateRouteContext(actionDescriptor: actionDescriptor.Object, loggerFactory: loggerFactory);
var handler = new MvcRouteHandler();
var expectedMessage = $"Executing action {displayName}";
// Act
await handler.RouteAsync(context);
// Assert
Assert.Single(sink.Scopes);
Assert.StartsWith("ActionId: ", sink.Scopes[0].Scope?.ToString());
Assert.Single(sink.Writes);
Assert.Equal(expectedMessage, sink.Writes[0].State?.ToString());
}
public async void SelectAsync_NoMatchedActions_LogIsCorrect()
{
// Arrange
var sink = new TestSink();
var loggerFactory = new TestLoggerFactory(sink);
var routeContext = CreateRouteContext("POST");
var actions = new ActionDescriptor[0];
var selector = CreateSelector(actions, loggerFactory);
// Act
var action = await selector.SelectAsync(routeContext);
// Assert
Assert.Equal(1, sink.Scopes.Count);
var scope = sink.Scopes[0];
Assert.Equal(typeof(DefaultActionSelector).FullName, scope.LoggerName);
Assert.Equal("DefaultActionSelector.SelectAsync", scope.Scope);
Assert.Equal(1, sink.Writes.Count);
var write = sink.Writes[0];
Assert.Equal(typeof(DefaultActionSelector).FullName, write.LoggerName);
Assert.Equal("DefaultActionSelector.SelectAsync", write.Scope);
var values = Assert.IsType <DefaultActionSelectorSelectAsyncValues>(write.State);
Assert.Equal("DefaultActionSelector.SelectAsync", values.Name);
Assert.Empty(values.ActionsMatchingRouteConstraints);
Assert.Empty(values.ActionsMatchingActionConstraints);
Assert.Empty(values.FinalMatches);
Assert.Null(values.SelectedAction);
// (does not throw)
Assert.NotEmpty(values.Summary);
}
public TestLogger(string name, TestSink sink)
{
_sink = sink;
_name = name;
}
public TestLoggerFactory(TestSink sink)
{
_sink = sink;
}
