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); }