public void InvokeActionMethodFilterAsynchronously_NormalExecutionNotCanceled()
{
// Arrange
bool nextInChainWasCalled = false;
bool onActionExecutingWasCalled = false;
bool onActionExecutedWasCalled = false;
ActionExecutingContext preContext = GetActionExecutingContext();
ActionFilterImpl actionFilter = new ActionFilterImpl()
{
OnActionExecutingImpl = _ => { onActionExecutingWasCalled = true; },
OnActionExecutedImpl = _ => { onActionExecutedWasCalled = true; }
};
// Act
Func <ActionExecutedContext> continuation = AsyncControllerActionInvoker.InvokeActionMethodFilterAsynchronously(actionFilter, preContext,
() => {
nextInChainWasCalled = true;
return(() => new ActionExecutedContext());
});
// Assert
Assert.IsTrue(nextInChainWasCalled);
Assert.IsTrue(onActionExecutingWasCalled, "OnActionExecuting() should've been called by the first invocation.");
Assert.IsFalse(onActionExecutedWasCalled, "OnActionExecuted() shouldn't have been called by the first invocation.");
continuation();
Assert.IsTrue(onActionExecutedWasCalled, "OnActionExecuted() should've been called by the second invocation.");
}
public void InvokeActionMethodFilterAsynchronously_NextInChainThrowsOnActionExecutedException_Handled()
{
// Arrange
ViewResult expectedResult = new ViewResult();
bool nextInChainWasCalled = false;
bool onActionExecutedWasCalled = false;
ActionExecutingContext preContext = GetActionExecutingContext();
ActionFilterImpl actionFilter = new ActionFilterImpl()
{
OnActionExecutedImpl = filterContext => {
onActionExecutedWasCalled = true;
Assert.IsNotNull(filterContext.Exception);
filterContext.ExceptionHandled = true;
filterContext.Result = expectedResult;
}
};
// Act & assert pre-execution
Func <ActionExecutedContext> continuation = AsyncControllerActionInvoker.InvokeActionMethodFilterAsynchronously(actionFilter, preContext,
() => () => {
nextInChainWasCalled = true;
throw new Exception("Some exception text.");
});
Assert.IsFalse(onActionExecutedWasCalled, "OnActionExecuted() shouldn't have been called yet.");
// Act & assert post-execution
ActionExecutedContext postContext = continuation();
Assert.IsTrue(nextInChainWasCalled, "Next in chain should've been called.");
Assert.IsTrue(onActionExecutedWasCalled, "OnActionExecuted() should've been called.");
Assert.AreEqual(expectedResult, postContext.Result);
}
public void InvokeActionMethodFilterAsynchronously_NextInChainThrowsOnActionExecutingException_NotHandled()
{
// Arrange
ViewResult expectedResult = new ViewResult();
bool nextInChainWasCalled = false;
bool onActionExecutingWasCalled = false;
bool onActionExecutedWasCalled = false;
ActionExecutingContext preContext = GetActionExecutingContext();
ActionFilterImpl actionFilter = new ActionFilterImpl()
{
OnActionExecutingImpl = filterContext => { onActionExecutingWasCalled = true; },
OnActionExecutedImpl = filterContext => { onActionExecutedWasCalled = true; }
};
// Act & assert
Assert.Throws <Exception>(
delegate
{
AsyncControllerActionInvoker.InvokeActionMethodFilterAsynchronously(
actionFilter, preContext,
() =>
{
nextInChainWasCalled = true;
throw new Exception("Some exception text.");
});
},
@"Some exception text.");
// Assert
Assert.True(nextInChainWasCalled);
Assert.True(onActionExecutingWasCalled);
Assert.True(onActionExecutedWasCalled);
}
public void InvokeActionMethodFilterAsynchronously_NextInChainThrowsOnActionExecutedException_ThreadAbort()
{
// Arrange
ViewResult expectedResult = new ViewResult();
bool onActionExecutedWasCalled = false;
ActionExecutingContext preContext = GetActionExecutingContext();
ActionFilterImpl actionFilter = new ActionFilterImpl()
{
OnActionExecutedImpl = filterContext => {
onActionExecutedWasCalled = true;
Thread.ResetAbort();
}
};
// Act & assert
Func <ActionExecutedContext> continuation = AsyncControllerActionInvoker.InvokeActionMethodFilterAsynchronously(actionFilter, preContext,
() => () => {
Thread.CurrentThread.Abort();
return(null);
});
ExceptionHelper.ExpectException <ThreadAbortException>(
delegate {
continuation();
});
// Assert
Assert.IsTrue(onActionExecutedWasCalled, "OnActionExecuted() should've been called.");
}
public void InvokeAction_AsyncControllerActionInvoker()
{
_controllerContext.Controller = new TestController();
var actionInvoker = new AsyncControllerActionInvoker();
IAsyncResult asyncResult = actionInvoker.BeginInvokeAction(_controllerContext, nameof(TestController.NormalAction), null, null);
var retVal = actionInvoker.EndInvokeAction(asyncResult);
}
public void InvokeAction_ThrowsIfControllerContextIsNull()
{
// Arrange
AsyncControllerActionInvoker invoker = new AsyncControllerActionInvoker();
// Act & assert
Assert.ThrowsArgumentNull(
delegate { invoker.BeginInvokeAction(null, "someAction", null, null); }, "controllerContext");
}
public void InvokeAction_ThrowsIfActionNameIsNull()
{
// Arrange
AsyncControllerActionInvoker invoker = new AsyncControllerActionInvoker();
// Act & assert
Assert.ThrowsArgumentNullOrEmpty(
delegate { invoker.BeginInvokeAction(new ControllerContext(), null, null, null); }, "actionName");
}
public void InvokeAction_ActionThrowsException_ThreadAbort()
{
// Arrange
ControllerContext controllerContext = GetControllerContext();
AsyncControllerActionInvoker invoker = new AsyncControllerActionInvoker();
// Act & assert
Assert.Throws<ThreadAbortException>(
delegate { invoker.BeginInvokeAction(controllerContext, "ActionCallsThreadAbort", null, null); });
}
public void InvokeAction_RequestValidationFails()
{
// Arrange
ControllerContext controllerContext = GetControllerContext(passesRequestValidation: false);
AsyncControllerActionInvoker invoker = new AsyncControllerActionInvoker();
// Act & assert
Assert.Throws <HttpRequestValidationException>(
delegate { invoker.BeginInvokeAction(controllerContext, "NormalAction", null, null); });
}
public void InvokeAction_ActionThrowsException_ThreadAbort()
{
// Arrange
ControllerContext controllerContext = GetControllerContext();
AsyncControllerActionInvoker invoker = new AsyncControllerActionInvoker();
// Act & assert
Assert.Throws <ThreadAbortException>(
delegate { invoker.BeginInvokeAction(controllerContext, "ActionCallsThreadAbort", null, null); });
}
public void InvokeAction_ThrowsIfActionNameIsEmpty()
{
// Arrange
AsyncControllerActionInvoker invoker = new AsyncControllerActionInvoker();
// Act & assert
ExceptionHelper.ExpectArgumentExceptionNullOrEmpty(
delegate {
invoker.BeginInvokeAction(new ControllerContext(), "", null, null);
}, "actionName");
}
public void InvokeAction_ActionThrowsException_NotHandled()
{
// Arrange
ControllerContext controllerContext = GetControllerContext();
AsyncControllerActionInvoker invoker = new AsyncControllerActionInvoker();
// Act & assert
Assert.Throws <Exception>(
delegate { invoker.BeginInvokeAction(controllerContext, "ActionThrowsExceptionAndIsNotHandled", null, null); },
@"Some exception text.");
}
private ActionResult BeingInvokeActionMethodWithFiltersTester(Func <IAsyncResult> beginFunction, Func <ActionResult> endFunction, bool checkBegin, bool checkEnd, IActionFilter[] filters)
{
AsyncControllerActionInvoker invoker = new AsyncControllerActionInvoker();
ControllerContext controllerContext = new ControllerContext();
Dictionary <string, object> parameters = new Dictionary <string, object>();
Mock <AsyncActionDescriptor> mockActionDescriptor = new Mock <AsyncActionDescriptor>();
bool endExecuteCalled = false;
bool beginExecuteCalled = false;
Func <ActionResult> endExecute = () =>
{
endExecuteCalled = true;
return(endFunction());
};
Func <IAsyncResult> beingExecute = () =>
{
beginExecuteCalled = true;
return(beginFunction());
};
mockActionDescriptor.Setup(d => d.BeginExecute(controllerContext, parameters, It.IsAny <AsyncCallback>(), It.IsAny <object>())).Returns(beingExecute);
mockActionDescriptor.Setup(d => d.EndExecute(It.IsAny <IAsyncResult>())).Returns(endExecute);
IAsyncResult outerAsyncResult = null;
try
{
outerAsyncResult = invoker.BeginInvokeActionMethodWithFilters(controllerContext, filters, mockActionDescriptor.Object, parameters, null, null);
}
catch (Exception ex)
{
if (checkEnd)
{
// Testing end, so not expecting exception thrown from begin
Assert.NotNull(ex);
}
else
{
throw ex;
}
}
Assert.NotNull(outerAsyncResult);
Assert.Equal(checkBegin, beginExecuteCalled);
Assert.False(endExecuteCalled);
ActionExecutedContext postContext = invoker.EndInvokeActionMethodWithFilters(outerAsyncResult);
Assert.NotNull(postContext);
if (checkEnd)
{
Assert.True(endExecuteCalled);
}
return(postContext.Result);
}
public void InvokeAction_ActionThrowsException_NotHandled()
{
// Arrange
ControllerContext controllerContext = GetControllerContext();
AsyncControllerActionInvoker invoker = new AsyncControllerActionInvoker();
// Act & assert
Assert.Throws<Exception>(
delegate { invoker.BeginInvokeAction(controllerContext, "ActionThrowsExceptionAndIsNotHandled", null, null); },
@"Some exception text.");
}
private static IEnumerable <ReflectedAsyncControllerDescriptor> GetControllerDescriptors(IEnumerable <Type> controllerTypes)
{
Contract.Assert(controllerTypes != null);
Func <Type, ControllerDescriptor> descriptorFactory = ReflectedAsyncControllerDescriptor.DefaultDescriptorFactory;
ControllerDescriptorCache descriptorsCache = new AsyncControllerActionInvoker().DescriptorCache;
return
(controllerTypes
.Select(type => descriptorsCache.GetDescriptor(type, descriptorFactory, type))
.Cast <ReflectedAsyncControllerDescriptor>());
}
public void InvokeAction_ActionNotFound() {
// Arrange
ControllerContext controllerContext = GetControllerContext();
AsyncControllerActionInvoker invoker = new AsyncControllerActionInvoker();
// Act
IAsyncResult asyncResult = invoker.BeginInvokeAction(controllerContext, "ActionNotFound", null, null);
bool retVal = invoker.EndInvokeAction(asyncResult);
// Assert
Assert.IsFalse(retVal);
}
public void InvokeAction_RequestValidationFails()
{
// Arrange
ControllerContext controllerContext = GetControllerContext(false /* passesRequestValidation */);
AsyncControllerActionInvoker invoker = new AsyncControllerActionInvoker();
// Act & assert
ExceptionHelper.ExpectException <HttpRequestValidationException>(
delegate {
invoker.BeginInvokeAction(controllerContext, "NormalAction", null, null);
});
}
public void InvokeAction_ActionNotFound()
{
// Arrange
ControllerContext controllerContext = GetControllerContext();
AsyncControllerActionInvoker invoker = new AsyncControllerActionInvoker();
// Act
IAsyncResult asyncResult = invoker.BeginInvokeAction(controllerContext, "ActionNotFound", null, null);
bool retVal = invoker.EndInvokeAction(asyncResult);
// Assert
Assert.IsFalse(retVal);
}
public void InvokeAction_ResultThrowsException_Handled()
{
// Arrange
ControllerContext controllerContext = GetControllerContext();
AsyncControllerActionInvoker invoker = new AsyncControllerActionInvoker();
// Act & assert
IAsyncResult asyncResult = invoker.BeginInvokeAction(controllerContext, "ResultThrowsExceptionAndIsHandled", null, null);
bool retVal = invoker.EndInvokeAction(asyncResult);
Assert.IsTrue(retVal);
Assert.AreEqual("From exception filter", ((TestController)controllerContext.Controller).Log);
}
public void InvokeAction_ActionThrowsException_Handled() {
// Arrange
ControllerContext controllerContext = GetControllerContext();
AsyncControllerActionInvoker invoker = new AsyncControllerActionInvoker();
// Act & assert
IAsyncResult asyncResult = invoker.BeginInvokeAction(controllerContext, "ActionThrowsExceptionAndIsHandled", null, null);
Assert.IsNull(((TestController)controllerContext.Controller).Log, "Result filter shouldn't have executed yet.");
bool retVal = invoker.EndInvokeAction(asyncResult);
Assert.IsTrue(retVal);
Assert.AreEqual("From exception filter", ((TestController)controllerContext.Controller).Log);
}
public void InvokeAction_AuthorizationFilterShortCircuits() {
// Arrange
ControllerContext controllerContext = GetControllerContext();
AsyncControllerActionInvoker invoker = new AsyncControllerActionInvoker();
// Act
IAsyncResult asyncResult = invoker.BeginInvokeAction(controllerContext, "AuthorizationFilterShortCircuits", null, null);
bool retVal = invoker.EndInvokeAction(asyncResult);
// Assert
Assert.IsTrue(retVal);
Assert.AreEqual("From authorization filter", ((TestController)controllerContext.Controller).Log);
}
public void InvokeAction_ResultThrowsException_ThreadAbort()
{
// Arrange
ControllerContext controllerContext = GetControllerContext();
AsyncControllerActionInvoker invoker = new AsyncControllerActionInvoker();
// Act & assert
IAsyncResult asyncResult = invoker.BeginInvokeAction(controllerContext, "ResultCallsThreadAbort", null, null);
ExceptionHelper.ExpectException <ThreadAbortException>(
delegate {
invoker.EndInvokeAction(asyncResult);
});
}
public void InvokeAction_NormalAction()
{
// Arrange
ControllerContext controllerContext = GetControllerContext();
AsyncControllerActionInvoker invoker = new AsyncControllerActionInvoker();
// Act
IAsyncResult asyncResult = invoker.BeginInvokeAction(controllerContext, "NormalAction", null, null);
bool retVal = invoker.EndInvokeAction(asyncResult);
// Assert
Assert.IsTrue(retVal);
Assert.AreEqual("From action", ((TestController)controllerContext.Controller).Log);
}
public void InvokeAction_AuthorizationFilterShortCircuits()
{
// Arrange
ControllerContext controllerContext = GetControllerContext();
AsyncControllerActionInvoker invoker = new AsyncControllerActionInvoker();
// Act
IAsyncResult asyncResult = invoker.BeginInvokeAction(controllerContext, "AuthorizationFilterShortCircuits", null, null);
bool retVal = invoker.EndInvokeAction(asyncResult);
// Assert
Assert.IsTrue(retVal);
Assert.AreEqual("From authorization filter", ((TestController)controllerContext.Controller).Log);
}
internal void AddRouteEntries(SubRouteCollection collector, IEnumerable <Type> controllerTypes)
{
ControllerDescriptorCache descriptorsCache = new AsyncControllerActionInvoker().DescriptorCache;
IEnumerable <ReflectedAsyncControllerDescriptor> descriptors = controllerTypes
.Select(
type =>
descriptorsCache.GetDescriptor(type, innerType => new ReflectedAsyncControllerDescriptor(innerType), type))
.Cast <ReflectedAsyncControllerDescriptor>();
foreach (ReflectedAsyncControllerDescriptor controllerDescriptor in descriptors)
{
AddRouteEntries(collector, controllerDescriptor);
}
}
public void InvokeAction_ResultThrowsException_NotHandled()
{
// Arrange
ControllerContext controllerContext = GetControllerContext();
AsyncControllerActionInvoker invoker = new AsyncControllerActionInvoker();
// Act & assert
IAsyncResult asyncResult = invoker.BeginInvokeAction(controllerContext, "ResultThrowsExceptionAndIsNotHandled", null, null);
ExceptionHelper.ExpectException <Exception>(
delegate {
invoker.EndInvokeAction(asyncResult);
},
@"Some exception text.");
}
public void InvokeAction_ActionThrowsException_Handled()
{
// Arrange
ControllerContext controllerContext = GetControllerContext();
AsyncControllerActionInvoker invoker = new AsyncControllerActionInvoker();
// Act & assert
IAsyncResult asyncResult = invoker.BeginInvokeAction(controllerContext, "ActionThrowsExceptionAndIsHandled", null, null);
Assert.Null(((TestController)controllerContext.Controller).Log); // Result filter shouldn't have executed yet
bool retVal = invoker.EndInvokeAction(asyncResult);
Assert.True(retVal);
Assert.Equal("From exception filter", ((TestController)controllerContext.Controller).Log);
}
public void InvokeActionMethodWithFilters_ShortCircuited()
{
// Arrange
List <string> actionLog = new List <string>();
ControllerContext controllerContext = new ControllerContext();
Dictionary <string, object> parameters = new Dictionary <string, object>();
ActionResult actionResult = new ViewResult();
ActionFilterImpl filter1 = new ActionFilterImpl()
{
OnActionExecutingImpl = delegate(ActionExecutingContext filterContext) {
actionLog.Add("OnActionExecuting1");
},
OnActionExecutedImpl = delegate(ActionExecutedContext filterContext) {
actionLog.Add("OnActionExecuted1");
}
};
ActionFilterImpl filter2 = new ActionFilterImpl()
{
OnActionExecutingImpl = delegate(ActionExecutingContext filterContext) {
actionLog.Add("OnActionExecuting2");
filterContext.Result = actionResult;
},
OnActionExecutedImpl = delegate(ActionExecutedContext filterContext) {
actionLog.Add("OnActionExecuted2");
}
};
Mock <AsyncActionDescriptor> mockActionDescriptor = new Mock <AsyncActionDescriptor>();
mockActionDescriptor.Expect(d => d.BeginExecute(controllerContext, parameters, It.IsAny <AsyncCallback>(), It.IsAny <object>())).Throws(new Exception("I shouldn't have been called."));
mockActionDescriptor.Expect(d => d.EndExecute(It.IsAny <IAsyncResult>())).Throws(new Exception("I shouldn't have been called."));
AsyncControllerActionInvoker invoker = new AsyncControllerActionInvoker();
IActionFilter[] filters = new IActionFilter[] { filter1, filter2 };
// Act
IAsyncResult outerAsyncResult = invoker.BeginInvokeActionMethodWithFilters(controllerContext, filters, mockActionDescriptor.Object, parameters, null, null);
ActionExecutedContext postContext = invoker.EndInvokeActionMethodWithFilters(outerAsyncResult);
// Assert
CollectionAssert.AreEqual(
new string[] { "OnActionExecuting1", "OnActionExecuting2", "OnActionExecuted1" },
actionLog);
Assert.AreEqual(actionResult, postContext.Result);
}
internal List <RouteEntry> MapMvcAttributeRoutes(IEnumerable <Type> controllerTypes)
{
ControllerDescriptorCache descriptorsCache = new AsyncControllerActionInvoker().DescriptorCache;
IEnumerable <ReflectedAsyncControllerDescriptor> descriptors = controllerTypes
.Select(
type =>
descriptorsCache.GetDescriptor(type, innerType => new ReflectedAsyncControllerDescriptor(innerType), type))
.Cast <ReflectedAsyncControllerDescriptor>();
List <RouteEntry> routeEntries = new List <RouteEntry>();
foreach (ReflectedAsyncControllerDescriptor controllerDescriptor in descriptors)
{
routeEntries.AddRange(MapMvcAttributeRoutes(controllerDescriptor));
}
return(routeEntries);
}
public void InvokeActionMethod_SynchronousDescriptor()
{
// Arrange
ControllerContext controllerContext = new ControllerContext();
Dictionary <string, object> parameters = new Dictionary <string, object>();
ActionResult expectedResult = new ViewResult();
Mock <ActionDescriptor> mockActionDescriptor = new Mock <ActionDescriptor>();
mockActionDescriptor.Expect(d => d.Execute(controllerContext, parameters)).Returns(expectedResult);
AsyncControllerActionInvoker invoker = new AsyncControllerActionInvoker();
// Act
IAsyncResult asyncResult = invoker.BeginInvokeActionMethod(controllerContext, mockActionDescriptor.Object, parameters, null, null);
ActionResult returnedResult = invoker.EndInvokeActionMethod(asyncResult);
// Assert
Assert.AreEqual(expectedResult, returnedResult);
}
public void InvokeActionMethodFilterAsynchronously_NextInChainThrowsOnActionExecutingException_Handled()
{
// Arrange
ViewResult expectedResult = new ViewResult();
bool nextInChainWasCalled = false;
bool onActionExecutingWasCalled = false;
bool onActionExecutedWasCalled = false;
ActionExecutingContext preContext = GetActionExecutingContext();
ActionFilterImpl actionFilter = new ActionFilterImpl()
{
OnActionExecutingImpl = filterContext => { onActionExecutingWasCalled = true; },
OnActionExecutedImpl = filterContext =>
{
onActionExecutedWasCalled = true;
Assert.NotNull(filterContext.Exception);
filterContext.ExceptionHandled = true;
filterContext.Result = expectedResult;
}
};
// Act
Func <ActionExecutedContext> continuation = AsyncControllerActionInvoker.InvokeActionMethodFilterAsynchronously(
actionFilter, preContext,
() =>
{
nextInChainWasCalled = true;
throw new Exception("Some exception text.");
});
// Assert
Assert.True(nextInChainWasCalled);
Assert.True(onActionExecutingWasCalled);
Assert.True(onActionExecutedWasCalled);
ActionExecutedContext postContext = continuation();
Assert.Equal(expectedResult, postContext.Result);
}
public void InvokeActionMethodFilterAsynchronously_NextInChainThrowsOnActionExecutingException_ThreadAbort()
{
// Arrange
ViewResult expectedResult = new ViewResult();
bool nextInChainWasCalled = false;
bool onActionExecutingWasCalled = false;
bool onActionExecutedWasCalled = false;
ActionExecutingContext preContext = GetActionExecutingContext();
ActionFilterImpl actionFilter = new ActionFilterImpl()
{
OnActionExecutingImpl = filterContext => { onActionExecutingWasCalled = true; },
OnActionExecutedImpl = filterContext =>
{
onActionExecutedWasCalled = true;
Thread.ResetAbort();
}
};
// Act & assert
Assert.Throws <ThreadAbortException>(
delegate
{
AsyncControllerActionInvoker.InvokeActionMethodFilterAsynchronously(
actionFilter, preContext,
() =>
{
nextInChainWasCalled = true;
Thread.CurrentThread.Abort();
return(null);
});
});
// Assert
Assert.True(nextInChainWasCalled);
Assert.True(onActionExecutingWasCalled);
Assert.True(onActionExecutedWasCalled);
}
public void InvokeActionMethod_AsynchronousDescriptor()
{
// Arrange
ControllerContext controllerContext = new ControllerContext();
Dictionary <string, object> parameters = new Dictionary <string, object>();
IAsyncResult innerAsyncResult = new MockAsyncResult();
ActionResult expectedResult = new ViewResult();
Mock <AsyncActionDescriptor> mockActionDescriptor = new Mock <AsyncActionDescriptor>();
mockActionDescriptor.Setup(d => d.BeginExecute(controllerContext, parameters, It.IsAny <AsyncCallback>(), It.IsAny <object>())).Returns(innerAsyncResult);
mockActionDescriptor.Setup(d => d.EndExecute(innerAsyncResult)).Returns(expectedResult);
AsyncControllerActionInvoker invoker = new AsyncControllerActionInvoker();
// Act
IAsyncResult asyncResult = invoker.BeginInvokeActionMethod(controllerContext, mockActionDescriptor.Object, parameters, null, null);
ActionResult returnedResult = invoker.EndInvokeActionMethod(asyncResult);
// Assert
Assert.Equal(expectedResult, returnedResult);
}
public void InvokeActionMethodFilterAsynchronously_OnActionExecutingSetsResult()
{
// Arrange
ViewResult expectedResult = new ViewResult();
bool nextInChainWasCalled = false;
bool onActionExecutingWasCalled = false;
bool onActionExecutedWasCalled = false;
ActionExecutingContext preContext = GetActionExecutingContext();
ActionFilterImpl actionFilter = new ActionFilterImpl()
{
OnActionExecutingImpl = filterContext =>
{
onActionExecutingWasCalled = true;
filterContext.Result = expectedResult;
},
OnActionExecutedImpl = _ => { onActionExecutedWasCalled = true; }
};
// Act
Func <ActionExecutedContext> continuation = AsyncControllerActionInvoker.InvokeActionMethodFilterAsynchronously(
actionFilter, preContext,
() =>
{
nextInChainWasCalled = true;
return(() => new ActionExecutedContext());
});
// Assert
Assert.False(nextInChainWasCalled);
Assert.True(onActionExecutingWasCalled);
Assert.False(onActionExecutedWasCalled);
ActionExecutedContext postContext = continuation();
Assert.False(onActionExecutedWasCalled);
Assert.Equal(expectedResult, postContext.Result);
}
public void InvokeActionMethodFilterAsynchronously_NextInChainThrowsOnActionExecutingException_ThreadAbort()
{
// Arrange
ViewResult expectedResult = new ViewResult();
bool nextInChainWasCalled = false;
bool onActionExecutingWasCalled = false;
bool onActionExecutedWasCalled = false;
ActionExecutingContext preContext = GetActionExecutingContext();
ActionFilterImpl actionFilter = new ActionFilterImpl()
{
OnActionExecutingImpl = filterContext => {
onActionExecutingWasCalled = true;
},
OnActionExecutedImpl = filterContext => {
onActionExecutedWasCalled = true;
Thread.ResetAbort();
}
};
// Act & assert
ExceptionHelper.ExpectException <ThreadAbortException>(
delegate {
AsyncControllerActionInvoker.InvokeActionMethodFilterAsynchronously(actionFilter, preContext,
() => {
nextInChainWasCalled = true;
Thread.CurrentThread.Abort();
return(null);
});
});
// Assert
Assert.IsTrue(nextInChainWasCalled, "Next in chain should've been called.");
Assert.IsTrue(onActionExecutingWasCalled, "OnActionExecuting() should've been called by the first invocation.");
Assert.IsTrue(onActionExecutedWasCalled, "OnActionExecuted() should've been called due to exception handling.");
}
public void InvokeActionMethodWithFilters()
{
// Arrange
List<string> actionLog = new List<string>();
ControllerContext controllerContext = new ControllerContext();
Dictionary<string, object> parameters = new Dictionary<string, object>();
MockAsyncResult innerAsyncResult = new MockAsyncResult();
ActionResult actionResult = new ViewResult();
ActionFilterImpl filter1 = new ActionFilterImpl()
{
OnActionExecutingImpl = delegate(ActionExecutingContext filterContext) { actionLog.Add("OnActionExecuting1"); },
OnActionExecutedImpl = delegate(ActionExecutedContext filterContext) { actionLog.Add("OnActionExecuted1"); }
};
ActionFilterImpl filter2 = new ActionFilterImpl()
{
OnActionExecutingImpl = delegate(ActionExecutingContext filterContext) { actionLog.Add("OnActionExecuting2"); },
OnActionExecutedImpl = delegate(ActionExecutedContext filterContext) { actionLog.Add("OnActionExecuted2"); }
};
Mock<AsyncActionDescriptor> mockActionDescriptor = new Mock<AsyncActionDescriptor>();
mockActionDescriptor.Setup(d => d.BeginExecute(controllerContext, parameters, It.IsAny<AsyncCallback>(), It.IsAny<object>())).Returns(innerAsyncResult);
mockActionDescriptor.Setup(d => d.EndExecute(innerAsyncResult)).Returns(actionResult);
AsyncControllerActionInvoker invoker = new AsyncControllerActionInvoker();
IActionFilter[] filters = new IActionFilter[] { filter1, filter2 };
// Act
IAsyncResult outerAsyncResult = invoker.BeginInvokeActionMethodWithFilters(controllerContext, filters, mockActionDescriptor.Object, parameters, null, null);
ActionExecutedContext postContext = invoker.EndInvokeActionMethodWithFilters(outerAsyncResult);
// Assert
Assert.Equal(new[] { "OnActionExecuting1", "OnActionExecuting2", "OnActionExecuted2", "OnActionExecuted1" }, actionLog.ToArray());
Assert.Equal(actionResult, postContext.Result);
}
public void InvokeActionMethod_SynchronousDescriptor()
{
// Arrange
ControllerContext controllerContext = new ControllerContext();
Dictionary<string, object> parameters = new Dictionary<string, object>();
ActionResult expectedResult = new ViewResult();
Mock<ActionDescriptor> mockActionDescriptor = new Mock<ActionDescriptor>();
mockActionDescriptor.Setup(d => d.Execute(controllerContext, parameters)).Returns(expectedResult);
AsyncControllerActionInvoker invoker = new AsyncControllerActionInvoker();
// Act
IAsyncResult asyncResult = invoker.BeginInvokeActionMethod(controllerContext, mockActionDescriptor.Object, parameters, null, null);
ActionResult returnedResult = invoker.EndInvokeActionMethod(asyncResult);
// Assert
Assert.Equal(expectedResult, returnedResult);
}
public void InvokeAction_ThrowsIfControllerContextIsNull()
{
// Arrange
AsyncControllerActionInvoker invoker = new AsyncControllerActionInvoker();
// Act & assert
Assert.ThrowsArgumentNull(
delegate { invoker.BeginInvokeAction(null, "someAction", null, null); }, "controllerContext");
}
public void InvokeAction_ThrowsIfActionNameIsNull()
{
// Arrange
AsyncControllerActionInvoker invoker = new AsyncControllerActionInvoker();
// Act & assert
Assert.ThrowsArgumentNullOrEmpty(
delegate { invoker.BeginInvokeAction(new ControllerContext(), null, null, null); }, "actionName");
}
public void InvokeAction_ResultThrowsException_Handled()
{
// Arrange
ControllerContext controllerContext = GetControllerContext();
AsyncControllerActionInvoker invoker = new AsyncControllerActionInvoker();
// Act & assert
IAsyncResult asyncResult = invoker.BeginInvokeAction(controllerContext, "ResultThrowsExceptionAndIsHandled", null, null);
bool retVal = invoker.EndInvokeAction(asyncResult);
Assert.True(retVal);
Assert.Equal("From exception filter", ((TestController)controllerContext.Controller).Log);
}
public void InvokeAction_RequestValidationFails() {
// Arrange
ControllerContext controllerContext = GetControllerContext(false /* passesRequestValidation */);
AsyncControllerActionInvoker invoker = new AsyncControllerActionInvoker();
// Act & assert
ExceptionHelper.ExpectException<HttpRequestValidationException>(
delegate {
invoker.BeginInvokeAction(controllerContext, "NormalAction", null, null);
});
}
public void InvokeAction_AuthenticationFilterChallenges()
{
// Arrange
ControllerContext controllerContext = GetControllerContext();
AsyncControllerActionInvoker invoker = new AsyncControllerActionInvoker();
// Act
IAsyncResult asyncResult = invoker.BeginInvokeAction(controllerContext, "AuthenticationFilterChallenges", null, null);
bool retVal = invoker.EndInvokeAction(asyncResult);
// Assert
Assert.True(retVal);
Assert.Equal("From authentication filter challenge", ((TestController)controllerContext.Controller).Log);
}
public void InvokeActionMethodWithFilters_ShortCircuited() {
// Arrange
List<string> actionLog = new List<string>();
ControllerContext controllerContext = new ControllerContext();
Dictionary<string, object> parameters = new Dictionary<string, object>();
ActionResult actionResult = new ViewResult();
ActionFilterImpl filter1 = new ActionFilterImpl() {
OnActionExecutingImpl = delegate(ActionExecutingContext filterContext) {
actionLog.Add("OnActionExecuting1");
},
OnActionExecutedImpl = delegate(ActionExecutedContext filterContext) {
actionLog.Add("OnActionExecuted1");
}
};
ActionFilterImpl filter2 = new ActionFilterImpl() {
OnActionExecutingImpl = delegate(ActionExecutingContext filterContext) {
actionLog.Add("OnActionExecuting2");
filterContext.Result = actionResult;
},
OnActionExecutedImpl = delegate(ActionExecutedContext filterContext) {
actionLog.Add("OnActionExecuted2");
}
};
Mock<AsyncActionDescriptor> mockActionDescriptor = new Mock<AsyncActionDescriptor>();
mockActionDescriptor.Expect(d => d.BeginExecute(controllerContext, parameters, It.IsAny<AsyncCallback>(), It.IsAny<object>())).Throws(new Exception("I shouldn't have been called."));
mockActionDescriptor.Expect(d => d.EndExecute(It.IsAny<IAsyncResult>())).Throws(new Exception("I shouldn't have been called."));
AsyncControllerActionInvoker invoker = new AsyncControllerActionInvoker();
IActionFilter[] filters = new IActionFilter[] { filter1, filter2 };
// Act
IAsyncResult outerAsyncResult = invoker.BeginInvokeActionMethodWithFilters(controllerContext, filters, mockActionDescriptor.Object, parameters, null, null);
ActionExecutedContext postContext = invoker.EndInvokeActionMethodWithFilters(outerAsyncResult);
// Assert
CollectionAssert.AreEqual(
new string[] { "OnActionExecuting1", "OnActionExecuting2", "OnActionExecuted1" },
actionLog);
Assert.AreEqual(actionResult, postContext.Result);
}
public void InvokeActionMethod_AsynchronousDescriptor() {
// Arrange
ControllerContext controllerContext = new ControllerContext();
Dictionary<string, object> parameters = new Dictionary<string, object>();
IAsyncResult innerAsyncResult = new MockAsyncResult();
ActionResult expectedResult = new ViewResult();
Mock<AsyncActionDescriptor> mockActionDescriptor = new Mock<AsyncActionDescriptor>();
mockActionDescriptor.Expect(d => d.BeginExecute(controllerContext, parameters, It.IsAny<AsyncCallback>(), It.IsAny<object>())).Returns(innerAsyncResult);
mockActionDescriptor.Expect(d => d.EndExecute(innerAsyncResult)).Returns(expectedResult);
AsyncControllerActionInvoker invoker = new AsyncControllerActionInvoker();
// Act
IAsyncResult asyncResult = invoker.BeginInvokeActionMethod(controllerContext, mockActionDescriptor.Object, parameters, null, null);
ActionResult returnedResult = invoker.EndInvokeActionMethod(asyncResult);
// Assert
Assert.AreEqual(expectedResult, returnedResult);
}
public void InvokeAction_ThrowsIfActionNameIsEmpty() {
// Arrange
AsyncControllerActionInvoker invoker = new AsyncControllerActionInvoker();
// Act & assert
ExceptionHelper.ExpectArgumentExceptionNullOrEmpty(
delegate {
invoker.BeginInvokeAction(new ControllerContext(), "", null, null);
}, "actionName");
}
public void InvokeAction_ResultThrowsException_ThreadAbort() {
// Arrange
ControllerContext controllerContext = GetControllerContext();
AsyncControllerActionInvoker invoker = new AsyncControllerActionInvoker();
// Act & assert
IAsyncResult asyncResult = invoker.BeginInvokeAction(controllerContext, "ResultCallsThreadAbort", null, null);
ExceptionHelper.ExpectException<ThreadAbortException>(
delegate {
invoker.EndInvokeAction(asyncResult);
});
}
private ActionResult BeingInvokeActionMethodWithFiltersTester(Func<IAsyncResult> beginFunction, Func<ActionResult> endFunction, bool checkBegin, bool checkEnd, IActionFilter[] filters)
{
AsyncControllerActionInvoker invoker = new AsyncControllerActionInvoker();
ControllerContext controllerContext = new ControllerContext();
Dictionary<string, object> parameters = new Dictionary<string, object>();
Mock<AsyncActionDescriptor> mockActionDescriptor = new Mock<AsyncActionDescriptor>();
bool endExecuteCalled = false;
bool beginExecuteCalled = false;
Func<ActionResult> endExecute = () =>
{
endExecuteCalled = true;
return endFunction();
};
Func<IAsyncResult> beingExecute = () =>
{
beginExecuteCalled = true;
return beginFunction();
};
mockActionDescriptor.Setup(d => d.BeginExecute(controllerContext, parameters, It.IsAny<AsyncCallback>(), It.IsAny<object>())).Returns(beingExecute);
mockActionDescriptor.Setup(d => d.EndExecute(It.IsAny<IAsyncResult>())).Returns(endExecute);
IAsyncResult outerAsyncResult = null;
try
{
outerAsyncResult = invoker.BeginInvokeActionMethodWithFilters(controllerContext, filters, mockActionDescriptor.Object, parameters, null, null);
}
catch (Exception ex)
{
if (checkEnd)
{
// Testing end, so not expecting exception thrown from begin
Assert.NotNull(ex);
}
else
{
throw ex;
}
}
Assert.NotNull(outerAsyncResult);
Assert.Equal(checkBegin, beginExecuteCalled);
Assert.False(endExecuteCalled);
ActionExecutedContext postContext = invoker.EndInvokeActionMethodWithFilters(outerAsyncResult);
Assert.NotNull(postContext);
if (checkEnd)
{
Assert.True(endExecuteCalled);
}
return postContext.Result;
}
public void InvokeAction_RequestValidationFails()
{
// Arrange
ControllerContext controllerContext = GetControllerContext(passesRequestValidation: false);
AsyncControllerActionInvoker invoker = new AsyncControllerActionInvoker();
// Act & assert
Assert.Throws<HttpRequestValidationException>(
delegate { invoker.BeginInvokeAction(controllerContext, "NormalAction", null, null); });
}
public void InvokeAction_NormalAction()
{
// Arrange
ControllerContext controllerContext = GetControllerContext();
AsyncControllerActionInvoker invoker = new AsyncControllerActionInvoker();
// Act
IAsyncResult asyncResult = invoker.BeginInvokeAction(controllerContext, "NormalAction", null, null);
bool retVal = invoker.EndInvokeAction(asyncResult);
// Assert
Assert.True(retVal);
Assert.Equal("From action", ((TestController)controllerContext.Controller).Log);
}
public void InvokeAction_ResultThrowsException_NotHandled() {
// Arrange
ControllerContext controllerContext = GetControllerContext();
AsyncControllerActionInvoker invoker = new AsyncControllerActionInvoker();
// Act & assert
IAsyncResult asyncResult = invoker.BeginInvokeAction(controllerContext, "ResultThrowsExceptionAndIsNotHandled", null, null);
ExceptionHelper.ExpectException<Exception>(
delegate {
invoker.EndInvokeAction(asyncResult);
},
@"Some exception text.");
}
