public async Task DispatchProcessInOrderAsync()
{
BatchAsyncBatcher batchAsyncBatcher = new BatchAsyncBatcher(10, 1000, new CosmosJsonDotNetSerializer(), this.Executor, this.Retrier);
List <ItemBatchOperation> operations = new List <ItemBatchOperation>(10);
for (int i = 0; i < 10; i++)
{
ItemBatchOperation operation = new ItemBatchOperation(OperationType.Create, i, i.ToString());
ItemBatchOperationContext context = new ItemBatchOperationContext(string.Empty);
operation.AttachContext(context);
operations.Add(operation);
Assert.IsTrue(batchAsyncBatcher.TryAdd(operation));
}
await batchAsyncBatcher.DispatchAsync();
for (int i = 0; i < 10; i++)
{
ItemBatchOperation operation = operations[i];
Assert.AreEqual(TaskStatus.RanToCompletion, operation.Context.OperationTask.Status);
TransactionalBatchOperationResult result = await operation.Context.OperationTask;
Assert.AreEqual(i.ToString(), result.ETag);
Assert.IsNotNull(operation.Context.Diagnostics);
Assert.AreEqual(operation.Context.Diagnostics.ToString(), result.Diagnostics.ToString());
Assert.IsFalse(string.IsNullOrEmpty(operation.Context.Diagnostics.ToString()));
}
}
public async Task DoOperationsAsync()
{
BatchAsyncContainerExecutor executor = new BatchAsyncContainerExecutor(this.cosmosContainer, this.cosmosContainer.ClientContext, 20, Constants.MaxDirectModeBatchRequestBodySizeInBytes);
List <Task <TransactionalBatchOperationResult> > tasks = new List <Task <TransactionalBatchOperationResult> >();
for (int i = 0; i < 100; i++)
{
tasks.Add(executor.AddAsync(CreateItem(i.ToString()), null, default(CancellationToken)));
}
await Task.WhenAll(tasks);
for (int i = 0; i < 100; i++)
{
Task <TransactionalBatchOperationResult> task = tasks[i];
TransactionalBatchOperationResult result = await task;
Assert.AreEqual(HttpStatusCode.Created, result.StatusCode);
MyDocument document = cosmosDefaultJsonSerializer.FromStream <MyDocument>(result.ResourceStream);
Assert.AreEqual(i.ToString(), document.id);
ItemResponse <MyDocument> storedDoc = await this.cosmosContainer.ReadItemAsync <MyDocument>(i.ToString(), new Cosmos.PartitionKey(i.ToString()));
Assert.IsNotNull(storedDoc.Resource);
}
executor.Dispose();
}
public async Task DispatchesAsync()
{
// Expect all operations to complete as their batches get dispached
BatchAsyncStreamer batchAsyncStreamer = new BatchAsyncStreamer(
2,
MaxBatchByteSize,
this.TimerWheel,
this.limiter,
1,
MockCosmosUtil.Serializer,
this.Executor,
this.Retrier,
this.GetMockClientContext());
List <Task <TransactionalBatchOperationResult> > contexts = new List <Task <TransactionalBatchOperationResult> >(10);
for (int i = 0; i < 10; i++)
{
ItemBatchOperation operation = new ItemBatchOperation(OperationType.Create, i, Cosmos.PartitionKey.Null, i.ToString());
ItemBatchOperationContext context = AttachContext(operation);
batchAsyncStreamer.Add(operation);
contexts.Add(context.OperationTask);
}
await Task.WhenAll(contexts);
for (int i = 0; i < 10; i++)
{
Task <TransactionalBatchOperationResult> context = contexts[i];
Assert.AreEqual(TaskStatus.RanToCompletion, context.Status);
TransactionalBatchOperationResult result = await context;
Assert.AreEqual(i.ToString(), result.ETag);
}
}
public async Task DispatchProcessInOrderAsync()
{
BatchAsyncBatcher batchAsyncBatcher = new BatchAsyncBatcher(10, 1000, MockCosmosUtil.Serializer, this.Executor, this.Retrier, BatchAsyncBatcherTests.MockClientContext());
List <ItemBatchOperation> operations = new List <ItemBatchOperation>(10);
for (int i = 0; i < 10; i++)
{
ItemBatchOperation operation = new ItemBatchOperation(
operationType: OperationType.Create,
operationIndex: i,
partitionKey: new Cosmos.PartitionKey(i.ToString()),
id: i.ToString());
ItemBatchOperationContext context = new ItemBatchOperationContext(string.Empty, NoOpTrace.Singleton);
operation.AttachContext(context);
operations.Add(operation);
Assert.IsTrue(batchAsyncBatcher.TryAdd(operation));
}
await batchAsyncBatcher.DispatchAsync(metric);
for (int i = 0; i < 10; i++)
{
ItemBatchOperation operation = operations[i];
Assert.AreEqual(TaskStatus.RanToCompletion, operation.Context.OperationTask.Status);
TransactionalBatchOperationResult result = await operation.Context.OperationTask;
Assert.AreEqual(i.ToString(), result.ETag);
}
}
public void CanBeMocked()
{
Mock <TransactionalBatchOperationResult> mockResult = new Mock <TransactionalBatchOperationResult>();
TransactionalBatchOperationResult result = mockResult.Object;
Assert.AreEqual(default(HttpStatusCode), result.StatusCode);
}
public override async Task <TransactionalBatchResponse> ExecuteAsync(
CancellationToken cancellationToken = default)
{
CosmosDiagnosticsContext diagnosticsContext = CosmosDiagnosticsContext.Create(options: null);
using (diagnosticsContext.CreateScope("TransactionalBatch.ExecuteAsync"))
{
TransactionalBatchResponse response = await this.transactionalBatch.ExecuteAsync(cancellationToken);
if (response.IsSuccessStatusCode)
{
for (int index = 0; index < response.Count; index++)
{
TransactionalBatchOperationResult result = response[index];
if (result.ResourceStream != null)
{
result.ResourceStream = await EncryptionProcessor.DecryptAsync(
result.ResourceStream,
this.encryptor,
diagnosticsContext,
cancellationToken);
}
}
}
return(response);
}
}
public async Task BatchSingleServerResponseAsync()
{
List <TransactionalBatchOperationResult> expectedResults = new List <TransactionalBatchOperationResult>();
CosmosJsonDotNetSerializer jsonSerializer = new CosmosJsonDotNetSerializer();
TestItem testItem = new TestItem("tst");
Stream itemStream = jsonSerializer.ToStream <TestItem>(testItem);
MemoryStream resourceStream = itemStream as MemoryStream;
if (resourceStream == null)
{
await itemStream.CopyToAsync(resourceStream);
resourceStream.Position = 0;
}
expectedResults.Add(
new TransactionalBatchOperationResult(HttpStatusCode.OK)
{
ETag = "theETag",
SubStatusCode = (SubStatusCodes)1100,
ResourceStream = resourceStream
});
expectedResults.Add(new TransactionalBatchOperationResult(HttpStatusCode.Conflict));
double requestCharge = 3.6;
TestHandler testHandler = new TestHandler(async(request, cancellationToken) =>
{
ResponseMessage responseMessage = new ResponseMessage(HttpStatusCode.OK, requestMessage: null, errorMessage: null)
{
Content = await new BatchResponsePayloadWriter(expectedResults).GeneratePayloadAsync()
};
responseMessage.Headers.RequestCharge = requestCharge;
return(responseMessage);
});
Container container = BatchUnitTests.GetContainer(testHandler);
TransactionalBatchResponse batchResponse = await new BatchCore((ContainerInternal)container, new Cosmos.PartitionKey(BatchUnitTests.PartitionKey1))
.ReadItem("id1")
.ReadItem("id2")
.ExecuteAsync();
Assert.AreEqual(HttpStatusCode.OK, batchResponse.StatusCode);
Assert.AreEqual(requestCharge, batchResponse.RequestCharge);
TransactionalBatchOperationResult <TestItem> result0 = batchResponse.GetOperationResultAtIndex <TestItem>(0);
Assert.AreEqual(expectedResults[0].StatusCode, result0.StatusCode);
Assert.AreEqual(expectedResults[0].SubStatusCode, result0.SubStatusCode);
Assert.AreEqual(expectedResults[0].ETag, result0.ETag);
Assert.AreEqual(testItem, result0.Resource);
Assert.AreEqual(expectedResults[1].StatusCode, batchResponse[1].StatusCode);
Assert.AreEqual(SubStatusCodes.Unknown, batchResponse[1].SubStatusCode);
Assert.IsNull(batchResponse[1].ETag);
Assert.IsNull(batchResponse[1].ResourceStream);
}
public void ToResponseMessage_MapsProperties()
{
TransactionalBatchOperationResult result = new TransactionalBatchOperationResult(HttpStatusCode.OK)
{
ResourceStream = new MemoryStream(new byte[] { 0x41, 0x42 }, index: 0, count: 2, writable: false, publiclyVisible: true),
ETag = "1234",
SubStatusCode = SubStatusCodes.CompletingSplit,
RetryAfter = TimeSpan.FromSeconds(10),
RequestCharge = 4.3,
Diagnostics = new PointOperationStatistics(
activityId: Guid.NewGuid().ToString(),
statusCode: HttpStatusCode.OK,
subStatusCode: SubStatusCodes.Unknown,
requestCharge: 0,
errorMessage: string.Empty,
method: HttpMethod.Get,
requestUri: new Uri("http://localhost"),
requestSessionToken: null,
responseSessionToken: null,
clientSideRequestStatistics: new CosmosClientSideRequestStatistics())
};
ResponseMessage response = result.ToResponseMessage();
Assert.AreEqual(result.ResourceStream, response.Content);
Assert.AreEqual(result.SubStatusCode, response.Headers.SubStatusCode);
Assert.AreEqual(result.RetryAfter, response.Headers.RetryAfter);
Assert.AreEqual(result.StatusCode, response.StatusCode);
Assert.AreEqual(result.RequestCharge, response.Headers.RequestCharge);
Assert.AreEqual(result.Diagnostics, response.Diagnostics);
}
private async Task <TransactionalBatchResponse> DecryptTransactionalBatchResponseAsync(
TransactionalBatchResponse response,
CosmosDiagnosticsContext diagnosticsContext,
CancellationToken cancellationToken)
{
List <TransactionalBatchOperationResult> decryptedTransactionalBatchOperationResults = new List <TransactionalBatchOperationResult>();
for (int index = 0; index < response.Count; index++)
{
TransactionalBatchOperationResult result = response[index];
if (response.IsSuccessStatusCode && result.ResourceStream != null)
{
Stream decryptedStream = await this.encryptionProcessor.DecryptAsync(
result.ResourceStream,
diagnosticsContext,
cancellationToken);
result = new EncryptionTransactionalBatchOperationResult(response[index], decryptedStream);
}
decryptedTransactionalBatchOperationResults.Add(result);
}
return(new EncryptionTransactionalBatchResponse(
decryptedTransactionalBatchOperationResults,
response,
this.cosmosSerializer));
}
public void GenericCanBeMocked()
{
Mock <TransactionalBatchOperationResult <object> > mockResult = new Mock <TransactionalBatchOperationResult <object> >();
TransactionalBatchOperationResult <object> result = mockResult.Object;
Assert.AreEqual(default(HttpStatusCode), result.StatusCode);
Assert.AreEqual(default(object), result.Resource);
}
public void IsSuccessStatusCodeTrueFor200to299()
{
for (int x = 100; x < 999; ++x)
{
TransactionalBatchOperationResult result = new TransactionalBatchOperationResult((HttpStatusCode)x);
bool success = x >= 200 && x <= 299;
Assert.AreEqual(success, result.IsSuccessStatusCode);
}
}
public async Task RetriesOn429()
{
IDocumentClientRetryPolicy retryPolicy = new BulkPartitionKeyRangeGoneRetryPolicy(
new ResourceThrottleRetryPolicy(1));
TransactionalBatchOperationResult result = new TransactionalBatchOperationResult((HttpStatusCode)StatusCodes.TooManyRequests);
ShouldRetryResult shouldRetryResult = await retryPolicy.ShouldRetryAsync(result.ToResponseMessage(), default(CancellationToken));
Assert.IsTrue(shouldRetryResult.ShouldRetry);
}
public async Task NotRetryOnSuccess()
{
IDocumentClientRetryPolicy retryPolicy = new BulkPartitionKeyRangeGoneRetryPolicy(
new ResourceThrottleRetryPolicy(1));
TransactionalBatchOperationResult result = new TransactionalBatchOperationResult(HttpStatusCode.OK);
ShouldRetryResult shouldRetryResult = await retryPolicy.ShouldRetryAsync(result.ToResponseMessage(), default(CancellationToken));
Assert.IsFalse(shouldRetryResult.ShouldRetry);
}
public async Task ShouldRetry_NoPolicy()
{
TransactionalBatchOperationResult result = new TransactionalBatchOperationResult(HttpStatusCode.OK);
ItemBatchOperation operation = new ItemBatchOperation(OperationType.Create, 0, Cosmos.PartitionKey.Null);
operation.AttachContext(new ItemBatchOperationContext(string.Empty));
ShouldRetryResult shouldRetryResult = await operation.Context.ShouldRetryAsync(result, default(CancellationToken));
Assert.IsFalse(shouldRetryResult.ShouldRetry);
}
public async Task TimerDispatchesAsync()
{
// Bigger batch size than the amount of operations, timer should dispatch
BatchAsyncStreamer batchAsyncStreamer = new BatchAsyncStreamer(2, MaxBatchByteSize, this.TimerWheel, this.limiter, 1, MockCosmosUtil.Serializer, this.Executor, this.Retrier, this.GetMockClientContext());
ItemBatchOperationContext context = AttachContext(this.ItemBatchOperation);
batchAsyncStreamer.Add(this.ItemBatchOperation);
TransactionalBatchOperationResult result = await context.OperationTask;
Assert.AreEqual(this.ItemBatchOperation.Id, result.ETag);
}
public async Task TimerDispatchesAsync()
{
// Bigger batch size than the amount of operations, timer should dispatch
BatchAsyncStreamer batchAsyncStreamer = new BatchAsyncStreamer(2, MaxBatchByteSize, DispatchTimerInSeconds, this.TimerPool, new CosmosJsonDotNetSerializer(), this.Executor, this.Retrier);
ItemBatchOperationContext context = AttachContext(this.ItemBatchOperation);
batchAsyncStreamer.Add(this.ItemBatchOperation);
TransactionalBatchOperationResult result = await context.OperationTask;
Assert.AreEqual(this.ItemBatchOperation.Id, result.ETag);
}
public async Task RetriesOn429()
{
IDocumentClientRetryPolicy retryPolicy = new BulkExecutionRetryPolicy(
Mock.Of <ContainerInternal>(),
OperationType.Read,
new ResourceThrottleRetryPolicy(1));
TransactionalBatchOperationResult result = new TransactionalBatchOperationResult((HttpStatusCode)StatusCodes.TooManyRequests);
ShouldRetryResult shouldRetryResult = await retryPolicy.ShouldRetryAsync(result.ToResponseMessage(), default);
Assert.IsTrue(shouldRetryResult.ShouldRetry);
}
public async Task ShouldRetry_WithPolicy_OnSuccess()
{
IDocumentClientRetryPolicy retryPolicy = new BulkPartitionKeyRangeGoneRetryPolicy(
new ResourceThrottleRetryPolicy(1));
TransactionalBatchOperationResult result = new TransactionalBatchOperationResult(HttpStatusCode.OK);
ItemBatchOperation operation = new ItemBatchOperation(OperationType.Create, 0, Cosmos.PartitionKey.Null);
operation.AttachContext(new ItemBatchOperationContext(string.Empty, retryPolicy));
ShouldRetryResult shouldRetryResult = await operation.Context.ShouldRetryAsync(result, default(CancellationToken));
Assert.IsFalse(shouldRetryResult.ShouldRetry);
}
public async Task RetriesOn413_OnWrite()
{
IDocumentClientRetryPolicy retryPolicy = new BulkExecutionRetryPolicy(
Mock.Of <ContainerInternal>(),
OperationType.Create,
new ResourceThrottleRetryPolicy(1));
TransactionalBatchOperationResult result = new TransactionalBatchOperationResult(HttpStatusCode.RequestEntityTooLarge);
ShouldRetryResult shouldRetryResult = await retryPolicy.ShouldRetryAsync(result.ToResponseMessage(), default);
Assert.IsFalse(shouldRetryResult.ShouldRetry);
}
public async Task NotRetryOnSuccess()
{
IDocumentClientRetryPolicy retryPolicy = new BulkExecutionRetryPolicy(
Mock.Of <ContainerInternal>(),
OperationType.Read,
new ResourceThrottleRetryPolicy(1));
TransactionalBatchOperationResult result = new TransactionalBatchOperationResult(HttpStatusCode.OK);
ShouldRetryResult shouldRetryResult = await retryPolicy.ShouldRetryAsync(result.ToResponseMessage(), default);
Assert.IsFalse(shouldRetryResult.ShouldRetry);
}
public void PropertiesAreSetThroughCopyCtor()
{
TransactionalBatchOperationResult other = CreateTestResult();
TransactionalBatchOperationResult result = new TransactionalBatchOperationResult(other);
Assert.AreEqual(other.StatusCode, result.StatusCode);
Assert.AreEqual(other.SubStatusCode, result.SubStatusCode);
Assert.AreEqual(other.ETag, result.ETag);
Assert.AreEqual(other.RequestCharge, result.RequestCharge);
Assert.AreEqual(other.RetryAfter, result.RetryAfter);
Assert.AreSame(other.ResourceStream, result.ResourceStream);
}
public async Task ShouldRetry_WithPolicy_On429()
{
IDocumentClientRetryPolicy retryPolicy = new BulkPartitionKeyRangeGoneRetryPolicy(
new ResourceThrottleRetryPolicy(1));
TransactionalBatchOperationResult result = new TransactionalBatchOperationResult((HttpStatusCode)StatusCodes.TooManyRequests);
ItemBatchOperation operation = new ItemBatchOperation(OperationType.Create, 0);
operation.AttachContext(new ItemBatchOperationContext(string.Empty, retryPolicy));
ShouldRetryResult shouldRetryResult = await operation.Context.ShouldRetryAsync(result, default(CancellationToken));
Assert.IsTrue(shouldRetryResult.ShouldRetry);
}
public async Task DispatchWithLessResponses()
{
BatchAsyncBatcher batchAsyncBatcher = new BatchAsyncBatcher(10, 1000, MockCosmosUtil.Serializer, this.ExecutorWithLessResponses, this.Retrier, BatchAsyncBatcherTests.MockClientContext());
BatchAsyncBatcher secondAsyncBatcher = new BatchAsyncBatcher(10, 1000, MockCosmosUtil.Serializer, this.Executor, this.Retrier, BatchAsyncBatcherTests.MockClientContext());
List <ItemBatchOperation> operations = new List <ItemBatchOperation>(10);
for (int i = 0; i < 10; i++)
{
ItemBatchOperation operation = new ItemBatchOperation(OperationType.Create, i, Cosmos.PartitionKey.Null, i.ToString());
ItemBatchOperationContext context = new ItemBatchOperationContext(string.Empty, NoOpTrace.Singleton);
operation.AttachContext(context);
operations.Add(operation);
Assert.IsTrue(batchAsyncBatcher.TryAdd(operation));
}
await batchAsyncBatcher.DispatchAsync(metric);
// Responses 1 and 10 should be missing
for (int i = 0; i < 10; i++)
{
ItemBatchOperation operation = operations[i];
// Some tasks should not be resolved
if (i == 0 || i == 9)
{
Assert.IsTrue(operation.Context.OperationTask.Status == TaskStatus.WaitingForActivation);
}
else
{
Assert.IsTrue(operation.Context.OperationTask.Status == TaskStatus.RanToCompletion);
}
if (operation.Context.OperationTask.Status == TaskStatus.RanToCompletion)
{
TransactionalBatchOperationResult result = await operation.Context.OperationTask;
Assert.AreEqual(i.ToString(), result.ETag);
}
else
{
// Pass the pending one to another batcher
Assert.IsTrue(secondAsyncBatcher.TryAdd(operation));
}
}
await secondAsyncBatcher.DispatchAsync(metric);
// All tasks should be completed
for (int i = 0; i < 10; i++)
{
ItemBatchOperation operation = operations[i];
Assert.AreEqual(TaskStatus.RanToCompletion, operation.Context.OperationTask.Status);
TransactionalBatchOperationResult result = await operation.Context.OperationTask;
Assert.AreEqual(i.ToString(), result.ETag);
}
}
public async Task RetriesOnCompletingPartitionMigrationSplits()
{
IDocumentClientRetryPolicy retryPolicy = new BulkPartitionKeyRangeGoneRetryPolicy(
new ResourceThrottleRetryPolicy(1));
TransactionalBatchOperationResult result = new TransactionalBatchOperationResult(HttpStatusCode.Gone)
{
SubStatusCode = SubStatusCodes.CompletingPartitionMigration
};
ShouldRetryResult shouldRetryResult = await retryPolicy.ShouldRetryAsync(result.ToResponseMessage(), default);
Assert.IsTrue(shouldRetryResult.ShouldRetry);
}
public override TransactionalBatchOperationResult <T> GetOperationResultAtIndex <T>(int index)
{
TransactionalBatchOperationResult result = this.results[index];
T resource = default;
if (result.ResourceStream != null)
{
resource = this.cosmosSerializer.FromStream <T>(result.ResourceStream);
}
return(new EncryptionTransactionalBatchOperationResult <T>(resource));
}
public void PropertiesAreSetThroughGenericCtor()
{
TransactionalBatchOperationResult other = CreateTestResult();
object testObject = new object();
TransactionalBatchOperationResult <object> result = new TransactionalBatchOperationResult <object>(other, testObject);
Assert.AreEqual(other.StatusCode, result.StatusCode);
Assert.AreEqual(other.SubStatusCode, result.SubStatusCode);
Assert.AreEqual(other.ETag, result.ETag);
Assert.AreEqual(other.RequestCharge, result.RequestCharge);
Assert.AreEqual(other.RetryAfter, result.RetryAfter);
Assert.AreSame(other.ResourceStream, result.ResourceStream);
Assert.AreSame(testObject, result.Resource);
}
public void ToResponseMessageHasPropertiesMapped()
{
TransactionalBatchOperationResult result = CreateTestResult();
ResponseMessage response = result.ToResponseMessage();
Assert.AreEqual(result.StatusCode, response.StatusCode);
Assert.AreEqual(result.SubStatusCode, response.Headers.SubStatusCode);
Assert.AreEqual(result.ETag, response.Headers.ETag);
Assert.AreEqual(result.RequestCharge, response.Headers.RequestCharge);
Assert.AreEqual(result.RetryAfter, response.Headers.RetryAfter);
Assert.AreSame(result.ResourceStream, response.Content);
Assert.IsNotNull(response.Diagnostics);
}
public async Task ShouldRetry_WithPolicy_On413_OnWrite()
{
IDocumentClientRetryPolicy retryPolicy = new BulkExecutionRetryPolicy(
Mock.Of <ContainerInternal>(),
OperationType.Create,
new ResourceThrottleRetryPolicy(1));
TransactionalBatchOperationResult result = new TransactionalBatchOperationResult(HttpStatusCode.RequestEntityTooLarge);
ItemBatchOperation operation = new ItemBatchOperation(OperationType.Create, 0, Cosmos.PartitionKey.Null);
operation.AttachContext(new ItemBatchOperationContext(string.Empty, retryPolicy));
ShouldRetryResult shouldRetryResult = await operation.Context.ShouldRetryAsync(result, default);
Assert.IsFalse(shouldRetryResult.ShouldRetry);
}
public async Task ShouldRetry_WithPolicy_On429()
{
IDocumentClientRetryPolicy retryPolicy = new BulkExecutionRetryPolicy(
Mock.Of <ContainerInternal>(),
OperationType.Read,
new ResourceThrottleRetryPolicy(1));
TransactionalBatchOperationResult result = new TransactionalBatchOperationResult((HttpStatusCode)StatusCodes.TooManyRequests);
ItemBatchOperation operation = new ItemBatchOperation(OperationType.Create, 0, Cosmos.PartitionKey.Null);
operation.AttachContext(new ItemBatchOperationContext(string.Empty, NoOpTrace.Singleton, retryPolicy));
ShouldRetryResult shouldRetryResult = await operation.Context.ShouldRetryAsync(result, default);
Assert.IsTrue(shouldRetryResult.ShouldRetry);
}
public async Task TaskResultIsSetOnCompleteAsync()
{
ItemBatchOperation operation = new ItemBatchOperation(OperationType.Create, 0, Cosmos.PartitionKey.Null);
ItemBatchOperationContext batchAsyncOperationContext = new ItemBatchOperationContext(string.Empty);
operation.AttachContext(batchAsyncOperationContext);
TransactionalBatchOperationResult expected = new TransactionalBatchOperationResult(HttpStatusCode.OK);
batchAsyncOperationContext.Complete(null, expected);
Assert.AreEqual(expected, await batchAsyncOperationContext.OperationTask);
Assert.AreEqual(TaskStatus.RanToCompletion, batchAsyncOperationContext.OperationTask.Status);
}
