public void ExecuteAsync_RemovesInnerControllerFromReleaseListAndAddsItselfInstead()
{
// Arrange
var request = new HttpRequestMessage();
var context = ContextUtil.CreateControllerContext(request: request);
var mockController = new Mock <IHttpController>();
var mockDisposable = mockController.As <IDisposable>();
mockController.Setup(c => c.ExecuteAsync(context, CancellationToken.None))
.Callback <HttpControllerContext, CancellationToken>((cc, ct) => cc.Request.RegisterForDispose(mockDisposable.Object))
.Returns(() => TaskHelpers.FromResult(new HttpResponseMessage()))
.Verifiable();
context.ControllerDescriptor = _controllerDescriptor;
context.Controller = mockController.Object;
var traceWriter = new TestTraceWriter();
var tracer = new HttpControllerTracer(request, mockController.Object, traceWriter);
// Act
((IHttpController)tracer).ExecuteAsync(context, CancellationToken.None).WaitUntilCompleted();
// Assert
IEnumerable <IDisposable> disposables = (IEnumerable <IDisposable>)request.Properties[HttpPropertyKeys.DisposableRequestResourcesKey];
Assert.Contains(tracer, disposables);
Assert.DoesNotContain(mockDisposable.Object, disposables);
}
public void Dispose_TracesAndInvokesInnerDisposeWhenControllerIsDisposable()
{
// Arrange
var mockController = new Mock <IHttpController>();
var mockDisposable = mockController.As <IDisposable>();
var request = new HttpRequestMessage();
var traceWriter = new TestTraceWriter();
var tracer = new HttpControllerTracer(request, mockController.Object, traceWriter);
var expectedTraces = new[]
{
new TraceRecord(request, TraceCategories.ControllersCategory, TraceLevel.Info)
{
Kind = TraceKind.Begin, Operation = "Dispose"
},
new TraceRecord(request, TraceCategories.ControllersCategory, TraceLevel.Info)
{
Kind = TraceKind.End, Operation = "Dispose"
}
};
// Act
((IDisposable)tracer).Dispose();
// Assert
Assert.Equal(expectedTraces, traceWriter.Traces, new TraceRecordComparer());
mockDisposable.Verify(d => d.Dispose(), Times.Once());
}
IHttpController IHttpControllerActivator.Create(HttpControllerContext controllerContext, Type controllerType)
{
IHttpController controller = null;
_traceWriter.TraceBeginEnd(
controllerContext.Request,
TraceCategories.ControllersCategory,
TraceLevel.Info,
_innerActivator.GetType().Name,
CreateMethodName,
beginTrace: null,
execute: () =>
{
controller = _innerActivator.Create(controllerContext, controllerType);
},
endTrace: (tr) =>
{
tr.Message = controller == null ? SRResources.TraceNoneObjectMessage : controller.GetType().FullName;
},
errorTrace: null);
if (controller != null && !(controller is HttpControllerTracer))
{
controller = new HttpControllerTracer(controller, _traceWriter);
}
return(controller);
}
IHttpController IHttpControllerActivator.Create(HttpRequestMessage request, HttpControllerDescriptor controllerDescriptor, Type controllerType)
{
IHttpController controller = null;
_traceWriter.TraceBeginEnd(
request,
TraceCategories.ControllersCategory,
TraceLevel.Info,
_innerActivator.GetType().Name,
CreateMethodName,
beginTrace: null,
execute: () =>
{
controller = _innerActivator.Create(request, controllerDescriptor, controllerType);
},
endTrace: (tr) =>
{
tr.Message = controller == null ? SRResources.TraceNoneObjectMessage : controller.GetType().FullName;
},
errorTrace: null);
if (controller != null && !(controller is HttpControllerTracer))
{
controller = new HttpControllerTracer(request, controller, _traceWriter);
}
return controller;
}
public void ExecuteAsync_Faults_And_Traces_When_Inner_Faults()
{
// Arrange
InvalidOperationException exception = new InvalidOperationException();
TaskCompletionSource<HttpResponseMessage> tcs = new TaskCompletionSource<HttpResponseMessage>();
tcs.TrySetException(exception);
Mock<ApiController> mockController = new Mock<ApiController>() { CallBase = true };
mockController.Setup(b => b.ExecuteAsync(It.IsAny<HttpControllerContext>(), It.IsAny<CancellationToken>())).Returns(tcs.Task);
HttpControllerContext controllerContext = ContextUtil.CreateControllerContext(request: new HttpRequestMessage());
controllerContext.ControllerDescriptor = _controllerDescriptor;
controllerContext.Controller = mockController.Object;
HttpActionContext actionContext = ContextUtil.CreateActionContext(controllerContext, actionDescriptor: _mockActionDescriptor.Object);
TestTraceWriter traceWriter = new TestTraceWriter();
HttpControllerTracer tracer = new HttpControllerTracer(mockController.Object, traceWriter);
TraceRecord[] expectedTraces = new TraceRecord[]
{
new TraceRecord(actionContext.Request, TraceCategories.ControllersCategory, TraceLevel.Info) { Kind = TraceKind.Begin },
new TraceRecord(actionContext.Request, TraceCategories.ControllersCategory, TraceLevel.Error) { Kind = TraceKind.End }
};
// Act
Exception thrown = Assert.Throws<InvalidOperationException>(() => ((IHttpController)tracer).ExecuteAsync(controllerContext, CancellationToken.None).Wait());
// Assert
Assert.Equal<TraceRecord>(expectedTraces, traceWriter.Traces, new TraceRecordComparer());
Assert.Same(exception, thrown);
Assert.Same(exception, traceWriter.Traces[1].Exception);
}
public void ExecuteAsync_Invokes_Inner_And_Traces()
{
// Arrange
HttpResponseMessage response = new HttpResponseMessage();
Mock<ApiController> mockController = new Mock<ApiController>() { CallBase = true };
mockController.Setup(b => b.ExecuteAsync(It.IsAny<HttpControllerContext>(), It.IsAny<CancellationToken>())).Returns(TaskHelpers.FromResult<HttpResponseMessage>(response));
HttpControllerContext controllerContext = ContextUtil.CreateControllerContext(request: new HttpRequestMessage());
controllerContext.ControllerDescriptor = _controllerDescriptor;
controllerContext.Controller = mockController.Object;
HttpActionContext actionContext = ContextUtil.CreateActionContext(controllerContext, actionDescriptor: _mockActionDescriptor.Object);
TestTraceWriter traceWriter = new TestTraceWriter();
HttpControllerTracer tracer = new HttpControllerTracer(mockController.Object, traceWriter);
TraceRecord[] expectedTraces = new TraceRecord[]
{
new TraceRecord(actionContext.Request, TraceCategories.ControllersCategory, TraceLevel.Info) { Kind = TraceKind.Begin },
new TraceRecord(actionContext.Request, TraceCategories.ControllersCategory, TraceLevel.Info) { Kind = TraceKind.End }
};
// Act
HttpResponseMessage actualResponse = ((IHttpController)tracer).ExecuteAsync(controllerContext, CancellationToken.None).Result;
// Assert
Assert.Equal<TraceRecord>(expectedTraces, traceWriter.Traces, new TraceRecordComparer());
Assert.Same(response, actualResponse);
}
public override IHttpController CreateController(HttpRequestMessage request)
{
IHttpController controller = null;
_traceWriter.TraceBeginEnd(
request,
TraceCategories.ControllersCategory,
TraceLevel.Info,
_innerDescriptor.GetType().Name,
CreateControllerMethodName,
beginTrace: null,
execute: () =>
{
controller = _innerDescriptor.CreateController(request);
},
endTrace: (tr) =>
{
tr.Message = controller == null
? SRResources.TraceNoneObjectMessage
: HttpControllerTracer.ActualControllerType(controller).FullName;
},
errorTrace: null);
if (controller != null && !(controller is HttpControllerTracer))
{
return(new HttpControllerTracer(request, controller, _traceWriter));
}
return(controller);
}
public void Decorator_GetInner_On_HttpControllerTracer_Returns_IHttpController()
{
// Arrange
IHttpController expectedInner = new Mock <IHttpController>().Object;
HttpControllerTracer productUnderTest = new HttpControllerTracer(new HttpRequestMessage(), expectedInner, new TestTraceWriter());
// Act
IHttpController actualInner = Decorator.GetInner(productUnderTest as IHttpController);
// Assert
Assert.Same(expectedInner, actualInner);
}
public void Dispose_DoesNotTraceWhenControllerIsNotDisposable()
{
// Arrange
var mockController = new Mock<IHttpController>();
var request = new HttpRequestMessage();
var traceWriter = new TestTraceWriter();
var tracer = new HttpControllerTracer(request, mockController.Object, traceWriter);
// Act
((IDisposable)tracer).Dispose();
// Assert
Assert.Empty(traceWriter.Traces);
}
public void Dispose_DoesNotTraceWhenControllerIsNotDisposable()
{
// Arrange
var mockController = new Mock <IHttpController>();
var request = new HttpRequestMessage();
var traceWriter = new TestTraceWriter();
var tracer = new HttpControllerTracer(request, mockController.Object, traceWriter);
// Act
((IDisposable)tracer).Dispose();
// Assert
Assert.Empty(traceWriter.Traces);
}
public void ExecuteAsync_Faults_And_Traces_When_Inner_Faults()
{
// Arrange
InvalidOperationException exception = new InvalidOperationException();
TaskCompletionSource <HttpResponseMessage> tcs = new TaskCompletionSource <HttpResponseMessage>();
tcs.TrySetException(exception);
Mock <ApiController> mockController = new Mock <ApiController>()
{
CallBase = true
};
mockController.Setup(b => b.ExecuteAsync(It.IsAny <HttpControllerContext>(), It.IsAny <CancellationToken>())).Returns(tcs.Task);
HttpRequestMessage request = new HttpRequestMessage();
HttpControllerContext controllerContext = ContextUtil.CreateControllerContext(request: request);
controllerContext.ControllerDescriptor = _controllerDescriptor;
controllerContext.Controller = mockController.Object;
HttpActionContext actionContext = ContextUtil.CreateActionContext(controllerContext, actionDescriptor: _mockActionDescriptor.Object);
TestTraceWriter traceWriter = new TestTraceWriter();
HttpControllerTracer tracer = new HttpControllerTracer(request, mockController.Object, traceWriter);
TraceRecord[] expectedTraces = new TraceRecord[]
{
new TraceRecord(actionContext.Request, TraceCategories.ControllersCategory, TraceLevel.Info)
{
Kind = TraceKind.Begin
},
new TraceRecord(actionContext.Request, TraceCategories.ControllersCategory, TraceLevel.Error)
{
Kind = TraceKind.End
}
};
// Act
Exception thrown = Assert.Throws <InvalidOperationException>(() => ((IHttpController)tracer).ExecuteAsync(controllerContext, CancellationToken.None).Wait());
// Assert
Assert.Equal <TraceRecord>(expectedTraces, traceWriter.Traces, new TraceRecordComparer());
Assert.Same(exception, thrown);
Assert.Same(exception, traceWriter.Traces[1].Exception);
}
public async Task ExecuteAsync_Invokes_Inner_And_Traces()
{
// Arrange
HttpResponseMessage response = new HttpResponseMessage();
Mock <ApiController> mockController = new Mock <ApiController>()
{
CallBase = true
};
mockController.Setup(b => b.ExecuteAsync(It.IsAny <HttpControllerContext>(), It.IsAny <CancellationToken>())).Returns(Task.FromResult <HttpResponseMessage>(response));
HttpRequestMessage request = new HttpRequestMessage();
HttpControllerContext controllerContext = ContextUtil.CreateControllerContext(request: request);
controllerContext.ControllerDescriptor = _controllerDescriptor;
controllerContext.Controller = mockController.Object;
HttpActionContext actionContext = ContextUtil.CreateActionContext(controllerContext, actionDescriptor: _mockActionDescriptor.Object);
TestTraceWriter traceWriter = new TestTraceWriter();
HttpControllerTracer tracer = new HttpControllerTracer(request, mockController.Object, traceWriter);
TraceRecord[] expectedTraces = new TraceRecord[]
{
new TraceRecord(actionContext.Request, TraceCategories.ControllersCategory, TraceLevel.Info)
{
Kind = TraceKind.Begin
},
new TraceRecord(actionContext.Request, TraceCategories.ControllersCategory, TraceLevel.Info)
{
Kind = TraceKind.End
}
};
// Act
var task = ((IHttpController)tracer).ExecuteAsync(controllerContext, CancellationToken.None);
HttpResponseMessage actualResponse = await task;
// Assert
Assert.Equal <TraceRecord>(expectedTraces, traceWriter.Traces, new TraceRecordComparer());
Assert.Same(response, actualResponse);
}
void IHttpControllerFactory.ReleaseController(HttpControllerContext controllerContext, IHttpController controller)
{
_traceWriter.TraceBeginEnd(
controllerContext.Request,
TraceCategories.ControllersCategory,
TraceLevel.Info,
_innerFactory.GetType().Name,
ReleaseControllerMethodName,
beginTrace: (tr) =>
{
tr.Message = HttpControllerTracer.ActualControllerType(controller).FullName;
},
execute: () =>
{
IHttpController actualController = HttpControllerTracer.ActualController(controller);
_innerFactory.ReleaseController(controllerContext, actualController);
},
endTrace: null,
errorTrace: null);
}
public void Dispose_TracesAndInvokesInnerDisposeWhenControllerIsDisposable()
{
// Arrange
var mockController = new Mock<IHttpController>();
var mockDisposable = mockController.As<IDisposable>();
var request = new HttpRequestMessage();
var traceWriter = new TestTraceWriter();
var tracer = new HttpControllerTracer(request, mockController.Object, traceWriter);
var expectedTraces = new[]
{
new TraceRecord(request, TraceCategories.ControllersCategory, TraceLevel.Info) { Kind = TraceKind.Begin, Operation = "Dispose" },
new TraceRecord(request, TraceCategories.ControllersCategory, TraceLevel.Info) { Kind = TraceKind.End, Operation = "Dispose" }
};
// Act
((IDisposable)tracer).Dispose();
// Assert
Assert.Equal(expectedTraces, traceWriter.Traces, new TraceRecordComparer());
mockDisposable.Verify(d => d.Dispose(), Times.Once());
}
public void ExecuteAsync_IsCancelled_And_Traces_When_Inner_IsCancelled()
{
// Arrange
Mock <ApiController> mockController = new Mock <ApiController>()
{
CallBase = true
};
mockController.Setup(b => b.ExecuteAsync(It.IsAny <HttpControllerContext>(), It.IsAny <CancellationToken>())).Returns(TaskHelpers.Canceled <HttpResponseMessage>());
HttpRequestMessage request = new HttpRequestMessage();
HttpControllerContext controllerContext = ContextUtil.CreateControllerContext(request: request);
controllerContext.ControllerDescriptor = _controllerDescriptor;
controllerContext.Controller = mockController.Object;
HttpActionContext actionContext = ContextUtil.CreateActionContext(controllerContext, actionDescriptor: _mockActionDescriptor.Object);
TestTraceWriter traceWriter = new TestTraceWriter();
HttpControllerTracer tracer = new HttpControllerTracer(request, mockController.Object, traceWriter);
TraceRecord[] expectedTraces = new TraceRecord[]
{
new TraceRecord(actionContext.Request, TraceCategories.ControllersCategory, TraceLevel.Info)
{
Kind = TraceKind.Begin
},
new TraceRecord(actionContext.Request, TraceCategories.ControllersCategory, TraceLevel.Warn)
{
Kind = TraceKind.End
}
};
// Act
Task task = ((IHttpController)tracer).ExecuteAsync(controllerContext, CancellationToken.None);
Exception thrown = Assert.Throws <TaskCanceledException>(() => task.Wait());
// Assert
Assert.Equal <TraceRecord>(expectedTraces, traceWriter.Traces, new TraceRecordComparer());
}
IHttpController IHttpControllerFactory.CreateController(HttpControllerContext controllerContext, string controllerName)
{
IHttpController controller = null;
_traceWriter.TraceBeginEnd(
controllerContext.Request,
TraceCategories.ControllersCategory,
TraceLevel.Info,
_innerFactory.GetType().Name,
CreateControllerMethodName,
beginTrace: (tr) =>
{
tr.Message = Error.Format(
SRResources.TraceControllerNameAndRouteMessage,
controllerName,
FormattingUtilities.RouteToString(controllerContext.RouteData));
},
execute: () =>
{
controller = _innerFactory.CreateController(controllerContext, controllerName);
},
endTrace: (tr) =>
{
tr.Message = controller == null
? SRResources.TraceNoneObjectMessage
: HttpControllerTracer.ActualControllerType(controller).FullName;
},
errorTrace: null);
if (controller != null && !(controller is HttpControllerTracer))
{
controller = new HttpControllerTracer(controller, _traceWriter);
}
return controller;
}
IHttpController IHttpControllerFactory.CreateController(HttpControllerContext controllerContext, string controllerName)
{
IHttpController controller = null;
_traceWriter.TraceBeginEnd(
controllerContext.Request,
TraceCategories.ControllersCategory,
TraceLevel.Info,
_innerFactory.GetType().Name,
CreateControllerMethodName,
beginTrace: (tr) =>
{
tr.Message = Error.Format(
SRResources.TraceControllerNameAndRouteMessage,
controllerName,
FormattingUtilities.RouteToString(controllerContext.RouteData));
},
execute: () =>
{
controller = _innerFactory.CreateController(controllerContext, controllerName);
},
endTrace: (tr) =>
{
tr.Message = controller == null
? SRResources.TraceNoneObjectMessage
: HttpControllerTracer.ActualControllerType(controller).FullName;
},
errorTrace: null);
if (controller != null && !(controller is HttpControllerTracer))
{
controller = new HttpControllerTracer(controller, _traceWriter);
}
return(controller);
}
public void ExecuteAsync_RemovesInnerControllerFromReleaseListAndAddsItselfInstead()
{
// Arrange
var request = new HttpRequestMessage();
var context = ContextUtil.CreateControllerContext(request: request);
var mockController = new Mock<IHttpController>();
var mockDisposable = mockController.As<IDisposable>();
mockController.Setup(c => c.ExecuteAsync(context, CancellationToken.None))
.Callback<HttpControllerContext, CancellationToken>((cc, ct) => cc.Request.RegisterForDispose(mockDisposable.Object))
.Returns(() => TaskHelpers.FromResult(new HttpResponseMessage()))
.Verifiable();
context.ControllerDescriptor = _controllerDescriptor;
context.Controller = mockController.Object;
var traceWriter = new TestTraceWriter();
var tracer = new HttpControllerTracer(request, mockController.Object, traceWriter);
// Act
((IHttpController)tracer).ExecuteAsync(context, CancellationToken.None).WaitUntilCompleted();
// Assert
IEnumerable<IDisposable> disposables = (IEnumerable<IDisposable>)request.Properties[HttpPropertyKeys.DisposableRequestResourcesKey];
Assert.Contains(tracer, disposables);
Assert.DoesNotContain(mockDisposable.Object, disposables);
}
public static IHttpController ActualController(IHttpController controller)
{
HttpControllerTracer tracer = controller as HttpControllerTracer;
return(tracer == null ? controller : tracer._innerController);
}
public void Decorator_GetInner_On_HttpControllerTracer_Returns_IHttpController()
{
// Arrange
IHttpController expectedInner = new Mock<IHttpController>().Object;
HttpControllerTracer productUnderTest = new HttpControllerTracer(new HttpRequestMessage(), expectedInner, new TestTraceWriter());
// Act
IHttpController actualInner = Decorator.GetInner(productUnderTest as IHttpController);
// Assert
Assert.Same(expectedInner, actualInner);
}
public void ExecuteAsync_IsCancelled_And_Traces_When_Inner_IsCancelled()
{
// Arrange
Mock<ApiController> mockController = new Mock<ApiController>() { CallBase = true };
mockController.Setup(b => b.ExecuteAsync(It.IsAny<HttpControllerContext>(), It.IsAny<CancellationToken>())).Returns(TaskHelpers.Canceled<HttpResponseMessage>());
HttpRequestMessage request = new HttpRequestMessage();
HttpControllerContext controllerContext = ContextUtil.CreateControllerContext(request: request);
controllerContext.ControllerDescriptor = _controllerDescriptor;
controllerContext.Controller = mockController.Object;
HttpActionContext actionContext = ContextUtil.CreateActionContext(controllerContext, actionDescriptor: _mockActionDescriptor.Object);
TestTraceWriter traceWriter = new TestTraceWriter();
HttpControllerTracer tracer = new HttpControllerTracer(request, mockController.Object, traceWriter);
TraceRecord[] expectedTraces = new TraceRecord[]
{
new TraceRecord(actionContext.Request, TraceCategories.ControllersCategory, TraceLevel.Info) { Kind = TraceKind.Begin },
new TraceRecord(actionContext.Request, TraceCategories.ControllersCategory, TraceLevel.Warn) { Kind = TraceKind.End }
};
// Act
Task task = ((IHttpController)tracer).ExecuteAsync(controllerContext, CancellationToken.None);
Exception thrown = Assert.Throws<TaskCanceledException>(() => task.Wait());
// Assert
Assert.Equal<TraceRecord>(expectedTraces, traceWriter.Traces, new TraceRecordComparer());
}
