public void Constructor_SetsProperties()
{
// Arrange
string actionName = "SomeAction";
ControllerDescriptor cd = new Mock<ControllerDescriptor>().Object;
// Act
TaskAsyncActionDescriptor ad = new TaskAsyncActionDescriptor(_taskMethod, actionName, cd);
// Assert
Assert.Equal(_taskMethod, ad.TaskMethodInfo);
Assert.Equal(actionName, ad.ActionName);
Assert.Equal(cd, ad.ControllerDescriptor);
}
public void Constructor_SetsProperties()
{
// Arrange
string actionName = "SomeAction";
ControllerDescriptor cd = new Mock <ControllerDescriptor>().Object;
// Act
TaskAsyncActionDescriptor ad = new TaskAsyncActionDescriptor(_taskMethod, actionName, cd);
// Assert
Assert.Equal(_taskMethod, ad.TaskMethodInfo);
Assert.Equal(actionName, ad.ActionName);
Assert.Equal(cd, ad.ControllerDescriptor);
}
public void Execute_ThrowsIfParametersIsNull()
{
// Arrange
TaskAsyncActionDescriptor ad = GetActionDescriptor(_taskMethod);
// Act & assert
Assert.ThrowsArgumentNull(
delegate
{
ad.BeginExecute(new ControllerContext(), null, null, null);
},
"parameters"
);
}
public void Execute_ThrowsIfControllerContextIsNull()
{
// Arrange
TaskAsyncActionDescriptor ad = GetActionDescriptor(_taskMethod);
// Act & assert
Assert.ThrowsArgumentNull(
delegate
{
ad.BeginExecute(null, new Dictionary <string, object>(), null, null);
},
"controllerContext"
);
}
public void ExecuteTaskOfPrivateT()
{
// Arrange
TaskAsyncActionDescriptor actionDescriptor = GetActionDescriptor(GetExecuteControllerMethodInfo("TaskOfPrivateT"));
ControllerContext controllerContext = GetControllerContext();
Dictionary <string, object> parameters = new Dictionary <string, object>();
// Act
object retVal = ExecuteHelper(actionDescriptor, parameters, controllerContext);
// Assert
Assert.Null(retVal);
Assert.True((controllerContext.Controller as ExecuteController).WorkDone);
}
public void ExecuteTaskGeneric()
{
// Arrange
TaskAsyncActionDescriptor actionDescriptor = GetActionDescriptor(GetExecuteControllerMethodInfo("GenericTask"));
Dictionary <string, object> parameters = new Dictionary <string, object>()
{
{ "taskId", "foo" }
};
// Act
object retVal = ExecuteHelper(actionDescriptor, parameters);
// Assert
Assert.Equal("foo", retVal);
}
public void ExecuteTaskWithTimeout()
{
// Arrange
TaskAsyncActionDescriptor actionDescriptor = GetActionDescriptor(GetExecuteControllerMethodInfo("TaskTimeout"));
Dictionary <string, object> token = new Dictionary <string, object>()
{
{ "cancellationToken", new CancellationToken() }
};
// Act & assert
Assert.Throws <TimeoutException>(
() => actionDescriptor.EndExecute(actionDescriptor.BeginExecute(GetControllerContext(2000), parameters: token, callback: null, state: null)),
"The operation has timed out."
);
}
public void ExecuteWithInfiniteTimeout()
{
// Arrange
TaskAsyncActionDescriptor actionDescriptor = GetActionDescriptor(GetExecuteControllerMethodInfo("TaskWithInfiniteTimeout"));
ControllerContext controllerContext = GetControllerContext(Timeout.Infinite);
Dictionary <string, object> parameters = new Dictionary <string, object>()
{
{ "cancellationToken", new CancellationToken() }
};
// Act
object retVal = ExecuteHelper(actionDescriptor, parameters);
// Assert
Assert.Equal("Task Completed", retVal);
}
public void GetCustomAttributesWithAttributeTypeCallsMethodInfoGetCustomAttributes()
{
// Arrange
object[] expected = new object[0];
Mock <MethodInfo> mockMethod = new Mock <MethodInfo>();
mockMethod.Setup(mi => mi.GetCustomAttributes(typeof(ObsoleteAttribute), true)).Returns(expected);
TaskAsyncActionDescriptor ad = new TaskAsyncActionDescriptor(mockMethod.Object, "someName", new Mock <ControllerDescriptor>().Object, validateMethod: false)
{
DispatcherCache = new ActionMethodDispatcherCache()
};
// Act
object[] returned = ad.GetCustomAttributes(typeof(ObsoleteAttribute), true);
// Assert
Assert.Same(expected, returned);
}
public void ExecuteTaskPreservesState()
{
// Arrange
TaskAsyncActionDescriptor actionDescriptor = GetActionDescriptor(GetExecuteControllerMethodInfo("SimpleTask"));
Dictionary <string, object> parameters = new Dictionary <string, object>()
{
{ "doWork", true }
};
ControllerContext controllerContext = GetControllerContext();
// Act
TaskWrapperAsyncResult result = (TaskWrapperAsyncResult)actionDescriptor.BeginExecute(GetControllerContext(), parameters, callback: null, state: "state");
// Assert
Assert.Equal("state", result.AsyncState);
}
public void SynchronousExecuteThrows()
{
// Arrange
TaskAsyncActionDescriptor actionDescriptor = GetActionDescriptor(
GetExecuteControllerMethodInfo("SimpleTask")
);
// Act & assert
Assert.Throws <InvalidOperationException>(
delegate
{
actionDescriptor.Execute(
new ControllerContext(),
new Dictionary <string, object>()
);
},
"The asynchronous action method 'someName' returns a Task, which cannot be executed synchronously."
);
}
public void FixtureSetUp()
{
var controllerContext = new Mock <ControllerContext>();
controllerContext.Setup(mock => mock.Controller).Returns(new TestController());
_controllerContext = controllerContext.Object;
_controllerDescriptor = new Mock <ControllerDescriptor>().Object;
_baseMethodInfo = TestController.GetAction1MethodInfo <TestController>();
_derivedMethodInfo = TestController.GetAction1MethodInfo <TestControllerA>();
_mostDerivedMethodInfo = TestController.GetAction1MethodInfo <TestControllerB>();
_actionName = _baseMethodInfo.Name;
_reflectedActionDescriptor = new ReflectedActionDescriptor(_baseMethodInfo, _actionName, _controllerDescriptor);
_reflectedAsyncActionDescriptor = new ReflectedAsyncActionDescriptor(_baseMethodInfo, _baseMethodInfo, _actionName, _controllerDescriptor);
_taskAsyncActionDescriptor = new TaskAsyncActionDescriptor(_baseMethodInfo, _actionName, _controllerDescriptor);
_derivedActionDescriptor = new ReflectedActionDescriptor(_derivedMethodInfo, _actionName, _controllerDescriptor);
_mostDerivedActionDescriptor = new ReflectedActionDescriptor(_mostDerivedMethodInfo, _actionName, _controllerDescriptor);
}
public void Execute_ThrowsIfControllerIsNotAsyncManagerContainer()
{
// Arrange
TaskAsyncActionDescriptor ad = GetActionDescriptor(_taskMethod);
ControllerContext controllerContext = new ControllerContext()
{
Controller = new RegularSyncController()
};
Dictionary <string, object> parameters = new Dictionary <string, object>()
{
{ "doWork", true }
};
// Act & assert
Assert.Throws <InvalidOperationException>(
delegate { ad.BeginExecute(controllerContext, parameters, null, null); },
@"The controller of type 'System.Web.Mvc.Async.Test.TaskAsyncActionDescriptorTest+RegularSyncController' must subclass AsyncController or implement the IAsyncManagerContainer interface.");
}
public void GetParameters()
{
// Arrange
ParameterInfo pInfo = _taskMethod.GetParameters()[0];
TaskAsyncActionDescriptor ad = GetActionDescriptor(_taskMethod);
// Act
ParameterDescriptor[] pDescsFirstCall = ad.GetParameters();
ParameterDescriptor[] pDescsSecondCall = ad.GetParameters();
// Assert
Assert.NotSame(pDescsFirstCall, pDescsSecondCall); // Should get a new array every time
Assert.Equal(pDescsFirstCall, pDescsSecondCall);
ParameterDescriptor parameterDescriptor = Assert.Single(pDescsFirstCall);
ReflectedParameterDescriptor pDesc = Assert.IsType <ReflectedParameterDescriptor>(parameterDescriptor);
Assert.NotNull(pDesc);
Assert.Same(ad, pDesc.ActionDescriptor);
Assert.Same(pInfo, pDesc.ParameterInfo);
}
public void ExecuteTaskPreservesStackTraceOnException()
{
// Arrange
TaskAsyncActionDescriptor actionDescriptor = GetActionDescriptor(GetExecuteControllerMethodInfo("SimpleTaskException"));
Dictionary <string, object> parameters = new Dictionary <string, object>()
{
{ "doWork", true }
};
// Act
IAsyncResult result = actionDescriptor.BeginExecute(GetControllerContext(), parameters, null, null);
// Assert
InvalidOperationException ex = Assert.Throws <InvalidOperationException>(
() => actionDescriptor.EndExecute(result),
"Test exception from action"
);
Assert.Contains("System.Web.Mvc.Async.Test.TaskAsyncActionDescriptorTest.ExecuteController.", ex.StackTrace);
}
public static object ExecuteHelper(
TaskAsyncActionDescriptor actionDescriptor,
Dictionary <string, object> parameters,
ControllerContext controllerContext = null
)
{
using (SignalContainer <object> resultContainer = new SignalContainer <object>())
{
AsyncCallback callback = ar =>
{
object o = actionDescriptor.EndExecute(ar);
resultContainer.Signal(o);
};
actionDescriptor.BeginExecute(
controllerContext ?? GetControllerContext(),
parameters,
callback,
state: null
);
return(resultContainer.Wait());
}
}
public void GetSelectors()
{
// Arrange
ControllerContext controllerContext = new Mock <ControllerContext>().Object;
Mock <MethodInfo> mockMethod = new Mock <MethodInfo>();
Mock <ActionMethodSelectorAttribute> mockAttr =
new Mock <ActionMethodSelectorAttribute>();
mockAttr
.Setup(attr => attr.IsValidForRequest(controllerContext, mockMethod.Object))
.Returns(true)
.Verifiable();
mockMethod
.Setup(m => m.GetCustomAttributes(typeof(ActionMethodSelectorAttribute), true))
.Returns(new ActionMethodSelectorAttribute[] { mockAttr.Object });
TaskAsyncActionDescriptor ad = new TaskAsyncActionDescriptor(
mockMethod.Object,
"someName",
new Mock <ControllerDescriptor>().Object,
validateMethod: false
)
{
DispatcherCache = new ActionMethodDispatcherCache()
};
// Act
ICollection <ActionSelector> selectors = ad.GetSelectors();
bool executedSuccessfully = selectors.All(s => s(controllerContext));
// Assert
Assert.Single(selectors);
Assert.True(executedSuccessfully);
mockAttr.Verify();
}
public void FixtureSetUp()
{
_baseControllerContext = new ControllerContext {
Controller = new TestController()
};
_derivedControllerContext = new ControllerContext {
Controller = new TestControllerA()
};
_mostDerivedControllerContext = new ControllerContext {
Controller = new TestControllerB()
};
_baseMethodInfo = TestController.GetAction1MethodInfo <TestController>();
_derivedMethodInfo = TestController.GetAction1MethodInfo <TestControllerA>();
_mostDerivedMethodInfo = TestController.GetAction1MethodInfo <TestControllerB>();
_actionName = _baseMethodInfo.Name;
_controllerDescriptor = new Mock <ControllerDescriptor>().Object;
_reflectedActionDescriptor = new ReflectedActionDescriptor(_baseMethodInfo, _actionName, _controllerDescriptor);
_reflectedAsyncActionDescriptor = new ReflectedAsyncActionDescriptor(_baseMethodInfo, _baseMethodInfo, _actionName, _controllerDescriptor);
_taskAsyncActionDescriptor = new TaskAsyncActionDescriptor(_baseMethodInfo, _actionName, _controllerDescriptor);
_derivedActionDescriptor = new ReflectedActionDescriptor(_derivedMethodInfo, _actionName, _controllerDescriptor);
_mostDerivedActionDescriptor = new ReflectedActionDescriptor(_mostDerivedMethodInfo, _actionName, _controllerDescriptor);
}
public static object ExecuteHelper(TaskAsyncActionDescriptor actionDescriptor, Dictionary<string, object> parameters, ControllerContext controllerContext = null)
{
SignalContainer<object> resultContainer = new SignalContainer<object>();
AsyncCallback callback = ar =>
{
object o = actionDescriptor.EndExecute(ar);
resultContainer.Signal(o);
};
actionDescriptor.BeginExecute(controllerContext ?? GetControllerContext(), parameters, callback, state: null);
return resultContainer.Wait();
}
public void GetSelectors()
{
// Arrange
ControllerContext controllerContext = new Mock<ControllerContext>().Object;
Mock<MethodInfo> mockMethod = new Mock<MethodInfo>();
Mock<ActionMethodSelectorAttribute> mockAttr = new Mock<ActionMethodSelectorAttribute>();
mockAttr.Setup(attr => attr.IsValidForRequest(controllerContext, mockMethod.Object)).Returns(true).Verifiable();
mockMethod.Setup(m => m.GetCustomAttributes(typeof(ActionMethodSelectorAttribute), true)).Returns(new ActionMethodSelectorAttribute[] { mockAttr.Object });
TaskAsyncActionDescriptor ad = new TaskAsyncActionDescriptor(mockMethod.Object, "someName", new Mock<ControllerDescriptor>().Object, validateMethod: false)
{
DispatcherCache = new ActionMethodDispatcherCache()
};
// Act
ICollection<ActionSelector> selectors = ad.GetSelectors();
bool executedSuccessfully = selectors.All(s => s(controllerContext));
// Assert
Assert.Single(selectors);
Assert.True(executedSuccessfully);
mockAttr.Verify();
}
public void GetCustomAttributesWithAttributeTypeCallsMethodInfoGetCustomAttributes()
{
// Arrange
object[] expected = new object[0];
Mock<MethodInfo> mockMethod = new Mock<MethodInfo>();
mockMethod.Setup(mi => mi.GetCustomAttributes(typeof(ObsoleteAttribute), true)).Returns(expected);
TaskAsyncActionDescriptor ad = new TaskAsyncActionDescriptor(mockMethod.Object, "someName", new Mock<ControllerDescriptor>().Object, validateMethod: false)
{
DispatcherCache = new ActionMethodDispatcherCache()
};
// Act
object[] returned = ad.GetCustomAttributes(typeof(ObsoleteAttribute), true);
// Assert
Assert.Same(expected, returned);
}
