public static IReturnsResult<CloudBlobStream> ReturnsCompletingAsynchronously(
this ISetup<CloudBlobStream, ICancellableAsyncResult> setup,
CancellableAsyncCompletionSource completionSource)
{
if (setup == null)
{
throw new ArgumentNullException("setup");
}
return setup.Returns<AsyncCallback, object>((callback, state) =>
{
CompletingCancellableAsyncResult result = new CompletingCancellableAsyncResult(callback, state);
completionSource.SetAsyncResult(result);
return result;
});
}
public static IReturnsResult <CloudBlobStream> ReturnsCompletingAsynchronously(
this ISetup <CloudBlobStream, ICancellableAsyncResult> setup,
CancellableAsyncCompletionSource completionSource)
{
if (setup == null)
{
throw new ArgumentNullException("setup");
}
return(setup.Returns <AsyncCallback, object>((callback, state) =>
{
CompletingCancellableAsyncResult result = new CompletingCancellableAsyncResult(callback, state);
completionSource.SetAsyncResult(result);
return result;
}));
}
public void EndFlush_DuringCallback_WhenInnerStreamThrows_PropogatesException()
{
// Arrange
Exception expectedException = new Exception();
Mock<CloudBlobStream> innerStreamMock = CreateMockInnerStream();
CancellableAsyncCompletionSource completion = new CancellableAsyncCompletionSource();
innerStreamMock
.SetupBeginFlush()
.ReturnsCompletingAsynchronously(completion);
innerStreamMock
.SetupEndFlush()
.Throws(expectedException);
CloudBlobStream innerStream = innerStreamMock.Object;
CloudBlobStream product = CreateProductUnderTest(innerStream);
bool callbackCalled = false;
IAsyncResult result = null;
AsyncCallback callback = (_) =>
{
Exception exception = Assert.Throws<Exception>(() => product.EndFlush(result));
Assert.Same(expectedException, exception);
callbackCalled = true;
};
object state = null;
result = product.BeginFlush(callback, state);
// Act & Assert
completion.Complete();
Assert.True(callbackCalled);
}
public void EndFlush_DuringCallback_DelegatesToInnerStreamEndFlush()
{
// Arrange
Mock<CloudBlobStream> innerStreamMock = CreateMockInnerStream();
CancellableAsyncCompletionSource completion = new CancellableAsyncCompletionSource();
innerStreamMock
.SetupBeginFlush()
.ReturnsCompletingAsynchronously(completion);
innerStreamMock
.Setup(s => s.EndFlush(It.Is<IAsyncResult>((ar) => ar == completion.AsyncResult)))
.Verifiable();
CloudBlobStream innerStream = innerStreamMock.Object;
CloudBlobStream product = CreateProductUnderTest(innerStream);
bool callbackCalled = false;
AsyncCallback callback = (ar) =>
{
product.EndFlush(ar);
callbackCalled = true;
};
object state = null;
IAsyncResult result = product.BeginFlush(callback, state);
// Act
completion.Complete();
// Assert
Assert.True(callbackCalled);
innerStreamMock.Verify();
}
public void BeginFlush_WhenCompletedAsynchronously_CallsCallbackAndCompletesResult()
{
// Arrange
object expectedState = new object();
ExpectedAsyncResult expectedResult = new ExpectedAsyncResult
{
AsyncState = expectedState,
CompletedSynchronously = false,
IsCompleted = true
};
bool callbackCalled = false;
IAsyncResult callbackResult = null;
CloudBlobStream product = null;
AsyncCallback callback = (ar) =>
{
callbackResult = ar;
AssertEqual(expectedResult, ar);
callbackCalled = true;
};
Mock<CloudBlobStream> innerStreamMock = CreateMockInnerStream();
CancellableAsyncCompletionSource completion = new CancellableAsyncCompletionSource();
innerStreamMock
.SetupBeginFlush()
.ReturnsCompletingAsynchronously(completion);
innerStreamMock
.SetupEndRead()
.Returns(-1);
CloudBlobStream innerStream = innerStreamMock.Object;
product = CreateProductUnderTest(innerStream);
IAsyncResult result = product.BeginFlush(callback, expectedState);
// Act
completion.Complete();
// Assert
Assert.True(callbackCalled);
// An AsyncCallback must be called with the same IAsyncResult instance as the Begin method returned.
Assert.Same(result, callbackResult);
AssertEqual(expectedResult, result, disposeActual: true);
}
public void BeginFlush_Cancel_WhenNotYetCompleted_CallsInnerCancellableAsyncResultCancel()
{
// Arrange
Mock<CloudBlobStream> innerStreamMock = CreateMockInnerStream();
CancellableAsyncCompletionSource spy = new CancellableAsyncCompletionSource();
innerStreamMock
.SetupBeginFlush()
.ReturnsCompletingAsynchronously(spy);
CloudBlobStream innerStream = innerStreamMock.Object;
CloudBlobStream product = CreateProductUnderTest(innerStream);
AsyncCallback callback = null;
object state = null;
ICancellableAsyncResult result = product.BeginFlush(callback, state);
Assert.NotNull(result); // Guard
// Act
result.Cancel();
// Assert
Assert.True(spy.Canceled);
// Cleanup
result.AsyncWaitHandle.Dispose();
}
public void EndCommit_WhenInnerStreamThrows_PropogatesException()
{
// Arrange
Exception expectedException = new Exception();
Mock<CloudBlobStream> innerStreamMock = CreateMockInnerStream();
CancellableAsyncCompletionSource completion = new CancellableAsyncCompletionSource();
innerStreamMock
.SetupBeginCommit()
.ReturnsCompletingAsynchronously(completion);
innerStreamMock
.SetupEndCommit()
.Throws(expectedException);
CloudBlobStream innerStream = innerStreamMock.Object;
CloudBlobStream product = CreateProductUnderTest(innerStream);
AsyncCallback callback = null;
object state = null;
IAsyncResult result = product.BeginCommit(callback, state);
completion.Complete();
// Act & Assert
Exception exception = Assert.Throws<Exception>(() => product.EndCommit(result));
Assert.Same(expectedException, exception);
}
public void EndCommit_DelegatesToInnerStreamEndCommit()
{
// Arrange
Mock<CloudBlobStream> innerStreamMock = CreateMockInnerStream();
CancellableAsyncCompletionSource completion = new CancellableAsyncCompletionSource();
innerStreamMock
.SetupBeginCommit()
.ReturnsCompletingAsynchronously(completion);
innerStreamMock
.Setup(s => s.EndCommit(It.Is<IAsyncResult>((ar) => ar == completion.AsyncResult)))
.Verifiable();
CloudBlobStream innerStream = innerStreamMock.Object;
CloudBlobStream product = CreateProductUnderTest(innerStream);
AsyncCallback callback = null;
object state = null;
IAsyncResult result = product.BeginCommit(callback, state);
completion.Complete();
// Act
product.EndCommit(result);
// Assert
innerStreamMock.Verify();
}
public void CompleteAsync_WhenUnchanged_DoesNotCommitAndReturnsFalse()
{
// Arrange
bool committed = false;
Mock<CloudBlobStream> innerStreamMock = CreateMockInnerStream();
CancellableAsyncCompletionSource spy = new CancellableAsyncCompletionSource();
innerStreamMock
.SetupBeginCommit()
.Callback(() => committed = true)
.ReturnsCompletedSynchronously();
innerStreamMock.SetupEndCommit();
CloudBlobStream innerStream = innerStreamMock.Object;
WatchableCloudBlobStream product = CreateProductUnderTest(innerStream);
CancellationToken cancellationToken = CancellationToken.None;
// Act
Task<bool> task = product.CompleteAsync(cancellationToken);
// Assert
Assert.False(committed);
Assert.NotNull(task);
Assert.Equal(TaskStatus.RanToCompletion, task.Status);
Assert.False(task.Result);
}
public void CompleteAsync_WhenChangedAndCommitted_DoesNotCommitAgainButStillReturnsTrue()
{
// Arrange
Mock<CloudBlobStream> innerStreamMock = CreateMockInnerStream();
CancellableAsyncCompletionSource spy = new CancellableAsyncCompletionSource();
bool committedAgain = false;
innerStreamMock.Setup(s => s.WriteByte(It.IsAny<byte>()));
innerStreamMock.Setup(s => s.Commit());
innerStreamMock
.SetupBeginCommit()
.Callback(() => committedAgain = true)
.ReturnsCompletedSynchronously();
innerStreamMock.SetupEndCommit();
CloudBlobStream innerStream = innerStreamMock.Object;
WatchableCloudBlobStream product = CreateProductUnderTest(innerStream);
product.WriteByte(0x00);
product.Commit();
CancellationToken cancellationToken = CancellationToken.None;
// Act
Task<bool> task = product.CompleteAsync(cancellationToken);
// Assert
Assert.False(committedAgain);
Assert.NotNull(task);
Assert.Equal(TaskStatus.RanToCompletion, task.Status);
Assert.True(task.Result);
}
public void CompleteAsync_WhenChangedAndCancellationIsRequested_CallsCancellableAsyncResultCancel()
{
// Arrange
Mock<CloudBlobStream> innerStreamMock = CreateMockInnerStream();
CancellableAsyncCompletionSource spy = new CancellableAsyncCompletionSource();
innerStreamMock.Setup(s => s.WriteByte(It.IsAny<byte>()));
innerStreamMock
.SetupBeginCommit()
.ReturnsCompletingAsynchronously(spy);
innerStreamMock.SetupEndCommit();
CloudBlobStream innerStream = innerStreamMock.Object;
WatchableCloudBlobStream product = CreateProductUnderTest(innerStream);
product.WriteByte(0x00);
CancellationToken cancellationToken = new CancellationToken(canceled: true);
Task task = product.CompleteAsync(cancellationToken);
// Act
spy.Complete();
// Assert
Assert.True(spy.Canceled);
Assert.NotNull(task);
Assert.Equal(TaskStatus.RanToCompletion, task.Status);
}
public void CommitAsync_WhenNotCompletedSynchronously_CancelTokenDuringEndCommit_DoesNotCallAsyncResultCancel()
{
// Arrange
using (CancellationTokenSource tokenSource = new CancellationTokenSource())
{
Mock<CloudBlobStream> innerStreamMock = CreateMockInnerStream();
CancellableAsyncCompletionSource spy = new CancellableAsyncCompletionSource();
innerStreamMock
.SetupBeginCommit()
.ReturnsCompletingAsynchronously(spy);
innerStreamMock
.SetupEndCommit()
.Callback(() => tokenSource.Cancel());
CloudBlobStream innerStream = innerStreamMock.Object;
WatchableCloudBlobStream product = CreateProductUnderTest(innerStream);
CancellationToken cancellationToken = tokenSource.Token;
Task task = product.CommitAsync(cancellationToken);
Assert.NotNull(task); // Guard
// Act
spy.Complete();
// Assert
Assert.False(spy.Canceled);
task.GetAwaiter().GetResult();
}
}
public void CommitAsync_WhenInnerStreamBeginCommitCompletedAsynchronously_ReturnsRanToCompletionTask()
{
// Arrange
Mock<CloudBlobStream> innerStreamMock = CreateMockInnerStream();
CancellableAsyncCompletionSource completion = new CancellableAsyncCompletionSource();
innerStreamMock
.SetupBeginCommit()
.ReturnsCompletingAsynchronously(completion);
innerStreamMock.SetupEndCommit();
CloudBlobStream innerStream = innerStreamMock.Object;
WatchableCloudBlobStream product = CreateProductUnderTest(innerStream);
CancellationToken cancellationToken = CancellationToken.None;
Task task = product.CommitAsync(cancellationToken);
// Act
completion.Complete();
// Assert
Assert.NotNull(task);
Assert.Equal(TaskStatus.RanToCompletion, task.Status);
}
public void CommitAsync_DelegatesToInnerStreamBeginEndCommit()
{
// Arrange
Mock<CloudBlobStream> innerStreamMock = CreateMockInnerStream();
CancellableAsyncCompletionSource completion = new CancellableAsyncCompletionSource();
innerStreamMock
.SetupBeginCommit()
.ReturnsCompletingAsynchronously(completion)
.Verifiable();
innerStreamMock
.Setup(s => s.EndCommit(It.Is<IAsyncResult>((ar) => ar == completion.AsyncResult)))
.Verifiable();
CloudBlobStream innerStream = innerStreamMock.Object;
WatchableCloudBlobStream product = CreateProductUnderTest(innerStream);
CancellationToken cancellationToken = CancellationToken.None;
Task task = product.CommitAsync(cancellationToken);
// Act
completion.Complete();
// Assert
innerStreamMock.Verify();
task.GetAwaiter().GetResult();
}
public void FlushAsync_CancelToken_WhenNotCompletedSynchronously_DelegatesToCancel()
{
// Arrange
Mock<CloudBlobStream> innerStreamMock = CreateMockInnerStream();
CancellableAsyncCompletionSource spy = new CancellableAsyncCompletionSource();
innerStreamMock
.SetupBeginFlush()
.ReturnsCompletingAsynchronously(spy);
innerStreamMock.SetupEndFlush();
CloudBlobStream innerStream = innerStreamMock.Object;
Stream product = CreateProductUnderTest(innerStream);
using (CancellationTokenSource tokenSource = new CancellationTokenSource())
{
CancellationToken cancellationToken = tokenSource.Token;
Task task = product.FlushAsync(cancellationToken);
Assert.NotNull(task); // Guard
// Act
tokenSource.Cancel();
// Assert
Assert.True(spy.Canceled);
// Cleanup
spy.Complete();
task.GetAwaiter().GetResult();
}
}
