public void MultipartWriteDelegatingStreamTest_CallsCallbackOnFailure()
{
// Arrange
object expectedState = new object();
IAsyncResult mockAsyncResult = MockCompletedAsyncResult.Create(true, expectedState);
Mock <Stream> mockInnerStream = new Mock <Stream>()
{
CallBase = true
};
mockInnerStream.Setup(s => s.BeginWrite(It.IsAny <byte[]>(), It.IsAny <int>(), It.IsAny <int>(), It.IsAny <AsyncCallback>(), It.IsAny <object>()))
.Returns <byte[], int, int, AsyncCallback, object>((data, offset, count, callback, state) => mockAsyncResult);
mockInnerStream.Setup(s => s.EndWrite(mockAsyncResult))
.Throws(new Exception("Catch this!"));
MockMultipartWriteDelegatingStream mockStream = new MockMultipartWriteDelegatingStream(mockInnerStream.Object);
MockAsyncCallback mockCallback = new MockAsyncCallback();
// Act
IAsyncResult result = mockStream.BeginWrite(_testData, 0, _testData.Length, mockCallback.Handler, expectedState);
// Assert
Assert.True(mockCallback.WasInvoked);
Assert.Same(expectedState, mockCallback.AsyncResult.AsyncState);
}
public void Complete_ThrowsIfCallbackThrows()
{
// Arrange
MockAsyncCallback mockCallback = new MockAsyncCallback(true);
MockAsyncResult mockAsyncResult = new MockAsyncResult(mockCallback.Callback, null);
// Act/Assert
Assert.Throws <InvalidOperationException>(() => mockAsyncResult.Complete(false));
}
public void End_ThrowsIfCompletedWithException(bool completedSynchronously)
{
// Arrange
MockAsyncCallback mockCallback = new MockAsyncCallback(false);
MockAsyncResult mockAsyncResult = new MockAsyncResult(mockCallback.Callback, null);
ApplicationException applicationException = new ApplicationException("Complete failed!");
mockAsyncResult.Complete(completedSynchronously, applicationException);
// Act/Assert
Assert.Throws <ApplicationException>(() => MockAsyncResult.End <MockAsyncResult>(mockAsyncResult));
}
public void Complete_CallsCallback(bool completedSynchronously)
{
// Arrange
MockAsyncCallback mockCallback = new MockAsyncCallback(false);
MockAsyncResult mockAsyncResult = new MockAsyncResult(mockCallback.Callback, null);
// Act
mockAsyncResult.Complete(completedSynchronously);
// Assert
Assert.True(mockCallback.WasInvoked);
Assert.Same(mockAsyncResult, mockCallback.AsyncResult);
}
public void End_ThrowsIfCalledTwiceOnSameAsyncResult(bool completedSynchronously)
{
// Arrange
MockAsyncCallback mockCallback = new MockAsyncCallback(false);
MockAsyncResult mockAsyncResult = new MockAsyncResult(mockCallback.Callback, null);
mockAsyncResult.Complete(completedSynchronously);
// Act
MockAsyncResult.End <MockAsyncResult>(mockAsyncResult);
// Act
Assert.Throws <InvalidOperationException>(() => MockAsyncResult.End <MockAsyncResult>(mockAsyncResult));
}
public void EndAcceptChannel_Returns_Null_If_The_Inner_Listener_Returns_Null()
{
MockChannelListener innerListener = new MockChannelListener(true /* return null channel */);
HttpMessageEncodingChannelListener listener = new HttpMessageEncodingChannelListener(innerListener);
listener.Open();
object state = new object();
AsyncCallback callback = MockAsyncCallback.Create();
TimeSpan timeout = new TimeSpan(0, 2, 0);
IAsyncResult result = listener.BeginAcceptChannel(timeout, callback, state);
IReplyChannel channel = listener.EndAcceptChannel(result);
Assert.IsNull(channel, "HttpMessageEncodingChannelListener.EndAcceptChannel should have returned null since the inner listener returned null.");
}
public void EndClose_Calls_The_Inner_Listener()
{
MockChannelListener innerListener = new MockChannelListener();
HttpMessageEncodingChannelListener listener = new HttpMessageEncodingChannelListener(innerListener);
listener.Open();
object state = new object();
AsyncCallback callback = MockAsyncCallback.Create();
TimeSpan timeout = new TimeSpan(0, 2, 0);
IAsyncResult result = listener.BeginClose(timeout, callback, state);
listener.EndClose(result);
Assert.IsTrue(innerListener.OnEndCloseCalled, "HttpMessageEncodingChannelListener.EndClose should have called EndClose on the inner listener.");
}
public void EndAcceptChannel_Returns_HttpMessageEncodingChannel()
{
MockChannelListener innerListener = new MockChannelListener();
HttpMessageEncodingChannelListener listener = new HttpMessageEncodingChannelListener(innerListener);
listener.Open();
object state = new object();
AsyncCallback callback = MockAsyncCallback.Create();
TimeSpan timeout = new TimeSpan(0, 2, 0);
IAsyncResult result = listener.BeginAcceptChannel(timeout, callback, state);
IReplyChannel channel = listener.EndAcceptChannel(result);
Assert.IsNotNull(channel, "HttpMessageEncodingChannelListener.EndAcceptChannel should not have returned null since the inner listener did not return null.");
Assert.IsInstanceOfType(channel, typeof(HttpMessageEncodingReplyChannel), "HttpMessageEncodingChannelListener.EndAcceptChannel should have returned an HttpMessageEncodingReplyChannel.");
}
public void End_ClosesHandle(bool completedSynchronously)
{
// Arrange
MockAsyncCallback mockCallback = new MockAsyncCallback(false);
MockAsyncResult mockAsyncResult = new MockAsyncResult(mockCallback.Callback, null);
ApplicationException applicationException = new ApplicationException("Complete failed!");
mockAsyncResult.Complete(completedSynchronously);
WaitHandle handle = mockAsyncResult.AsyncWaitHandle;
// Act
MockAsyncResult.End <MockAsyncResult>(mockAsyncResult);
// Assert
Assert.ThrowsObjectDisposed(() => handle.WaitOne(), "");
}
public void EndWaitForChannel_Calls_The_Inner_Listener()
{
MockChannelListener innerListener = new MockChannelListener();
HttpMessageEncodingChannelListener listener = new HttpMessageEncodingChannelListener(innerListener);
listener.Open();
object state = new object();
AsyncCallback callback = MockAsyncCallback.Create();
TimeSpan timeout = new TimeSpan(0, 2, 0);
IAsyncResult result = listener.BeginWaitForChannel(timeout, callback, state);
bool waitResult = listener.EndWaitForChannel(result);
Assert.IsTrue(waitResult, "HttpMessageEncodingChannelListener.EndWaitForChannel should have returned the value from calling EndWaitForChannel on the inner listener.");
Assert.IsTrue(innerListener.OnEndWaitForChannelCalled, "HttpMessageEncodingChannelListener.EndWaitForChannel should have called EndWaitForChannel on the inner listener.");
Assert.AreSame(result, innerListener.ResultParameter, "HttpMessageEncodingChannelListener.EndWaitForChannel should have passed the result parameter along to the inner listener.");
}
public void BeginAcceptChannel_Calls_The_Inner_Listener()
{
MockChannelListener innerListener = new MockChannelListener();
HttpMessageEncodingChannelListener listener = new HttpMessageEncodingChannelListener(innerListener);
listener.Open();
object state = new object();
AsyncCallback callback = MockAsyncCallback.Create();
TimeSpan timeout = new TimeSpan(0, 2, 0);
IAsyncResult asyncResult = listener.BeginAcceptChannel(timeout, callback, state);
Assert.IsTrue(innerListener.OnBeginAcceptChannelCalled, "HttpMessageEncodingChannelListener.BeginAcceptChannel should have called BeginAcceptChannel on the inner listener.");
Assert.AreSame(callback, innerListener.CallbackParameter, "HttpMessageEncodingChannelListener.BeginAcceptChannel should have passed the callback parameter along to the inner listener.");
Assert.AreEqual(timeout, innerListener.TimeoutParameter, "HttpMessageEncodingChannelListener.BeginAcceptChannel should have passed the timeout parameter along to the inner listener.");
Assert.AreSame(state, innerListener.StateParameter, "HttpMessageEncodingChannelListener.BeginAcceptChannel should have passed the state parameter along to the inner listener.");
Assert.AreSame(asyncResult, innerListener.AsyncResultReturned, "HttpMessageEncodingChannelListener.BeginAcceptChannel should returned the same asyncResult as the inner listener.");
}
