public void Begin_WithCallbackSyncContext_ThrowsAsyncEvenIfSendContextCaptures() { // Arrange InvalidOperationException exception = new InvalidOperationException( "Some exception text." ); CapturingSynchronizationContext capturingSyncContext = new CapturingSynchronizationContext(); MockAsyncResult asyncResult = new MockAsyncResult() { CompletedSynchronously = false, IsCompleted = true }; using (asyncResult) { bool originalCallbackCalled = false; IAsyncResult passedAsyncResult = null; AsyncCallback passedCallback = null; AsyncCallback originalCallback = ar => { passedAsyncResult = ar; originalCallbackCalled = true; throw exception; }; // Act & Assert IAsyncResult outerResult = AsyncResultWrapper.Begin <object>( originalCallback, null, (callback, callbackState, state) => { passedCallback = callback; asyncResult.AsyncState = callbackState; return(asyncResult); }, (ar, state) => { asyncResult.IsCompleted = true; passedCallback(ar); }, null, callbackSyncContext: capturingSyncContext ); SynchronousOperationException thrownException = Assert.Throws <SynchronousOperationException>( delegate { AsyncResultWrapper.End(outerResult); }, @"An operation that crossed a synchronization context failed. See the inner exception for more information." ); // Assert Assert.Equal(exception, thrownException.InnerException); Assert.True(originalCallbackCalled); Assert.False(passedAsyncResult.CompletedSynchronously); Assert.True(capturingSyncContext.SendCalled); } }
public void Begin_AsynchronousCompletion() { // Arrange AsyncCallback capturedCallback = null; IAsyncResult resultGivenToCallback = null; using (MockAsyncResult innerResult = new MockAsyncResult()) { // Act IAsyncResult outerResult = AsyncResultWrapper.Begin <object>( ar => { resultGivenToCallback = ar; }, null, (callback, callbackState, state) => { capturedCallback = callback; return(innerResult); }, (ar, state) => { }, null); capturedCallback(innerResult); // Assert Assert.Equal(outerResult, resultGivenToCallback); } }
public void Begin_ReturnsAsyncResultWhichWrapsInnerResult() { // Arrange MockAsyncResult innerResult = new MockAsyncResult() { AsyncState = "inner state", CompletedSynchronously = true, IsCompleted = true }; using (innerResult) { // Act IAsyncResult outerResult = AsyncResultWrapper.Begin <object>( null, "outer state", (callback, callbackState, state) => innerResult, (ar, state) => { }, null); // Assert Assert.Equal(innerResult.AsyncState, outerResult.AsyncState); Assert.Null(outerResult.AsyncWaitHandle); Assert.Equal(innerResult.CompletedSynchronously, outerResult.CompletedSynchronously); Assert.Equal(innerResult.IsCompleted, outerResult.IsCompleted); } }
public void Begin_AsynchronousCompletionWithStateAndResult() { // Arrange using (MockAsyncResult innerResult = new MockAsyncResult()) { object invokeState = new object(); object capturedBeginState = null; object capturedEndState = null; object expectedRetun = new object(); // Act IAsyncResult outerResult = AsyncResultWrapper.Begin( null, null, (AsyncCallback callback, object callbackState, object innerInvokeState) => { capturedBeginState = innerInvokeState; return(innerResult); }, (IAsyncResult result, object innerInvokeState) => { capturedEndState = innerInvokeState; return(expectedRetun); }, invokeState, null, Timeout.Infinite); object endResult = AsyncResultWrapper.End <object>(outerResult); // Assert Assert.Same(expectedRetun, endResult); Assert.Same(invokeState, capturedBeginState); Assert.Same(invokeState, capturedEndState); } }
public void TimedOut() { // Arrange using (ManualResetEvent waitHandle = new ManualResetEvent(false /* initialState */)) { AsyncCallback callback = ar => { waitHandle.Set(); }; // Act & assert using (var mockResult = new MockAsyncResult()) { IAsyncResult asyncResult = AsyncResultWrapper.Begin <object>( callback, null, (innerCallback, callbackState, state) => mockResult, (ar, state) => { Assert.True(false, "This callback should never execute since we timed out."); }, null, null, 0); // wait for the timeout waitHandle.WaitOne(); Assert.True(asyncResult.IsCompleted); Assert.Throws <TimeoutException>( delegate { AsyncResultWrapper.End(asyncResult); }); } } }
public void WrapCallbackForSynchronizedExecution_DoesNotCallSyncIfOperationCompletedSynchronously() { // Arrange MockAsyncResult asyncResult = new MockAsyncResult() { CompletedSynchronously = true, IsCompleted = true }; bool originalCallbackCalled = false; AsyncCallback originalCallback = ar => { Assert.Equal(asyncResult, ar); originalCallbackCalled = true; }; DummySynchronizationContext syncContext = new DummySynchronizationContext(); // Act AsyncCallback retVal = AsyncUtil.WrapCallbackForSynchronizedExecution(originalCallback, syncContext); retVal(asyncResult); // Assert Assert.True(originalCallbackCalled); Assert.False(syncContext.SendCalled); }
public void End_ThrowsIfAsyncResultTagMismatch() { // Arrange using (var mockResult = new MockAsyncResult()) { IAsyncResult asyncResult = AsyncResultWrapper.Begin <object>( null, null, (callback, callbackState, state) => mockResult, (ar, state) => { }, null, "some tag" ); // Act & assert Assert.Throws <ArgumentException>( delegate { AsyncResultWrapper.End(asyncResult, "some other tag"); }, "The provided IAsyncResult is not valid for this method." + Environment.NewLine + "Parameter name: asyncResult" ); } }
public void Begin_AsynchronousCompletionWithStateAndResult() { // Arrange IAsyncResult innerResult = new MockAsyncResult(); object invokeState = new object(); object capturedBeginState = null; object capturedEndState = null; object expectedRetun = new object(); // Act IAsyncResult outerResult = AsyncResultWrapper.Begin( null, null, (AsyncCallback callback, object callbackState, object innerInvokeState) => { capturedBeginState = innerInvokeState; return innerResult; }, (IAsyncResult result, object innerInvokeState) => { capturedEndState = innerInvokeState; return expectedRetun; }, invokeState, null, Timeout.Infinite); object endResult = AsyncResultWrapper.End<object>(outerResult); // Assert Assert.Same(expectedRetun, endResult); Assert.Same(invokeState, capturedBeginState); Assert.Same(invokeState, capturedEndState); }
public void WrapCallbackForSynchronizedExecution_DoesNotCallSyncIfOperationCompletedSynchronously() { // Arrange MockAsyncResult asyncResult = new MockAsyncResult() { CompletedSynchronously = true, IsCompleted = true }; bool originalCallbackCalled = false; AsyncCallback originalCallback = ar => { Assert.Equal(asyncResult, ar); originalCallbackCalled = true; }; DummySynchronizationContext syncContext = new DummySynchronizationContext(); // Act AsyncCallback retVal = AsyncUtil.WrapCallbackForSynchronizedExecution(originalCallback, syncContext); retVal(asyncResult); // Assert Assert.True(originalCallbackCalled); Assert.False(syncContext.SendCalled); }
public void WaitForAsyncResultCompletion_DoesNothingIfResultAlreadyCompleted() { // Arrange MockAsyncResult asyncResult = new MockAsyncResult() { IsCompleted = true }; // Act AsyncUtil.WaitForAsyncResultCompletion(asyncResult, null /* app */); // Assert // If we reached this point of execution, the operation completed }
public void Begin_WithCallbackSyncContext_ThrowsSynchronous() { // Arrange InvalidOperationException exception = new InvalidOperationException( "Some exception text." ); CapturingSynchronizationContext capturingSyncContext = new CapturingSynchronizationContext(); MockAsyncResult asyncResult = new MockAsyncResult() { CompletedSynchronously = true, IsCompleted = true }; using (asyncResult) { bool originalCallbackCalled = false; IAsyncResult passedAsyncResult = null; AsyncCallback originalCallback = ar => { passedAsyncResult = ar; originalCallbackCalled = true; throw exception; }; // Act & Assert InvalidOperationException thrownException = Assert.Throws <InvalidOperationException>( delegate { AsyncResultWrapper.Begin <object>( originalCallback, null, (callback, callbackState, state) => { asyncResult.AsyncState = callbackState; return(asyncResult); }, (ar, state) => { }, null, callbackSyncContext: capturingSyncContext ); }, exception.Message ); // Assert Assert.Equal(exception, thrownException); Assert.True(originalCallbackCalled); Assert.True(passedAsyncResult.CompletedSynchronously); Assert.False(capturingSyncContext.SendCalled); } }
public void Begin_WithCallbackSyncContext_CallsSendIfOperationCompletedAsynchronously() { // Arrange MockAsyncResult asyncResult = new MockAsyncResult() { CompletedSynchronously = false, IsCompleted = false }; using (asyncResult) { bool originalCallbackCalled = false; IAsyncResult passedAsyncResult = null; AsyncCallback passedCallback = null; AsyncCallback originalCallback = ar => { originalCallbackCalled = true; passedAsyncResult = ar; }; object originalState = new object(); DummySynchronizationContext syncContext = new DummySynchronizationContext(); // Act IAsyncResult outerResult = AsyncResultWrapper.Begin <object>( originalCallback, originalState, (callback, callbackState, state) => { passedCallback = callback; asyncResult.AsyncState = callbackState; return(asyncResult); }, (ar, state) => { asyncResult.IsCompleted = true; passedCallback(ar); }, null, callbackSyncContext: syncContext ); AsyncResultWrapper.End(outerResult); // Assert Assert.True(originalCallbackCalled); Assert.False(passedAsyncResult.CompletedSynchronously); Assert.True(passedAsyncResult.IsCompleted); Assert.Same(originalState, passedAsyncResult.AsyncState); Assert.True(syncContext.SendCalled); } }
public void WaitForAsyncResultCompletion_DoesNothingIfResultAlreadyCompleted() { // Arrange MockAsyncResult asyncResult = new MockAsyncResult() { IsCompleted = true }; // Act AsyncUtil.WaitForAsyncResultCompletion(asyncResult, null /* app */); // Assert // If we reached this point of execution, the operation completed }
public override IAsyncResult BeginExecute(ControllerContext controllerContext, IDictionary<string, object> parameters, AsyncCallback callback, object state) { MockAsyncResult asyncResult = new MockAsyncResult() { IsCompleted = false, CompletedSynchronously = false }; _timer = new Timer(_ => { lock (controllerContext.HttpContext.ApplicationInstance) { asyncResult.IsCompleted = true; asyncResult.AsyncWaitHandle.Set(); } }, null, 1000, Timeout.Infinite); return asyncResult; }
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.Expect(d => d.BeginExecute(controllerContext, parameters, It.IsAny <AsyncCallback>(), It.IsAny <object>())).Returns(innerAsyncResult); mockActionDescriptor.Expect(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 CollectionAssert.AreEqual( new string[] { "OnActionExecuting1", "OnActionExecuting2", "OnActionExecuted2", "OnActionExecuted1" }, actionLog); Assert.AreEqual(actionResult, postContext.Result); }
public void End_ExecutesStoredDelegateAndReturnsValue() { // Arrange using (var mockResult = new MockAsyncResult()) { IAsyncResult asyncResult = AsyncResultWrapper.Begin( null, null, (callback, state) => mockResult, ar => 42); // Act int returned = AsyncResultWrapper.End <int>(asyncResult); // Assert Assert.Equal(42, returned); } }
public override IAsyncResult BeginExecute(ControllerContext controllerContext, IDictionary <string, object> parameters, AsyncCallback callback, object state) { MockAsyncResult asyncResult = new MockAsyncResult() { IsCompleted = false, CompletedSynchronously = false }; _timer = new Timer(_ => { lock (controllerContext.HttpContext.ApplicationInstance) { asyncResult.IsCompleted = true; asyncResult.AsyncWaitHandle.Set(); } }, null, 1000, Timeout.Infinite); return(asyncResult); }
public void Begin_SynchronousCompletion() { // Arrange IAsyncResult resultGivenToCallback = null; IAsyncResult innerResult = new MockAsyncResult(); // Act IAsyncResult outerResult = AsyncResultWrapper.Begin( ar => { resultGivenToCallback = ar; }, null, (callback, state) => { callback(innerResult); return innerResult; }, ar => { }); // Assert Assert.AreEqual(outerResult, resultGivenToCallback); }
public void End_ThrowsIfCalledTwiceOnSameAsyncResult() { // Arrange using (var mockResult = new MockAsyncResult()) { IAsyncResult asyncResult = AsyncResultWrapper.Begin <object>( null, null, (callback, callbackState, state) => mockResult, (ar, state) => { }, null); // Act & assert AsyncResultWrapper.End(asyncResult); Assert.Throws <InvalidOperationException>( delegate { AsyncResultWrapper.End(asyncResult); }, "The provided IAsyncResult has already been consumed."); } }
public void Begin_ReturnsAsyncResultWhichWrapsInnerResult() { // Arrange IAsyncResult innerResult = new MockAsyncResult() { AsyncState = "inner state", CompletedSynchronously = true, IsCompleted = true }; // Act IAsyncResult outerResult = AsyncResultWrapper.Begin(null, "outer state", (callback, state) => innerResult, ar => { }); // Assert Assert.AreEqual(innerResult.AsyncState, outerResult.AsyncState); Assert.AreEqual(innerResult.AsyncWaitHandle, outerResult.AsyncWaitHandle); Assert.AreEqual(innerResult.CompletedSynchronously, outerResult.CompletedSynchronously); Assert.AreEqual(innerResult.IsCompleted, outerResult.IsCompleted); }
public void Begin_SynchronousCompletion() { // Arrange IAsyncResult resultGivenToCallback = null; IAsyncResult innerResult = new MockAsyncResult(); // Act IAsyncResult outerResult = AsyncResultWrapper.Begin( ar => { resultGivenToCallback = ar; }, null, (callback, state) => { callback(innerResult); return(innerResult); }, ar => { }); // Assert Assert.AreEqual(outerResult, resultGivenToCallback); }
public void WaitForAsyncResultCompletion_WaitsOnWaitHandleIfAvailable() { // Arrange MockAsyncResult asyncResult = new MockAsyncResult() { IsCompleted = false }; HttpApplication app = new HttpApplication(); Timer timer = new Timer(_ => { lock (app) { asyncResult.IsCompleted = true; asyncResult.AsyncWaitHandle.Set(); } }, null, 1000, Timeout.Infinite); // Act lock (app) { AsyncUtil.WaitForAsyncResultCompletion(asyncResult, app); } }
public void Begin_ReturnsAsyncResultWhichWrapsInnerResult() { // Arrange IAsyncResult innerResult = new MockAsyncResult() { AsyncState = "inner state", CompletedSynchronously = true, IsCompleted = true }; // Act IAsyncResult outerResult = AsyncResultWrapper.Begin(null, "outer state", (callback, state) => innerResult, ar => { }); // Assert Assert.AreEqual(innerResult.AsyncState, outerResult.AsyncState); Assert.AreEqual(innerResult.AsyncWaitHandle, outerResult.AsyncWaitHandle); Assert.AreEqual(innerResult.CompletedSynchronously, outerResult.CompletedSynchronously); Assert.AreEqual(innerResult.IsCompleted, outerResult.IsCompleted); }
public void ExecuteCore_Asynchronous_ActionFound() { // Arrange MockAsyncResult innerAsyncResult = new MockAsyncResult(); Mock<IAsyncActionInvoker> mockActionInvoker = new Mock<IAsyncActionInvoker>(); mockActionInvoker.Setup(o => o.BeginInvokeAction(It.IsAny<ControllerContext>(), "SomeAction", It.IsAny<AsyncCallback>(), It.IsAny<object>())).Returns(innerAsyncResult); mockActionInvoker.Setup(o => o.EndInvokeAction(innerAsyncResult)).Returns(true); RequestContext requestContext = GetRequestContext("SomeAction"); EmptyController controller = new EmptyController() { ActionInvoker = mockActionInvoker.Object }; // Act & assert IAsyncResult outerAsyncResult = ((IAsyncController)controller).BeginExecute(requestContext, null, null); Assert.IsFalse(controller.TempDataSaved, "TempData shouldn't have been saved yet."); ((IAsyncController)controller).EndExecute(outerAsyncResult); Assert.IsTrue(controller.TempDataSaved); Assert.IsFalse(controller.HandleUnknownActionCalled); }
public void WaitForAsyncResultCompletion_WaitsOnWaitHandleIfAvailable() { // Arrange MockAsyncResult asyncResult = new MockAsyncResult() { IsCompleted = false }; HttpApplication app = new HttpApplication(); Timer timer = new Timer(_ => { lock (app) { asyncResult.IsCompleted = true; asyncResult.AsyncWaitHandle.Set(); } }, null, 1000, Timeout.Infinite); // Act lock (app) { AsyncUtil.WaitForAsyncResultCompletion(asyncResult, app); } }
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 BeginInvokeActionMethodWithFilters_NormalExecutionNotCanceled() { // Arrange bool onActionExecutingWasCalled = false; bool onActionExecutedWasCalled = false; MockAsyncResult innerAsyncResult = new MockAsyncResult(); ActionFilterImpl actionFilter = new ActionFilterImpl() { OnActionExecutingImpl = _ => { onActionExecutingWasCalled = true; }, OnActionExecutedImpl = _ => { onActionExecutedWasCalled = true; } }; Func <IAsyncResult> beginExecute = delegate { return(innerAsyncResult); }; // Act ActionResult result = BeingInvokeActionMethodWithFiltersBeginTester(beginExecute, actionFilter); // Assert Assert.True(onActionExecutingWasCalled); Assert.True(onActionExecutedWasCalled); }
public void Begin_AsynchronousCompletion() { // Arrange AsyncCallback capturedCallback = null; IAsyncResult resultGivenToCallback = null; IAsyncResult innerResult = new MockAsyncResult(); // Act IAsyncResult outerResult = AsyncResultWrapper.Begin<object>( ar => { resultGivenToCallback = ar; }, null, (callback, callbackState, state) => { capturedCallback = callback; return innerResult; }, (ar, state) => { }, null); capturedCallback(innerResult); // Assert Assert.Equal(outerResult, resultGivenToCallback); }
public void BeginInvokeActionMethodWithFilters_NormalExecutionNotCanceled() { // Arrange bool onActionExecutingWasCalled = false; bool onActionExecutedWasCalled = false; MockAsyncResult innerAsyncResult = new MockAsyncResult(); ActionFilterImpl actionFilter = new ActionFilterImpl() { OnActionExecutingImpl = _ => { onActionExecutingWasCalled = true; }, OnActionExecutedImpl = _ => { onActionExecutedWasCalled = true; } }; Func<IAsyncResult> beginExecute = delegate { return innerAsyncResult; }; // Act ActionResult result = BeingInvokeActionMethodWithFiltersBeginTester(beginExecute, actionFilter); // Assert 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 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.Expect(d => d.BeginExecute(controllerContext, parameters, It.IsAny<AsyncCallback>(), It.IsAny<object>())).Returns(innerAsyncResult); mockActionDescriptor.Expect(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 CollectionAssert.AreEqual( new string[] { "OnActionExecuting1", "OnActionExecuting2", "OnActionExecuted2", "OnActionExecuted1" }, actionLog); Assert.AreEqual(actionResult, postContext.Result); }
public void Begin_WithCallbackSyncContext_ThrowsSynchronous() { // Arrange InvalidOperationException exception = new InvalidOperationException("Some exception text."); CapturingSynchronizationContext capturingSyncContext = new CapturingSynchronizationContext(); MockAsyncResult asyncResult = new MockAsyncResult() { CompletedSynchronously = true, IsCompleted = true }; bool originalCallbackCalled = false; IAsyncResult passedAsyncResult = null; AsyncCallback originalCallback = ar => { passedAsyncResult = ar; originalCallbackCalled = true; throw exception; }; // Act & Assert InvalidOperationException thrownException = Assert.Throws<InvalidOperationException>( delegate { AsyncResultWrapper.Begin<object>( originalCallback, null, (callback, callbackState, state) => { asyncResult.AsyncState = callbackState; return asyncResult; }, (ar, state) => { }, null, callbackSyncContext: capturingSyncContext); }, exception.Message); // Assert Assert.Equal(exception, thrownException); Assert.True(originalCallbackCalled); Assert.True(passedAsyncResult.CompletedSynchronously); Assert.False(capturingSyncContext.SendCalled); }
public void ExecuteCore_Synchronous_ActionNotFound() { // Arrange MockAsyncResult innerAsyncResult = new MockAsyncResult(); Mock<IActionInvoker> mockActionInvoker = new Mock<IActionInvoker>(); mockActionInvoker.Setup(o => o.InvokeAction(It.IsAny<ControllerContext>(), "SomeAction")).Returns(false); RequestContext requestContext = GetRequestContext("SomeAction"); EmptyController controller = new EmptyController() { ActionInvoker = mockActionInvoker.Object }; // Act & assert IAsyncResult outerAsyncResult = ((IAsyncController)controller).BeginExecute(requestContext, null, null); Assert.False(controller.TempDataSaved); ((IAsyncController)controller).EndExecute(outerAsyncResult); Assert.True(controller.TempDataSaved); Assert.True(controller.HandleUnknownActionCalled); }
public void ProcessRequestAsync_AsyncController_NormalExecution() { // Arrange MockAsyncResult innerAsyncResult = new MockAsyncResult(); bool disposeWasCalled = false; Mock<IAsyncController> mockController = new Mock<IAsyncController>(); mockController.Setup(o => o.BeginExecute(It.IsAny<RequestContext>(), It.IsAny<AsyncCallback>(), It.IsAny<object>())).Returns(innerAsyncResult); mockController.As<IDisposable>().Setup(o => o.Dispose()).Callback(delegate { disposeWasCalled = true; }); MvcHandler handler = GetMvcHandler(mockController.Object); // Act & assert IAsyncResult outerAsyncResult = handler.BeginProcessRequest(handler.RequestContext.HttpContext, null, null); Assert.IsFalse(disposeWasCalled, "Dispose shouldn't have been called yet."); handler.EndProcessRequest(outerAsyncResult); Assert.IsTrue(disposeWasCalled); mockController.Verify(o => o.EndExecute(innerAsyncResult), Times.AtMostOnce()); }
public void Begin_WithCallbackSyncContext_ThrowsAsyncEvenIfSendContextCaptures() { // Arrange InvalidOperationException exception = new InvalidOperationException("Some exception text."); CapturingSynchronizationContext capturingSyncContext = new CapturingSynchronizationContext(); MockAsyncResult asyncResult = new MockAsyncResult() { CompletedSynchronously = false, IsCompleted = true }; bool originalCallbackCalled = false; IAsyncResult passedAsyncResult = null; AsyncCallback passedCallback = null; AsyncCallback originalCallback = ar => { passedAsyncResult = ar; originalCallbackCalled = true; throw exception; }; // Act & Assert IAsyncResult outerResult = AsyncResultWrapper.Begin<object>( originalCallback, null, (callback, callbackState, state) => { passedCallback = callback; asyncResult.AsyncState = callbackState; return asyncResult; }, (ar, state) => { asyncResult.IsCompleted = true; passedCallback(ar); }, null, callbackSyncContext: capturingSyncContext); SynchronousOperationException thrownException = Assert.Throws<SynchronousOperationException>( delegate { AsyncResultWrapper.End(outerResult); }, @"An operation that crossed a synchronization context failed. See the inner exception for more information."); // Assert Assert.Equal(exception, thrownException.InnerException); Assert.True(originalCallbackCalled); Assert.False(passedAsyncResult.CompletedSynchronously); Assert.True(capturingSyncContext.SendCalled); }
public void Begin_WithCallbackSyncContext_DoesNotCallSendIfOperationCompletedSynchronously() { // Arrange MockAsyncResult asyncResult = new MockAsyncResult() { CompletedSynchronously = true, IsCompleted = true }; bool originalCallbackCalled = false; IAsyncResult passedAsyncResult = null; AsyncCallback originalCallback = ar => { passedAsyncResult = ar; originalCallbackCalled = true; }; object originalState = new object(); DummySynchronizationContext syncContext = new DummySynchronizationContext(); // Act IAsyncResult outerResult = AsyncResultWrapper.Begin<object>( originalCallback, originalState, (callback, callbackState, state) => { asyncResult.AsyncState = callbackState; return asyncResult; }, (ar, state) => { }, null, callbackSyncContext: syncContext); // Assert Assert.True(originalCallbackCalled); Assert.True(passedAsyncResult.CompletedSynchronously); Assert.True(passedAsyncResult.IsCompleted); Assert.Same(originalState, passedAsyncResult.AsyncState); Assert.False(syncContext.SendCalled); }