public void ConstructPatchOperationTest() { PatchOperation operation = PatchOperation.CreateAddOperation(path, "string"); PatchOperationTests.ValidateOperations(operation, PatchOperationType.Add, "string"); DateTime current = DateTime.UtcNow; operation = PatchOperation.CreateAddOperation(path, current); PatchOperationTests.ValidateOperations(operation, PatchOperationType.Add, current); dynamic complexObject = new { a = "complex", b = 12.34, c = true }; operation = PatchOperation.CreateAddOperation(path, complexObject); PatchOperationTests.ValidateOperations(operation, PatchOperationType.Add, complexObject); operation = PatchOperation.CreateRemoveOperation(path); PatchOperationTests.ValidateOperations(operation, PatchOperationType.Remove, "value not required"); int[] arrayObject = { 1, 2, 3 }; operation = PatchOperation.CreateReplaceOperation(path, arrayObject); PatchOperationTests.ValidateOperations(operation, PatchOperationType.Replace, arrayObject); Guid guid = new Guid(); operation = PatchOperation.CreateSetOperation(path, guid); PatchOperationTests.ValidateOperations(operation, PatchOperationType.Set, guid); }
private async Task Validate( ItemRequestOptions requestOptions, Action <ItemResponse <ToDoActivity> > ValidateWrite, Action <ItemResponse <ToDoActivity> > ValidateRead) { ToDoActivity item = ToDoActivity.CreateRandomToDoActivity(); ItemResponse <ToDoActivity> itemResponse = await this.container.CreateItemAsync(item, requestOptions : requestOptions); Assert.AreEqual(HttpStatusCode.Created, itemResponse.StatusCode); ValidateWrite(itemResponse); itemResponse = await this.container.ReadItemAsync <ToDoActivity>(item.id, new PartitionKey(item.status), requestOptions : requestOptions); Assert.AreEqual(HttpStatusCode.OK, itemResponse.StatusCode); ValidateRead(itemResponse); item.cost = 424242.42; itemResponse = await this.container.UpsertItemAsync <ToDoActivity>(item, requestOptions : requestOptions); Assert.AreEqual(HttpStatusCode.OK, itemResponse.StatusCode); ValidateWrite(itemResponse); item.cost = 9000.42; itemResponse = await this.container.ReplaceItemAsync <ToDoActivity>( item, item.id, new PartitionKey(item.status), requestOptions : requestOptions); Assert.AreEqual(HttpStatusCode.OK, itemResponse.StatusCode); ValidateWrite(itemResponse); item.cost = 1000; List <PatchOperation> patch = new List <PatchOperation>() { PatchOperation.CreateReplaceOperation("/cost", item.cost) }; itemResponse = await this.containerInternal.PatchItemAsync <ToDoActivity>( item.id, new PartitionKey(item.status), patchOperations : patch, requestOptions : requestOptions); Assert.AreEqual(HttpStatusCode.OK, itemResponse.StatusCode); ValidateWrite(itemResponse); itemResponse = await this.container.DeleteItemAsync <ToDoActivity>( item.id, new PartitionKey(item.status), requestOptions : requestOptions); Assert.AreEqual(HttpStatusCode.NoContent, itemResponse.StatusCode); this.ValidateItemNoContentResponse(itemResponse); }
public async Task BatchCreateAndPatchAsync() { TestDoc testDoc = BatchTestBase.PopulateTestDoc(this.PartitionKey1); List <PatchOperation> patchOperations = new List <PatchOperation>() { PatchOperation.CreateReplaceOperation("/Cost", testDoc.Cost + 1) }; BatchCore batch = (BatchCore) new BatchCore((ContainerInlineCore)BatchTestBase.JsonContainer, BatchTestBase.GetPartitionKey(this.PartitionKey1)) .CreateItem(testDoc); batch = (BatchCore)batch.PatchItem(testDoc.Id, patchOperations); TransactionalBatchResponse batchResponse = await batch.ExecuteAsync(); BatchSinglePartitionKeyTests.VerifyBatchProcessed(batchResponse, numberOfOperations: 2); Assert.AreEqual(HttpStatusCode.Created, batchResponse[0].StatusCode); Assert.AreEqual(HttpStatusCode.OK, batchResponse[1].StatusCode); testDoc.Cost = testDoc.Cost + 1; await BatchTestBase.VerifyByReadAsync(BatchTestBase.JsonContainer, testDoc, isStream : false, isSchematized : false, useEpk : false); }
private async Task ValidateItemStream( ItemRequestOptions requestOptions, Action <ResponseMessage> ValidateWrite, Action <ResponseMessage> ValidateRead) { ToDoActivity item = ToDoActivity.CreateRandomToDoActivity(); using (ResponseMessage responseMessage = await this.container.CreateItemStreamAsync( TestCommon.SerializerCore.ToStream(item), new PartitionKey(item.status), requestOptions: requestOptions)) { Assert.AreEqual(HttpStatusCode.Created, responseMessage.StatusCode); ValidateWrite(responseMessage); } using (ResponseMessage responseMessage = await this.container.ReadItemStreamAsync( item.id, new PartitionKey(item.status), requestOptions: requestOptions)) { Assert.AreEqual(HttpStatusCode.OK, responseMessage.StatusCode); ValidateRead(responseMessage); } item.cost = 424242.42; using (ResponseMessage responseMessage = await this.container.UpsertItemStreamAsync( TestCommon.SerializerCore.ToStream(item), new PartitionKey(item.status), requestOptions: requestOptions)) { Assert.AreEqual(HttpStatusCode.OK, responseMessage.StatusCode); ValidateWrite(responseMessage); } item.cost = 9000.42; using (ResponseMessage responseMessage = await this.container.ReplaceItemStreamAsync( TestCommon.SerializerCore.ToStream(item), item.id, new PartitionKey(item.status), requestOptions: requestOptions)) { Assert.AreEqual(HttpStatusCode.OK, responseMessage.StatusCode); ValidateWrite(responseMessage); } item.cost = 1000; List <PatchOperation> patch = new List <PatchOperation>() { PatchOperation.CreateReplaceOperation("/cost", item.cost) }; using (ResponseMessage responseMessage = await this.containerInternal.PatchItemStreamAsync( item.id, new PartitionKey(item.status), patchOperations: patch, requestOptions: requestOptions)) { Assert.AreEqual(HttpStatusCode.OK, responseMessage.StatusCode); ValidateWrite(responseMessage); } using (ResponseMessage responseMessage = await this.container.DeleteItemStreamAsync( item.id, new PartitionKey(item.status), requestOptions: requestOptions)) { Assert.AreEqual(HttpStatusCode.NoContent, responseMessage.StatusCode); this.ValidateItemStreamNoContentResponse(responseMessage); } }
public async Task PointOperationDiagnostic(bool disableDiagnostics) { ItemRequestOptions requestOptions = new ItemRequestOptions(); if (disableDiagnostics) { requestOptions.DiagnosticContextFactory = () => EmptyCosmosDiagnosticsContext.Singleton; } else { // Add 10 seconds to ensure CPU history is recorded await Task.Delay(TimeSpan.FromSeconds(10)); } //Checking point operation diagnostics on typed operations ToDoActivity testItem = ToDoActivity.CreateRandomToDoActivity(); ItemResponse <ToDoActivity> createResponse = await this.Container.CreateItemAsync <ToDoActivity>( item : testItem, requestOptions : requestOptions); CosmosDiagnosticsTests.VerifyPointDiagnostics( createResponse.Diagnostics, disableDiagnostics); ItemResponse <ToDoActivity> readResponse = await this.Container.ReadItemAsync <ToDoActivity>( id : testItem.id, partitionKey : new PartitionKey(testItem.status), requestOptions); CosmosDiagnosticsTests.VerifyPointDiagnostics( readResponse.Diagnostics, disableDiagnostics); testItem.description = "NewDescription"; ItemResponse <ToDoActivity> replaceResponse = await this.Container.ReplaceItemAsync <ToDoActivity>( item : testItem, id : testItem.id, partitionKey : new PartitionKey(testItem.status), requestOptions : requestOptions); Assert.AreEqual(replaceResponse.Resource.description, "NewDescription"); CosmosDiagnosticsTests.VerifyPointDiagnostics( replaceResponse.Diagnostics, disableDiagnostics); testItem.description = "PatchedDescription"; ContainerInternal containerInternal = (ContainerInternal)this.Container; List <PatchOperation> patch = new List <PatchOperation>() { PatchOperation.CreateReplaceOperation("/description", testItem.description) }; ItemResponse <ToDoActivity> patchResponse = await containerInternal.PatchItemAsync <ToDoActivity>( id : testItem.id, partitionKey : new PartitionKey(testItem.status), patchOperations : patch, requestOptions : requestOptions); Assert.AreEqual(patchResponse.Resource.description, "PatchedDescription"); CosmosDiagnosticsTests.VerifyPointDiagnostics( patchResponse.Diagnostics, disableDiagnostics); ItemResponse <ToDoActivity> deleteResponse = await this.Container.DeleteItemAsync <ToDoActivity>( partitionKey : new Cosmos.PartitionKey(testItem.status), id : testItem.id, requestOptions : requestOptions); Assert.IsNotNull(deleteResponse); CosmosDiagnosticsTests.VerifyPointDiagnostics( deleteResponse.Diagnostics, disableDiagnostics); //Checking point operation diagnostics on stream operations ResponseMessage createStreamResponse = await this.Container.CreateItemStreamAsync( partitionKey : new PartitionKey(testItem.status), streamPayload : TestCommon.SerializerCore.ToStream <ToDoActivity>(testItem), requestOptions : requestOptions); CosmosDiagnosticsTests.VerifyPointDiagnostics( createStreamResponse.Diagnostics, disableDiagnostics); ResponseMessage readStreamResponse = await this.Container.ReadItemStreamAsync( id : testItem.id, partitionKey : new PartitionKey(testItem.status), requestOptions : requestOptions); CosmosDiagnosticsTests.VerifyPointDiagnostics( readStreamResponse.Diagnostics, disableDiagnostics); ResponseMessage replaceStreamResponse = await this.Container.ReplaceItemStreamAsync( streamPayload : TestCommon.SerializerCore.ToStream <ToDoActivity>(testItem), id : testItem.id, partitionKey : new PartitionKey(testItem.status), requestOptions : requestOptions); CosmosDiagnosticsTests.VerifyPointDiagnostics( replaceStreamResponse.Diagnostics, disableDiagnostics); ResponseMessage patchStreamResponse = await containerInternal.PatchItemStreamAsync( id : testItem.id, partitionKey : new PartitionKey(testItem.status), patchOperations : patch, requestOptions : requestOptions); CosmosDiagnosticsTests.VerifyPointDiagnostics( patchStreamResponse.Diagnostics, disableDiagnostics); ResponseMessage deleteStreamResponse = await this.Container.DeleteItemStreamAsync( id : testItem.id, partitionKey : new PartitionKey(testItem.status), requestOptions : requestOptions); CosmosDiagnosticsTests.VerifyPointDiagnostics( deleteStreamResponse.Diagnostics, disableDiagnostics); // Ensure diagnostics are set even on failed operations testItem.description = new string('x', Microsoft.Azure.Documents.Constants.MaxResourceSizeInBytes + 1); ResponseMessage createTooBigStreamResponse = await this.Container.CreateItemStreamAsync( partitionKey : new PartitionKey(testItem.status), streamPayload : TestCommon.SerializerCore.ToStream <ToDoActivity>(testItem), requestOptions : requestOptions); Assert.IsFalse(createTooBigStreamResponse.IsSuccessStatusCode); CosmosDiagnosticsTests.VerifyPointDiagnostics( createTooBigStreamResponse.Diagnostics, disableDiagnostics); }
private async Task <TransactionalBatchResponse> RunCrudAsync(bool isStream, bool isSchematized, bool useEpk, Container container) { TransactionalBatchRequestOptions batchOptions = null; if (isSchematized) { await this.CreateSchematizedTestDocsAsync(container); batchOptions = BatchTestBase.GetUpdatedBatchRequestOptions(batchOptions, isSchematized, useEpk, this.PartitionKey1); } else { await this.CreateJsonTestDocsAsync(container); } TestDoc testDocToCreate = BatchTestBase.PopulateTestDoc(this.PartitionKey1); TestDoc testDocToUpsert = BatchTestBase.PopulateTestDoc(this.PartitionKey1); TestDoc anotherTestDocToUpsert = this.GetTestDocCopy(this.TestDocPk1ExistingA); anotherTestDocToUpsert.Cost++; TestDoc testDocToReplace = this.GetTestDocCopy(this.TestDocPk1ExistingB); testDocToReplace.Cost++; TestDoc testDocToPatch = this.GetTestDocCopy(this.TestDocPk1ExistingC); List <PatchOperation> patchOperations = new List <PatchOperation>() { PatchOperation.CreateReplaceOperation("/Cost", testDocToPatch.Cost + 1) }; // We run CRUD operations where all are expected to return HTTP 2xx. TransactionalBatchResponse batchResponse; BatchCore batch; if (!isStream) { batch = (BatchCore) new BatchCore((ContainerInlineCore)container, BatchTestBase.GetPartitionKey(this.PartitionKey1)) .CreateItem(testDocToCreate) .ReadItem(this.TestDocPk1ExistingC.Id) .ReplaceItem(testDocToReplace.Id, testDocToReplace) .UpsertItem(testDocToUpsert) .UpsertItem(anotherTestDocToUpsert) .DeleteItem(this.TestDocPk1ExistingD.Id); batch = (BatchCore)batch.PatchItem(testDocToPatch.Id, patchOperations); } else { batch = (BatchCore) new BatchCore((ContainerInlineCore)container, BatchTestBase.GetPartitionKey(this.PartitionKey1)) .CreateItemStream( BatchTestBase.TestDocToStream(testDocToCreate, isSchematized), BatchTestBase.GetBatchItemRequestOptions(testDocToCreate, isSchematized)) .ReadItem( BatchTestBase.GetId(this.TestDocPk1ExistingC, isSchematized), BatchTestBase.GetBatchItemRequestOptions(this.TestDocPk1ExistingC, isSchematized)) .ReplaceItemStream( BatchTestBase.GetId(testDocToReplace, isSchematized), BatchTestBase.TestDocToStream(testDocToReplace, isSchematized), BatchTestBase.GetBatchItemRequestOptions(testDocToReplace, isSchematized)) .UpsertItemStream( BatchTestBase.TestDocToStream(testDocToUpsert, isSchematized), BatchTestBase.GetBatchItemRequestOptions(testDocToUpsert, isSchematized)) .UpsertItemStream( BatchTestBase.TestDocToStream(anotherTestDocToUpsert, isSchematized), BatchTestBase.GetBatchItemRequestOptions(anotherTestDocToUpsert, isSchematized)) .DeleteItem( BatchTestBase.GetId(this.TestDocPk1ExistingD, isSchematized), BatchTestBase.GetBatchItemRequestOptions(this.TestDocPk1ExistingD, isSchematized)); } batchResponse = await batch.ExecuteAsync(batchOptions); BatchSinglePartitionKeyTests.VerifyBatchProcessed(batchResponse, numberOfOperations: isStream ? 6 :7); Assert.AreEqual(HttpStatusCode.Created, batchResponse[0].StatusCode); Assert.AreEqual(HttpStatusCode.OK, batchResponse[1].StatusCode); Assert.AreEqual(HttpStatusCode.OK, batchResponse[2].StatusCode); Assert.AreEqual(HttpStatusCode.Created, batchResponse[3].StatusCode); Assert.AreEqual(HttpStatusCode.OK, batchResponse[4].StatusCode); Assert.AreEqual(HttpStatusCode.NoContent, batchResponse[5].StatusCode); if (!isStream) { Assert.AreEqual(this.TestDocPk1ExistingC, batchResponse.GetOperationResultAtIndex <TestDoc>(1).Resource); Assert.AreEqual(HttpStatusCode.OK, batchResponse[6].StatusCode); testDocToPatch.Cost = testDocToPatch.Cost + 1; await BatchTestBase.VerifyByReadAsync(container, testDocToPatch, isStream, isSchematized, useEpk); } else { Assert.AreEqual(this.TestDocPk1ExistingC, BatchTestBase.StreamToTestDoc(batchResponse[1].ResourceStream, isSchematized)); } await BatchTestBase.VerifyByReadAsync(container, testDocToCreate, isStream, isSchematized, useEpk); await BatchTestBase.VerifyByReadAsync(container, testDocToReplace, isStream, isSchematized, useEpk); await BatchTestBase.VerifyByReadAsync(container, testDocToUpsert, isStream, isSchematized, useEpk); await BatchTestBase.VerifyByReadAsync(container, anotherTestDocToUpsert, isStream, isSchematized, useEpk); await BatchTestBase.VerifyNotFoundAsync(container, this.TestDocPk1ExistingD, isSchematized, useEpk); return(batchResponse); }