public async Task DispatchesAsync()
{
// Expect all operations to complete as their batches get dispached
BatchAsyncStreamer batchAsyncStreamer = new BatchAsyncStreamer(
2,
MaxBatchByteSize,
DispatchTimerInSeconds,
this.TimerPool,
this.limiter,
1,
MockCosmosUtil.Serializer,
this.Executor,
this.Retrier);
List <Task <TransactionalBatchOperationResult> > contexts = new List <Task <TransactionalBatchOperationResult> >(10);
for (int i = 0; i < 10; i++)
{
ItemBatchOperation operation = new ItemBatchOperation(OperationType.Create, i, 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);
}
}
private static ItemBatchOperationContext AttachContext(ItemBatchOperation operation)
{
ItemBatchOperationContext context = new ItemBatchOperationContext(string.Empty);
operation.AttachContext(context);
return(context);
}
public async Task RetrierGetsCalledOn413_OnWrite()
{
IDocumentClientRetryPolicy retryPolicy1 = new BulkExecutionRetryPolicy(
GetSplitEnabledContainer(),
OperationType.Create,
new ResourceThrottleRetryPolicy(1));
IDocumentClientRetryPolicy retryPolicy2 = new BulkExecutionRetryPolicy(
GetSplitEnabledContainer(),
OperationType.Create,
new ResourceThrottleRetryPolicy(1));
ItemBatchOperation operation1 = this.CreateItemBatchOperation();
ItemBatchOperation operation2 = this.CreateItemBatchOperation();
operation1.AttachContext(new ItemBatchOperationContext(string.Empty, retryPolicy1));
operation2.AttachContext(new ItemBatchOperationContext(string.Empty, retryPolicy2));
Mock <BatchAsyncBatcherRetryDelegate> retryDelegate = new Mock <BatchAsyncBatcherRetryDelegate>();
BatchAsyncBatcher batchAsyncBatcher = new BatchAsyncBatcher(2, 1000, MockCosmosUtil.Serializer, this.ExecutorWith413, retryDelegate.Object);
Assert.IsTrue(batchAsyncBatcher.TryAdd(operation1));
Assert.IsTrue(batchAsyncBatcher.TryAdd(operation2));
await batchAsyncBatcher.DispatchAsync(metric);
retryDelegate.Verify(a => a(It.Is <ItemBatchOperation>(o => o == operation1), It.IsAny <CancellationToken>()), Times.Never);
retryDelegate.Verify(a => a(It.Is <ItemBatchOperation>(o => o == operation2), It.IsAny <CancellationToken>()), Times.Never);
retryDelegate.Verify(a => a(It.IsAny <ItemBatchOperation>(), It.IsAny <CancellationToken>()), Times.Never);
}
public async Task RetrierGetsCalledOnSplit()
{
IDocumentClientRetryPolicy retryPolicy1 = new BulkPartitionKeyRangeGoneRetryPolicy(
new ResourceThrottleRetryPolicy(1));
IDocumentClientRetryPolicy retryPolicy2 = new BulkPartitionKeyRangeGoneRetryPolicy(
new ResourceThrottleRetryPolicy(1));
ItemBatchOperation operation1 = this.CreateItemBatchOperation();
ItemBatchOperation operation2 = this.CreateItemBatchOperation();
operation1.AttachContext(new ItemBatchOperationContext(string.Empty, retryPolicy1));
operation2.AttachContext(new ItemBatchOperationContext(string.Empty, retryPolicy2));
Mock <BatchAsyncBatcherRetryDelegate> retryDelegate = new Mock <BatchAsyncBatcherRetryDelegate>();
BatchAsyncBatcher batchAsyncBatcher = new BatchAsyncBatcher(2, 1000, new CosmosJsonDotNetSerializer(), this.ExecutorWithSplit, retryDelegate.Object);
Assert.IsTrue(batchAsyncBatcher.TryAdd(operation1));
Assert.IsTrue(batchAsyncBatcher.TryAdd(operation2));
await batchAsyncBatcher.DispatchAsync();
retryDelegate.Verify(a => a(It.Is <ItemBatchOperation>(o => o == operation1), It.IsAny <CancellationToken>()), Times.Once);
retryDelegate.Verify(a => a(It.Is <ItemBatchOperation>(o => o == operation2), It.IsAny <CancellationToken>()), Times.Once);
retryDelegate.Verify(a => a(It.IsAny <ItemBatchOperation>(), It.IsAny <CancellationToken>()), Times.Exactly(2));
}
public async Task DispatchProcessInOrderAsync()
{
BatchAsyncBatcher batchAsyncBatcher = new BatchAsyncBatcher(10, 1000, MockCosmosUtil.Serializer, this.Executor, this.Retrier);
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(),
diagnosticsContext: new CosmosDiagnosticsContextCore());
ItemBatchOperationContext context = new ItemBatchOperationContext(string.Empty);
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);
Assert.IsNotNull(operation.DiagnosticsContext);
Assert.AreEqual(operation.DiagnosticsContext, result.DiagnosticsContext);
Assert.IsFalse(string.IsNullOrEmpty(operation.DiagnosticsContext.ToString()));
}
}
public async Task RetrierGetsCalledOnCompletingPartitionMigration()
{
IDocumentClientRetryPolicy retryPolicy1 = new BulkExecutionRetryPolicy(
GetSplitEnabledContainer(),
OperationType.Read,
new ResourceThrottleRetryPolicy(1));
IDocumentClientRetryPolicy retryPolicy2 = new BulkExecutionRetryPolicy(
GetSplitEnabledContainer(),
OperationType.Read,
new ResourceThrottleRetryPolicy(1));
ItemBatchOperation operation1 = this.CreateItemBatchOperation();
ItemBatchOperation operation2 = this.CreateItemBatchOperation();
operation1.AttachContext(new ItemBatchOperationContext(string.Empty, retryPolicy1));
operation2.AttachContext(new ItemBatchOperationContext(string.Empty, retryPolicy2));
Mock <BatchAsyncBatcherRetryDelegate> retryDelegate = new Mock <BatchAsyncBatcherRetryDelegate>();
BatchAsyncBatcher batchAsyncBatcher = new BatchAsyncBatcher(2, 1000, MockCosmosUtil.Serializer, this.ExecutorWithCompletingPartitionMigration, retryDelegate.Object);
Assert.IsTrue(batchAsyncBatcher.TryAdd(operation1));
Assert.IsTrue(batchAsyncBatcher.TryAdd(operation2));
await batchAsyncBatcher.DispatchAsync(metric);
retryDelegate.Verify(a => a(It.Is <ItemBatchOperation>(o => o == operation1), It.IsAny <CancellationToken>()), Times.Once);
retryDelegate.Verify(a => a(It.Is <ItemBatchOperation>(o => o == operation2), It.IsAny <CancellationToken>()), Times.Once);
retryDelegate.Verify(a => a(It.IsAny <ItemBatchOperation>(), It.IsAny <CancellationToken>()), Times.Exactly(2));
Assert.IsNull(operation1.DiagnosticsContext, "Batch operations do not have diagnostics per operation");
Assert.IsNull(operation2.DiagnosticsContext, "Batch operations do not have diagnostics per operation");
}
public void CannotAttachMoreThanOnce()
{
ItemBatchOperation operation = new ItemBatchOperation(OperationType.Create, 0, Cosmos.PartitionKey.Null);
operation.AttachContext(new ItemBatchOperationContext(string.Empty));
Assert.ThrowsException <InvalidOperationException>(() => operation.AttachContext(new ItemBatchOperationContext(string.Empty)));
}
private async Task <ResponseMessage> GenerateOkResponseAsync(ItemBatchOperation itemBatchOperation)
{
List <BatchOperationResult> results = new List <BatchOperationResult>();
ItemBatchOperation[] arrayOperations = new ItemBatchOperation[1];
results.Add(
new BatchOperationResult(HttpStatusCode.OK)
{
ETag = itemBatchOperation.Id
});
arrayOperations[0] = itemBatchOperation;
MemoryStream responseContent = await new BatchResponsePayloadWriter(results).GeneratePayloadAsync();
SinglePartitionKeyServerBatchRequest batchRequest = await SinglePartitionKeyServerBatchRequest.CreateAsync(
partitionKey : null,
operations : new ArraySegment <ItemBatchOperation>(arrayOperations),
maxBodyLength : 100,
maxOperationCount : 1,
serializer : new CosmosJsonDotNetSerializer(),
cancellationToken : CancellationToken.None);
ResponseMessage responseMessage = new ResponseMessage(HttpStatusCode.OK)
{
Content = responseContent
};
return(responseMessage);
}
public async Task StatusCodesAreSetThroughResponseAsync()
{
List <TransactionalBatchOperationResult> results = new List <TransactionalBatchOperationResult>();
ItemBatchOperation[] arrayOperations = new ItemBatchOperation[1];
ItemBatchOperation operation = new ItemBatchOperation(OperationType.Read, 0, "0");
results.Add(
new TransactionalBatchOperationResult(HttpStatusCode.OK)
{
ResourceStream = new MemoryStream(new byte[] { 0x41, 0x42 }, index: 0, count: 2, writable: false, publiclyVisible: true),
ETag = operation.Id
});
arrayOperations[0] = operation;
MemoryStream responseContent = await new BatchResponsePayloadWriter(results).GeneratePayloadAsync();
SinglePartitionKeyServerBatchRequest batchRequest = await SinglePartitionKeyServerBatchRequest.CreateAsync(
partitionKey : null,
operations : new ArraySegment <ItemBatchOperation>(arrayOperations),
serializer : new CosmosJsonDotNetSerializer(),
cancellationToken : default(CancellationToken));
TransactionalBatchResponse batchresponse = await TransactionalBatchResponse.FromResponseMessageAsync(
new ResponseMessage(HttpStatusCode.OK) { Content = responseContent },
batchRequest,
new CosmosJsonDotNetSerializer());
PartitionKeyRangeBatchResponse response = new PartitionKeyRangeBatchResponse(arrayOperations.Length, batchresponse, new CosmosJsonDotNetSerializer());
Assert.AreEqual(HttpStatusCode.OK, response.StatusCode);
}
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()));
}
}
private async Task <ResponseMessage> GenerateOkResponseAsync(ItemBatchOperation itemBatchOperation)
{
List <BatchOperationResult> results = new List <BatchOperationResult>();
ItemBatchOperation[] arrayOperations = new ItemBatchOperation[1];
results.Add(
new BatchOperationResult(HttpStatusCode.OK)
{
ETag = itemBatchOperation.Id
});
arrayOperations[0] = itemBatchOperation;
MemoryStream responseContent = await new BatchResponsePayloadWriter(results).GeneratePayloadAsync();
SinglePartitionKeyServerBatchRequest batchRequest = await SinglePartitionKeyServerBatchRequest.CreateAsync(
partitionKey : null,
operations : new ArraySegment <ItemBatchOperation>(arrayOperations),
maxBodyLength : 100,
maxOperationCount : 1,
serializer : new CosmosJsonDotNetSerializer(),
cancellationToken : CancellationToken.None);
ResponseMessage responseMessage = new ResponseMessage(HttpStatusCode.OK)
{
Content = responseContent, Diagnostics = new PointOperationStatistics(HttpStatusCode.OK, SubStatusCodes.Unknown, 0, string.Empty, HttpMethod.Get, new Uri("http://localhost"), new CosmosClientSideRequestStatistics())
};
return(responseMessage);
}
public async Task StatusCodesAreSetThroughResponseAsync()
{
List <TransactionalBatchOperationResult> results = new List <TransactionalBatchOperationResult>();
ItemBatchOperation[] arrayOperations = new ItemBatchOperation[1];
ItemBatchOperation operation = new ItemBatchOperation(OperationType.Read, 0, Cosmos.PartitionKey.Null, "0");
results.Add(
new TransactionalBatchOperationResult(HttpStatusCode.OK)
{
ResourceStream = new MemoryStream(new byte[] { 0x41, 0x42 }, index: 0, count: 2, writable: false, publiclyVisible: true),
ETag = operation.Id
});
arrayOperations[0] = operation;
MemoryStream responseContent = await new BatchResponsePayloadWriter(results).GeneratePayloadAsync();
SinglePartitionKeyServerBatchRequest batchRequest = await SinglePartitionKeyServerBatchRequest.CreateAsync(
partitionKey : null,
operations : new ArraySegment <ItemBatchOperation>(arrayOperations),
serializerCore : MockCosmosUtil.Serializer,
trace : NoOpTrace.Singleton,
cancellationToken : default);
public async Task DiagnosticsAreSetThroughResponseAsync()
{
List <TransactionalBatchOperationResult> results = new List <TransactionalBatchOperationResult>();
ItemBatchOperation[] arrayOperations = new ItemBatchOperation[1];
ItemBatchOperation operation = new ItemBatchOperation(OperationType.AddComputeGatewayRequestCharges, 0, "0");
results.Add(
new TransactionalBatchOperationResult(HttpStatusCode.OK)
{
ResourceStream = new MemoryStream(new byte[] { 0x41, 0x42 }, index: 0, count: 2, writable: false, publiclyVisible: true),
ETag = operation.Id
});
arrayOperations[0] = operation;
MemoryStream responseContent = await new BatchResponsePayloadWriter(results).GeneratePayloadAsync();
SinglePartitionKeyServerBatchRequest batchRequest = await SinglePartitionKeyServerBatchRequest.CreateAsync(
partitionKey : null,
operations : new ArraySegment <ItemBatchOperation>(arrayOperations),
serializerCore : MockCosmosUtil.Serializer,
cancellationToken : default(CancellationToken));
PointOperationStatistics 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 responseMessage = new ResponseMessage(HttpStatusCode.OK)
{
Content = responseContent,
};
responseMessage.DiagnosticsContext.AddDiagnosticsInternal(diagnostics);
TransactionalBatchResponse batchresponse = await TransactionalBatchResponse.FromResponseMessageAsync(
responseMessage,
batchRequest,
MockCosmosUtil.Serializer);
PartitionKeyRangeBatchResponse response = new PartitionKeyRangeBatchResponse(arrayOperations.Length, batchresponse, MockCosmosUtil.Serializer);
string pointDiagnosticString = diagnostics.ToString();
pointDiagnosticString = pointDiagnosticString.Substring(1, pointDiagnosticString.Length - 2);
string diagnosticContextString = response.DiagnosticsContext.ToString();
Assert.IsTrue(diagnosticContextString.Contains(pointDiagnosticString));
}
public async Task BatchRequestSerializationFillAsync()
{
const int maxBodySize = 5 * 1024;
const int maxOperationCount = 10;
const int operationBodySize = 2 * 1024;
const string partitionKey1 = "pk1";
const string id = "random";
ItemBatchOperation[] operations = new ItemBatchOperation[]
{
new ItemBatchOperation(
operationType: OperationType.Replace,
id: id,
operationIndex: 0)
{
ResourceBody = Encoding.UTF8.GetBytes(new string('w', operationBodySize))
},
new ItemBatchOperation(
operationType: OperationType.Create,
operationIndex: 1)
{
ResourceBody = Encoding.UTF8.GetBytes(new string('x', operationBodySize))
},
new ItemBatchOperation(
operationType: OperationType.Upsert,
operationIndex: 2)
{
ResourceBody = Encoding.UTF8.GetBytes(new string('y', operationBodySize))
},
new ItemBatchOperation(
operationType: OperationType.Create,
operationIndex: 3)
{
ResourceBody = Encoding.UTF8.GetBytes(new string('z', operationBodySize))
}
};
ServerBatchRequest batchRequest = await SinglePartitionKeyServerBatchRequest.CreateAsync(
new Cosmos.PartitionKey(partitionKey1),
new ArraySegment <ItemBatchOperation>(operations),
maxBodySize,
maxOperationCount,
serializer : new CosmosJsonDotNetSerializer(),
cancellationToken : CancellationToken.None);
Assert.AreEqual(2, batchRequest.Operations.Count);
using (MemoryStream payload = batchRequest.TransferBodyStream())
{
Assert.IsNotNull(payload);
List <ItemBatchOperation> readOperations = await new BatchRequestPayloadReader().ReadPayloadAsync(payload);
Assert.AreEqual(2, readOperations.Count);
ItemBatchOperationEqualityComparer comparer = new ItemBatchOperationEqualityComparer();
Assert.IsTrue(comparer.Equals(operations[0], readOperations[0]));
Assert.IsTrue(comparer.Equals(operations[1], readOperations[1]));
}
}
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);
Assert.IsFalse(shouldRetryResult.ShouldRetry);
}
public async Task ShouldRetry_NoPolicy()
{
BatchOperationResult result = new BatchOperationResult(HttpStatusCode.OK);
ItemBatchOperation operation = new ItemBatchOperation(OperationType.Create, 0);
operation.AttachContext(new ItemBatchOperationContext(string.Empty));
ShouldRetryResult shouldRetryResult = await operation.Context.ShouldRetryAsync(result, default(CancellationToken));
Assert.IsFalse(shouldRetryResult.ShouldRetry);
}
public async Task CannotAddToDispatchedBatch()
{
BatchAsyncBatcher batchAsyncBatcher = new BatchAsyncBatcher(1, 1000, MockCosmosUtil.Serializer, this.Executor, this.Retrier, BatchAsyncBatcherTests.MockClientContext());
ItemBatchOperation operation = this.CreateItemBatchOperation();
operation.AttachContext(new ItemBatchOperationContext(string.Empty, NoOpTrace.Singleton));
Assert.IsTrue(batchAsyncBatcher.TryAdd(operation));
await batchAsyncBatcher.DispatchAsync(metric);
Assert.IsFalse(batchAsyncBatcher.TryAdd(this.CreateItemBatchOperation()));
}
public async Task CannotAddToDispatchedBatch()
{
BatchAsyncBatcher batchAsyncBatcher = new BatchAsyncBatcher(1, 1000, new CosmosJsonDotNetSerializer(), this.Executor, this.Retrier);
ItemBatchOperation operation = this.CreateItemBatchOperation();
operation.AttachContext(new ItemBatchOperationContext(string.Empty));
Assert.IsTrue(batchAsyncBatcher.TryAdd(operation));
await batchAsyncBatcher.DispatchAsync();
Assert.IsFalse(batchAsyncBatcher.TryAdd(this.CreateItemBatchOperation()));
}
private ItemBatchOperation CreateItemBatchOperation(bool withContext = false)
{
ItemBatchOperation operation = new ItemBatchOperation(OperationType.Create, 0, string.Empty, new MemoryStream(new byte[] { 0x41, 0x42 }, index: 0, count: 2, writable: false, publiclyVisible: true));
if (withContext)
{
operation.AttachContext(new ItemBatchOperationContext(string.Empty));
}
return(operation);
}
public void TaskIsCreatedOnInitialization()
{
ItemBatchOperation operation = new ItemBatchOperation(OperationType.Create, 0);
ItemBatchOperationContext batchAsyncOperationContext = new ItemBatchOperationContext(string.Empty);
operation.AttachContext(batchAsyncOperationContext);
Assert.IsNotNull(batchAsyncOperationContext.OperationTask);
Assert.AreEqual(batchAsyncOperationContext, operation.Context);
Assert.AreEqual(TaskStatus.WaitingForActivation, batchAsyncOperationContext.OperationTask.Status);
}
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 HasFixedByteSize()
{
ItemBatchOperation itemBatchOperation = this.CreateItemBatchOperation(true);
await itemBatchOperation.MaterializeResourceAsync(MockCosmosUtil.Serializer, default);
// Each operation is 2 bytes
BatchAsyncBatcher batchAsyncBatcher = new BatchAsyncBatcher(3, 4, MockCosmosUtil.Serializer, this.Executor, this.Retrier, BatchAsyncBatcherTests.MockClientContext());
Assert.IsTrue(batchAsyncBatcher.TryAdd(itemBatchOperation));
Assert.IsTrue(batchAsyncBatcher.TryAdd(itemBatchOperation));
Assert.IsFalse(batchAsyncBatcher.TryAdd(itemBatchOperation));
}
public async Task HasFixedByteSize()
{
ItemBatchOperation itemBatchOperation = this.CreateItemBatchOperation(true);
await itemBatchOperation.MaterializeResourceAsync(new CosmosJsonDotNetSerializer(), default(CancellationToken));
// Each operation is 2 bytes
BatchAsyncBatcher batchAsyncBatcher = new BatchAsyncBatcher(3, 4, new CosmosJsonDotNetSerializer(), this.Executor, this.Retrier);
Assert.IsTrue(batchAsyncBatcher.TryAdd(itemBatchOperation));
Assert.IsTrue(batchAsyncBatcher.TryAdd(itemBatchOperation));
Assert.IsFalse(batchAsyncBatcher.TryAdd(itemBatchOperation));
}
public async Task ShouldRetry_WithPolicy_OnSuccess()
{
IDocumentClientRetryPolicy retryPolicy = new BulkPartitionKeyRangeGoneRetryPolicy(
new ResourceThrottleRetryPolicy(1));
BatchOperationResult result = new BatchOperationResult(HttpStatusCode.OK);
ItemBatchOperation operation = new ItemBatchOperation(OperationType.Create, 0);
operation.AttachContext(new ItemBatchOperationContext(string.Empty, retryPolicy));
ShouldRetryResult shouldRetryResult = await operation.Context.ShouldRetryAsync(result, default(CancellationToken));
Assert.IsFalse(shouldRetryResult.ShouldRetry);
}
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, Cosmos.PartitionKey.Null);
operation.AttachContext(new ItemBatchOperationContext(string.Empty, retryPolicy));
ShouldRetryResult shouldRetryResult = await operation.Context.ShouldRetryAsync(result, default(CancellationToken));
Assert.IsTrue(shouldRetryResult.ShouldRetry);
}
private static async Task <ResponseMessage> GenerateResponseAsync(
ItemBatchOperation itemBatchOperation,
HttpStatusCode httpStatusCode,
SubStatusCodes subStatusCode)
{
List <TransactionalBatchOperationResult> results = new List <TransactionalBatchOperationResult>();
ItemBatchOperation[] arrayOperations = new ItemBatchOperation[1];
results.Add(
new TransactionalBatchOperationResult(httpStatusCode)
{
ETag = itemBatchOperation.Id,
SubStatusCode = subStatusCode
});
arrayOperations[0] = itemBatchOperation;
MemoryStream responseContent = await new BatchResponsePayloadWriter(results).GeneratePayloadAsync();
_ = await SinglePartitionKeyServerBatchRequest.CreateAsync(
partitionKey : null,
operations : new ArraySegment <ItemBatchOperation>(arrayOperations),
serializerCore : MockCosmosUtil.Serializer,
trace : NoOpTrace.Singleton,
cancellationToken : CancellationToken.None);
ResponseMessage responseMessage = new ResponseMessage(httpStatusCode)
{
Content = responseContent,
};
using (responseMessage.Trace = Trace.GetRootTrace("Test Trace"))
{
responseMessage.Trace.AddDatum(
"Point Operation Statistics",
new PointOperationStatisticsTraceDatum(
activityId: Guid.NewGuid().ToString(),
statusCode: httpStatusCode,
subStatusCode: subStatusCode,
responseTimeUtc: DateTime.UtcNow,
requestCharge: 0,
errorMessage: string.Empty,
method: HttpMethod.Get,
requestUri: "http://localhost",
requestSessionToken: null,
responseSessionToken: null,
beLatencyInMs: "0.42"));
}
responseMessage.Headers.SubStatusCode = subStatusCode;
return(responseMessage);
}
public void PartitionKeyRangeIdIsSetOnInitialization()
{
string expectedPkRangeId = Guid.NewGuid().ToString();
ItemBatchOperation operation = new ItemBatchOperation(OperationType.Create, 0);
ItemBatchOperationContext batchAsyncOperationContext = new ItemBatchOperationContext(expectedPkRangeId);
operation.AttachContext(batchAsyncOperationContext);
Assert.IsNotNull(batchAsyncOperationContext.OperationTask);
Assert.AreEqual(batchAsyncOperationContext, operation.Context);
Assert.AreEqual(expectedPkRangeId, batchAsyncOperationContext.PartitionKeyRangeId);
Assert.AreEqual(TaskStatus.WaitingForActivation, batchAsyncOperationContext.OperationTask.Status);
}
public async Task ShouldRetry_WithPolicy_OnSuccess()
{
IDocumentClientRetryPolicy retryPolicy = new BulkPartitionKeyRangeGoneRetryPolicy(
Mock.Of <ContainerInternal>(),
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);
Assert.IsFalse(shouldRetryResult.ShouldRetry);
}
public async Task TaskResultIsSetOnCompleteAsync()
{
ItemBatchOperation operation = new ItemBatchOperation(OperationType.Create, 0);
ItemBatchOperationContext batchAsyncOperationContext = new ItemBatchOperationContext(string.Empty);
operation.AttachContext(batchAsyncOperationContext);
BatchOperationResult expected = new BatchOperationResult(HttpStatusCode.OK);
batchAsyncOperationContext.Complete(null, expected);
Assert.AreEqual(expected, await batchAsyncOperationContext.OperationTask);
Assert.AreEqual(TaskStatus.RanToCompletion, batchAsyncOperationContext.OperationTask.Status);
}
public async Task ShouldRetry_WithPolicy_On413_OnRead()
{
IDocumentClientRetryPolicy retryPolicy = new BulkExecutionRetryPolicy(
Mock.Of <ContainerInternal>(),
OperationType.Read,
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.IsTrue(shouldRetryResult.ShouldRetry);
}