public async Task ItemBulkNoResponseTest()
{
ItemRequestOptions requestOptions = new ItemRequestOptions()
{
EnableContentResponseOnWrite = false
};
CosmosClient bulkClient = TestCommon.CreateCosmosClient((builder) => builder.WithBulkExecution(true));
Container bulkContainer = bulkClient.GetContainer(this.database.Id, this.container.Id);
ContainerInternal bulkContainerInternal = (ContainerInternal)bulkContainer;
string pkId = "TestBulkId";
List <PatchOperation> patch = new List <PatchOperation>()
{
PatchOperation.Remove("/cost")
};
List <Task <ItemResponse <ToDoActivity> > > bulkOperations = new List <Task <ItemResponse <ToDoActivity> > >();
List <ToDoActivity> items = new List <ToDoActivity>();
for (int i = 0; i < 50; i++)
{
ToDoActivity item = ToDoActivity.CreateRandomToDoActivity(pk: pkId);
items.Add(item);
bulkOperations.Add(bulkContainer.CreateItemAsync <ToDoActivity>(item, requestOptions: requestOptions));
}
foreach (Task <ItemResponse <ToDoActivity> > result in bulkOperations)
{
ItemResponse <ToDoActivity> itemResponse = await result;
this.ValidateItemNoContentResponse(itemResponse);
}
PatchItemRequestOptions patchRequestOptions = new PatchItemRequestOptions()
{
EnableContentResponseOnWrite = false
};
foreach (ToDoActivity item in items)
{
bulkOperations.Add(bulkContainerInternal.PatchItemAsync <ToDoActivity>(item.id, new PartitionKey(item.pk), patch, requestOptions: patchRequestOptions));
}
foreach (Task <ItemResponse <ToDoActivity> > result in bulkOperations)
{
ItemResponse <ToDoActivity> itemResponse = await result;
this.ValidateItemNoContentResponse(itemResponse);
}
bulkOperations = new List <Task <ItemResponse <ToDoActivity> > >();
foreach (ToDoActivity item in items)
{
bulkOperations.Add(bulkContainer.ReadItemAsync <ToDoActivity>(item.id, new PartitionKey(item.pk), requestOptions: requestOptions));
}
foreach (Task <ItemResponse <ToDoActivity> > result in bulkOperations)
{
ItemResponse <ToDoActivity> itemResponse = await result;
this.ValidateItemResponse(itemResponse);
}
}
public async Task ClientContentResponseTest()
{
ToDoActivity item = ToDoActivity.CreateRandomToDoActivity();
ItemResponse <ToDoActivity> itemResponse = await this.containerWithFlag.CreateItemAsync(item);
Assert.AreEqual(HttpStatusCode.Created, itemResponse.StatusCode);
Assert.IsNotNull(itemResponse);
Assert.IsNotNull(itemResponse.Resource);
itemResponse = await this.containerWithFlag.ReadItemAsync <ToDoActivity>(item.id, new PartitionKey(item.pk));
Assert.AreEqual(HttpStatusCode.OK, itemResponse.StatusCode);
item.cost = 424242.42;
itemResponse = await this.containerWithFlag.UpsertItemAsync <ToDoActivity>(item);
Assert.AreEqual(HttpStatusCode.OK, itemResponse.StatusCode);
Assert.IsNotNull(itemResponse.Resource);
item.cost = 9000.42;
itemResponse = await this.containerWithFlag.ReplaceItemAsync <ToDoActivity>(
item,
item.id,
new PartitionKey(item.pk));
Assert.AreEqual(HttpStatusCode.OK, itemResponse.StatusCode);
Assert.IsNotNull(itemResponse.Resource);
ContainerInternal containerInternal = (ContainerInternal)this.containerWithFlag;
item.cost = 1000;
List <PatchOperation> patch = new List <PatchOperation>()
{
PatchOperation.Replace("/cost", item.cost)
};
itemResponse = await containerInternal.PatchItemAsync <ToDoActivity>(
item.id,
new PartitionKey(item.pk),
patchOperations : patch);
Assert.AreEqual(HttpStatusCode.OK, itemResponse.StatusCode);
Assert.IsNotNull(itemResponse.Resource);
ItemResponse <ToDoActivity> itemResponseWithoutFlag = await this.containerWithoutFlag.CreateItemAsync(item);
Assert.AreEqual(HttpStatusCode.Created, itemResponseWithoutFlag.StatusCode);
Assert.IsNotNull(itemResponseWithoutFlag);
Assert.IsNull(itemResponseWithoutFlag.Resource);
}
private static Task <ItemResponse <ToDoActivity> > ExecutePatchAsync(ContainerInternal container, ToDoActivity item, List <PatchOperation> patch)
{
return(container.PatchItemAsync <ToDoActivity>(item.id, new PartitionKey(item.pk), patch));
}
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.Replace("/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 static Task <ItemResponse <MyDocument> > ExecutePatchAsync(ContainerInternal container, MyDocument item, List <PatchOperation> patch)
{
return(container.PatchItemAsync <MyDocument>(item.id, new PartitionKey(item.Status), patch));
}