public async Task 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(() => Task.FromResult(new HttpResponseMessage()))
.Verifiable();
context.ControllerDescriptor = _controllerDescriptor;
context.Controller = mockController.Object;
var traceWriter = new TestTraceWriter();
var tracer = new HttpControllerTracer(request, mockController.Object, traceWriter);
// Act
var controller = (IHttpController)tracer;
await controller.ExecuteAsync(context, CancellationToken.None);
// Assert
IEnumerable <IDisposable> disposables = (IEnumerable <IDisposable>)request.Properties[HttpPropertyKeys.DisposableRequestResourcesKey];
Assert.Contains(tracer, disposables);
Assert.DoesNotContain(mockDisposable.Object, disposables);
}
public void TestInit()
{
userService = new Mock <IUserService>();
controller = new UsersController(userService.Object);
controller.ControllerContext = ContextUtil.CreateControllerContext();
userService.Setup(x => x.GetUsersAsync(It.IsAny <QueryableOperator <UserDTO> >()))
.ReturnsAsync(new PagedQueryResults <UserDTO>(0, new List <UserDTO>()));
}
protected override void Given()
{
var ac = ContextUtil.CreateActionContext();
var cc = ContextUtil.CreateControllerContext(request: GivenRequest());
ac.SetPrivateFieldValue("_controllerContext", cc);
Context = ContextUtil.CreateActionExecutedConected(GivenException(), ac);
base.Given();
}
protected override void Given()
{
Context = ContextUtil.CreateActionContext();
Context.SetPrivateFieldValue("_modelState", GivenModelState());
var cc = ContextUtil.CreateControllerContext(request: GivenRequest());
Context.SetPrivateFieldValue("_controllerContext", cc);
base.Given();
}
private HttpControllerContext CreateControllerContext(string controllerName, Type controllerType)
{
ComplexTypeAwareActionSelector actionSelector = new ComplexTypeAwareActionSelector();
HttpControllerContext controllerContext = ContextUtil.CreateControllerContext();
HttpControllerDescriptor controllerDescriptor = new HttpControllerDescriptor(controllerContext.Configuration, controllerName, controllerType);
controllerDescriptor.Configuration.Services.Replace(typeof(IHttpActionSelector), actionSelector);
controllerContext.ControllerDescriptor = controllerDescriptor;
return(controllerContext);
}
private HttpResponseMessage RequestSingleProject(string name)
{
var uri = "http://localhost/api/projects/" + name;
var ctrler = new ProjectsController
{
Configuration = new HttpConfiguration(),
Request = new HttpRequestMessage(),
ActionContext = ContextUtil.CreateActionContext(ContextUtil.CreateControllerContext(request: new HttpRequestMessage(HttpMethod.Get, uri)))
};
return(ctrler.FindSingleProject(name).Result);
}
private static HttpActionExecutedContext GetActionExecutedContext <TResponse>(string uri, TResponse result)
{
var request = new HttpRequestMessage(HttpMethod.Get, uri);
var actionContext = ContextUtil.CreateActionContext(ContextUtil.CreateControllerContext(request: request));
var response = request.CreateResponse <TResponse>(HttpStatusCode.OK, result);
var actionExecutedContext = new HttpActionExecutedContext {
ActionContext = actionContext, Response = response
};
actionContext.ActionDescriptor.Configuration = request.GetConfiguration();
return(actionExecutedContext);
}
public void Decorator_GetInner_On_HttpActionDescriptorTracer_Returns_HttpActionDescriptor()
{
// Arrange
HttpActionDescriptor expectedInner = new Mock <HttpActionDescriptor>().Object;
HttpControllerContext controllerContext = ContextUtil.CreateControllerContext();
HttpActionDescriptorTracer productUnderTest = new HttpActionDescriptorTracer(controllerContext, expectedInner, new TestTraceWriter());
// Act
HttpActionDescriptor actualInner = Decorator.GetInner(productUnderTest as HttpActionDescriptor);
// Assert
Assert.Same(expectedInner, actualInner);
}
public Task ApiControllerBase_InvokesOnControllerExecuted()
{
//Arrange
var fakeController = new FakeOKController();
var controllerContext = ContextUtil.CreateControllerContext(fakeController, "FakeOk", typeof(FakeOKController));
//Act
return(fakeController.ExecuteAsync(controllerContext, CancellationToken.None)
//Assert
.ContinueWith(task => {
Assert.True(fakeController.OnControllerExecutedInvoked);
}));
}
public Task ApiControllerBase_InvokesActionIfOnControllerExecutingDoesNotTerminate()
{
//Arrange
var fakeController = new FakeOKController();
var controllerContext = ContextUtil.CreateControllerContext(fakeController, "FakeOk", typeof(FakeOKController));
//Act
return(fakeController.ExecuteAsync(controllerContext, CancellationToken.None)
//Assert
.ContinueWith(task => {
Assert.Equal(HttpStatusCode.OK, task.Result.StatusCode);
Assert.Equal("Hello World", ((StringContent)task.Result.Content).ReadAsStringAsync().Result);
}));
}
public HttpActionSelectorTracerTest()
{
_mockActionDescriptor = new Mock <HttpActionDescriptor>()
{
CallBase = true
};
_mockActionDescriptor.Setup(a => a.ActionName).Returns("test");
_mockActionDescriptor.Setup(a => a.GetParameters()).Returns(new Collection <HttpParameterDescriptor>(new HttpParameterDescriptor[0]));
_controllerDescriptor = new HttpControllerDescriptor(new HttpConfiguration(), "controller", typeof(ApiController));
_controllerContext = ContextUtil.CreateControllerContext(request: new HttpRequestMessage());
_controllerContext.ControllerDescriptor = _controllerDescriptor;
_actionContext = ContextUtil.CreateActionContext(_controllerContext, actionDescriptor: _mockActionDescriptor.Object);
}
public void ExecuteAsync_Invokes_Inner_ExecuteAsync()
{
// Arrange
var cts = new CancellationTokenSource();
var mockActionDescriptor = new Mock<HttpActionDescriptor>() { CallBase = true };
mockActionDescriptor.Setup(a => a.ActionName).Returns("test");
var controllerContext = ContextUtil.CreateControllerContext();
controllerContext.ControllerDescriptor = new HttpControllerDescriptor(controllerContext.Configuration, "test", typeof(ApiController));
var arguments = new Dictionary<string, object>();
var tracer = new HttpActionDescriptorTracer(controllerContext, mockActionDescriptor.Object, new TestTraceWriter());
// Act
tracer.ExecuteAsync(controllerContext, arguments, cts.Token);
// Assert
mockActionDescriptor.Verify(a => a.ExecuteAsync(controllerContext, arguments, cts.Token), Times.Once());
}
private HttpResponseMessage RequestAllProjects()
{
var uri = "http://localhost/api/projects/";
var ctrler = new ProjectsController
{
Configuration = new HttpConfiguration(),
Request = new HttpRequestMessage(),
ControllerContext = ContextUtil.CreateControllerContext(request: new HttpRequestMessage(HttpMethod.Get, uri))
};
//configuração para a lib DRUM
ctrler.Configuration.MapHttpAttributeRoutesAndUseUriMaker(new DefaultDirectRouteProvider());
ctrler.Configuration.EnsureInitialized();
//ctrler.Request.SetConfiguration(new HttpConfiguration());
return(ctrler.GetProjects(0).Result);
}
public Task ApiControllerBase_DoesNotInvokeActionIfOnControllerExecutingThrowsException()
{
//Arrange
var fakeController = new FakeExceptionController();
var controllerContext = ContextUtil.CreateControllerContext(fakeController, "FakeException", typeof(FakeExceptionController));
//Act
return(fakeController.ExecuteAsync(controllerContext, CancellationToken.None)
//Assert
.ContinueWith(task => {
Assert.True(fakeController.OnControllerExecutingInvoked);
Assert.True(fakeController.OnControllerExecutedInvoked);
Assert.False(fakeController.IsActionInvoked);
Assert.Equal(TaskStatus.Faulted, task.Status);
}));
}
public Task ApiControllerBase_DoesNotInvokeActionIfOnControllerExecutingTerminates()
{
//Arrange
var fakeController = new FakeTerminatedController();
var controllerContext = ContextUtil.CreateControllerContext(fakeController, "FakeTerminated", typeof(FakeTerminatedController));
//Act
return(fakeController.ExecuteAsync(controllerContext, CancellationToken.None)
//Assert
.ContinueWith(task => {
Assert.True(fakeController.OnControllerExecutingInvoked);
Assert.True(fakeController.OnControllerExecutedInvoked);
Assert.False(fakeController.IsActionInvoked);
Assert.Equal(HttpStatusCode.NotAcceptable, task.Result.StatusCode);
}));
}
public HttpActionInvokerTracerTest()
{
UsersController controller = new UsersController();
_apiController = controller;
Func <HttpResponseMessage> actionMethod = controller.Get;
_actionContext = ContextUtil.CreateActionContext(
ContextUtil.CreateControllerContext(instance: _apiController),
new ReflectedHttpActionDescriptor {
MethodInfo = actionMethod.Method
});
HttpRequestMessage request = new HttpRequestMessage();
_actionContext.ControllerContext.Request = request;
}
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 void GetFilters_Returns_Wrapped_IFilters()
{
// Arrange
Mock<IFilter> mockFilter = new Mock<IFilter>();
Collection<IFilter> filters = new Collection<IFilter>(new IFilter[] { mockFilter.Object });
Mock<HttpActionDescriptor> mockActionDescriptor = new Mock<HttpActionDescriptor>() { CallBase = true };
mockActionDescriptor.Setup(a => a.ActionName).Returns("test");
mockActionDescriptor.Setup(a => a.GetFilters()).Returns(filters);
HttpControllerContext controllerContext = ContextUtil.CreateControllerContext();
controllerContext.ControllerDescriptor = new HttpControllerDescriptor(controllerContext.Configuration, "test", typeof(ApiController));
HttpActionDescriptorTracer tracer = new HttpActionDescriptorTracer(controllerContext, mockActionDescriptor.Object, new TestTraceWriter());
// Act
IFilter[] wrappedFilters = tracer.GetFilters().ToArray();
// Assert
Assert.IsType<FilterTracer>(wrappedFilters[0]);
}
public void GetFilterPipeline_Returns_Wrapped_Filters()
{
// Arrange
Mock<IFilter> mockFilter = new Mock<IFilter>();
FilterInfo filter = new FilterInfo(mockFilter.Object, FilterScope.Global);
Collection<FilterInfo> filterCollection = new Collection<FilterInfo>(new FilterInfo[] { filter });
Mock<HttpActionDescriptor> mockActionDescriptor = new Mock<HttpActionDescriptor>() { CallBase = true };
mockActionDescriptor.Setup(a => a.ActionName).Returns("test");
mockActionDescriptor.Setup(a => a.GetFilterPipeline()).Returns(filterCollection);
HttpControllerContext controllerContext = ContextUtil.CreateControllerContext();
controllerContext.ControllerDescriptor = new HttpControllerDescriptor(controllerContext.Configuration, "test", typeof(ApiController));
HttpActionDescriptorTracer tracer = new HttpActionDescriptorTracer(controllerContext, mockActionDescriptor.Object, new TestTraceWriter());
// Act
Collection<FilterInfo> wrappedFilterCollection = tracer.GetFilterPipeline();
// Assert
Assert.IsType<FilterTracer>(wrappedFilterCollection[0].Instance);
}
public void GetBinding_Returns_HttpActionBindingTracer()
{
// Arrange
Mock <HttpActionDescriptor> mockActionDescriptor = new Mock <HttpActionDescriptor>()
{
CallBase = true
};
mockActionDescriptor.Setup(a => a.ActionName).Returns("test");
mockActionDescriptor.Setup(a => a.GetParameters()).Returns(new Collection <HttpParameterDescriptor>(new HttpParameterDescriptor[0]));
Mock <HttpParameterDescriptor> mockParameterDescriptor = new Mock <HttpParameterDescriptor>()
{
CallBase = true
};
Mock <HttpParameterBinding> mockParameterBinding = new Mock <HttpParameterBinding>(mockParameterDescriptor.Object)
{
CallBase = true
};
HttpActionBinding actionBinding = new HttpActionBinding(mockActionDescriptor.Object, new HttpParameterBinding[] { mockParameterBinding.Object });
HttpControllerDescriptor controllerDescriptor = new HttpControllerDescriptor(new HttpConfiguration(), "controller", typeof(ApiController));
HttpControllerContext controllerContext = ContextUtil.CreateControllerContext(request: new HttpRequestMessage());
controllerContext.ControllerDescriptor = controllerDescriptor;
Mock <IActionValueBinder> mockBinder = new Mock <IActionValueBinder>()
{
CallBase = true
};
mockBinder.Setup(b => b.GetBinding(It.IsAny <HttpActionDescriptor>())).Returns(actionBinding);
ActionValueBinderTracer tracer = new ActionValueBinderTracer(mockBinder.Object, new TestTraceWriter());
// Act
HttpActionBinding actualBinding = ((IActionValueBinder)tracer).GetBinding(mockActionDescriptor.Object);
// Assert
Assert.IsType <HttpActionBindingTracer>(actualBinding);
Assert.Same(mockActionDescriptor.Object, actualBinding.ActionDescriptor);
}
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);
}
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());
}
public void ExecuteAsync_Throws_What_Inner_Throws_And_Traces()
{
// Arrange
Mock <HttpActionDescriptor> mockActionDescriptor = new Mock <HttpActionDescriptor>()
{
CallBase = true
};
InvalidOperationException exception = new InvalidOperationException("test");
mockActionDescriptor.Setup(
a => a.ExecuteAsync(It.IsAny <HttpControllerContext>(), It.IsAny <IDictionary <string, object> >())).Throws(exception);
mockActionDescriptor.Setup(a => a.ActionName).Returns("test");
HttpControllerContext controllerContext = ContextUtil.CreateControllerContext();
controllerContext.ControllerDescriptor = new HttpControllerDescriptor(controllerContext.Configuration, "test", typeof(ApiController));
IDictionary <string, object> arguments = new Dictionary <string, object>();
TestTraceWriter traceWriter = new TestTraceWriter();
HttpActionDescriptorTracer tracer = new HttpActionDescriptorTracer(controllerContext, mockActionDescriptor.Object, traceWriter);
TraceRecord[] expectedTraces = new TraceRecord[]
{
new TraceRecord(controllerContext.Request, TraceCategories.ActionCategory, TraceLevel.Info)
{
Kind = TraceKind.Begin
},
new TraceRecord(controllerContext.Request, TraceCategories.ActionCategory, TraceLevel.Error)
{
Kind = TraceKind.End
}
};
// Act & Assert
Assert.Throws <InvalidOperationException>(() => tracer.ExecuteAsync(controllerContext, arguments));
// Assert
Assert.Equal <TraceRecord>(expectedTraces, traceWriter.Traces, new TraceRecordComparer());
Assert.Same(exception, traceWriter.Traces[1].Exception);
}
public void ExecuteAsync_Traces()
{
// Arrange
Mock <HttpActionDescriptor> mockActionDescriptor = new Mock <HttpActionDescriptor>()
{
CallBase = true
};
mockActionDescriptor.Setup(a => a.ActionName).Returns("test");
mockActionDescriptor.Setup(a => a.ExecuteAsync(It.IsAny <HttpControllerContext>(), It.IsAny <IDictionary <string, object> >()))
.Returns(TaskHelpers.FromResult <object>(null));
HttpControllerContext controllerContext = ContextUtil.CreateControllerContext();
controllerContext.ControllerDescriptor = new HttpControllerDescriptor(controllerContext.Configuration, "test", typeof(ApiController));
IDictionary <string, object> arguments = new Dictionary <string, object>();
TestTraceWriter traceWriter = new TestTraceWriter();
HttpActionDescriptorTracer tracer = new HttpActionDescriptorTracer(controllerContext, mockActionDescriptor.Object, traceWriter);
TraceRecord[] expectedTraces = new TraceRecord[]
{
new TraceRecord(controllerContext.Request, TraceCategories.ActionCategory, TraceLevel.Info)
{
Kind = TraceKind.Begin, Operation = "ExecuteAsync"
},
new TraceRecord(controllerContext.Request, TraceCategories.ActionCategory, TraceLevel.Info)
{
Kind = TraceKind.End
}
};
// Act
var result = tracer.ExecuteAsync(controllerContext, arguments);
// Assert
result.WaitUntilCompleted();
Assert.Equal <TraceRecord>(expectedTraces, traceWriter.Traces, new TraceRecordComparer());
}
public void ExecuteAsync_Invokes_Inner_ExecuteAsync()
{
// Arrange
bool executeCalled = false;
Mock <HttpActionDescriptor> mockActionDescriptor = new Mock <HttpActionDescriptor>()
{
CallBase = true
};
mockActionDescriptor.Setup(a => a.ActionName).Returns("test");
mockActionDescriptor.Setup(
a => a.ExecuteAsync(It.IsAny <HttpControllerContext>(), It.IsAny <IDictionary <string, object> >())).Callback(() => executeCalled = true);
HttpControllerContext controllerContext = ContextUtil.CreateControllerContext();
controllerContext.ControllerDescriptor = new HttpControllerDescriptor(controllerContext.Configuration, "test", typeof(ApiController));
IDictionary <string, object> arguments = new Dictionary <string, object>();
HttpActionDescriptorTracer tracer = new HttpActionDescriptorTracer(controllerContext, mockActionDescriptor.Object, new TestTraceWriter());
// Act
tracer.ExecuteAsync(controllerContext, arguments);
// Assert
Assert.True(executeCalled);
}
private static HttpControllerContext GetHttpControllerContext()
{
return(ContextUtil.CreateControllerContext());
}
HttpActionContext SetupContext(string uri)
{
return(ContextUtil.CreateActionContext(ContextUtil.CreateControllerContext(request: new HttpRequestMessage(HttpMethod.Get, uri))));
}