public async Task PointSuccessOperationsTest(ConnectionMode mode)
{
Container container = await this.GetContainer(mode);
// Create an item
ToDoActivity testItem = ToDoActivity.CreateRandomToDoActivity("MyTestPkValue");
ItemResponse <ToDoActivity> createResponse = await container.CreateItemAsync <ToDoActivity>(testItem);
ToDoActivity testItemCreated = createResponse.Resource;
// Read an Item
await container.ReadItemAsync <ToDoActivity>(testItem.id, new Cosmos.PartitionKey(testItem.id));
// Upsert an Item
await container.UpsertItemAsync <ToDoActivity>(testItem);
// Replace an Item
await container.ReplaceItemAsync <ToDoActivity>(testItemCreated, testItemCreated.id.ToString());
// Patch an Item
List <PatchOperation> patch = new List <PatchOperation>()
{
PatchOperation.Add("/new", "patched")
};
await((ContainerInternal)container).PatchItemAsync <ToDoActivity>(
testItem.id,
new Cosmos.PartitionKey(testItem.id),
patch);
// Delete an Item
await container.DeleteItemAsync <ToDoActivity>(testItem.id, new Cosmos.PartitionKey(testItem.id));
await this.WaitAndAssert(12);
}
public async Task ClientWithAllowUpgradeConsistencyToLocalQuorumTestAsync(bool isLocalQuorumConsistency)
{
Container container = await this.CreateContainer(isLocalQuorumConsistency);
ToDoActivity testItem = ToDoActivity.CreateRandomToDoActivity();
ItemResponse <ToDoActivity> createResponse = await container.CreateItemAsync <ToDoActivity>(item : testItem);
Assert.AreEqual(HttpStatusCode.Created, createResponse.StatusCode);
ItemRequestOptions requestOptions = new();
requestOptions.ConsistencyLevel = Cosmos.ConsistencyLevel.Strong;
if (isLocalQuorumConsistency)
{
ItemResponse <ToDoActivity> readResponse = await container.ReadItemAsync <ToDoActivity>(testItem.id, new Cosmos.PartitionKey(testItem.pk), requestOptions);
Assert.AreEqual(HttpStatusCode.OK, readResponse.StatusCode);
}
else
{
try
{
await container.ReadItemAsync <ToDoActivity>(testItem.id, new Cosmos.PartitionKey(testItem.pk), requestOptions);
}
catch (Exception ex)
{
Assert.ReferenceEquals(new ArgumentException(), ex);
Assert.AreEqual("ConsistencyLevel Strong specified in the request is invalid when service is configured with consistency level Eventual. Ensure the request consistency level is not stronger than the service consistency level.", ex.Message);
}
}
}
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 SingleOperationMultipleTimesTest(ConnectionMode mode)
{
Container container = await this.CreateClientAndContainer(mode);
// Create an item
ToDoActivity testItem = ToDoActivity.CreateRandomToDoActivity();
await container.CreateItemAsync <ToDoActivity>(testItem, requestOptions : new ItemRequestOptions());
for (int count = 0; count < 50; count++)
{
// Read an Item
await container.ReadItemAsync <ToDoActivity>(testItem.id, new Cosmos.PartitionKey(testItem.id));
}
IDictionary <string, long> expectedRecordCountInOperation = new Dictionary <string, long>
{
{ Documents.OperationType.Read.ToString(), 50 },
{ Documents.OperationType.Create.ToString(), 1 }
};
await this.WaitAndAssert(
expectedOperationCount : 4,// 2 (read, requetLatency + requestCharge) + 2 (create, requestLatency + requestCharge)
expectedOperationRecordCountMap : expectedRecordCountInOperation);
}
public async Task BulkOperationDiagnostic()
{
string pkValue = "DiagnosticBulkTestPk";
CosmosClient bulkClient = TestCommon.CreateCosmosClient(builder => builder.WithBulkExecution(true));
Container bulkContainer = bulkClient.GetContainer(this.database.Id, this.Container.Id);
List <Task <ItemResponse <ToDoActivity> > > createItemsTasks = new List <Task <ItemResponse <ToDoActivity> > >();
for (int i = 0; i < 100; i++)
{
ToDoActivity item = ToDoActivity.CreateRandomToDoActivity(pk: pkValue);
createItemsTasks.Add(bulkContainer.CreateItemAsync <ToDoActivity>(item, new PartitionKey(item.status)));
}
await Task.WhenAll(createItemsTasks);
foreach (Task <ItemResponse <ToDoActivity> > createTask in createItemsTasks)
{
ItemResponse <ToDoActivity> itemResponse = await createTask;
Assert.IsNotNull(itemResponse);
CosmosDiagnosticsTests.VerifyPointDiagnostics(
diagnostics: itemResponse.Diagnostics,
disableDiagnostics: false);
}
}
internal static async Task CreateItemInNonPartitionedContainer(
ContainerCore container,
string itemId)
{
(string endpoint, string authKey)accountInfo = TestCommon.GetAccountInfo();
//Creating non partition Container item.
HttpClient client = new System.Net.Http.HttpClient();
Uri baseUri = new Uri(accountInfo.endpoint);
string dateTimeUtc = NonPartitionedContainerHelper.GetUtcDateTime();
string verb = "POST";
string resourceType = "docs";
string resourceLink = string.Format("dbs/{0}/colls/{1}/docs", container.Database.Id, container.Id);
string authHeader = NonPartitionedContainerHelper.GenerateMasterKeyAuthorizationSignature(
verb, container.LinkUri.OriginalString,
resourceType,
accountInfo.authKey,
"master",
"1.0",
dateTimeUtc);
client.DefaultRequestHeaders.Add("x-ms-date", dateTimeUtc);
client.DefaultRequestHeaders.Add("x-ms-version", NonPartitionedContainerHelper.PreNonPartitionedMigrationApiVersion);
client.DefaultRequestHeaders.Add("authorization", authHeader);
string itemDefinition = JsonConvert.SerializeObject(ToDoActivity.CreateRandomToDoActivity(id: itemId));
{
StringContent itemContent = new StringContent(itemDefinition);
Uri requestUri = new Uri(baseUri, resourceLink);
HttpResponseMessage response = await client.PostAsync(requestUri.ToString(), itemContent);
Assert.AreEqual(HttpStatusCode.Created, response.StatusCode, response.ToString());
}
}
public async Task NoContentResponseBulkTest()
{
CosmosClientBuilder cosmosClientBuilder = TestCommon.GetDefaultConfiguration();
cosmosClientBuilder = cosmosClientBuilder.WithBulkExecution(true).WithContentResponseOnWrite(false);
CosmosClient bulkClient = cosmosClientBuilder.Build();
Container bulkContainer = bulkClient.GetContainer(this.databaseWithoutFlag.Id, this.containerWithoutFlag.Id);
string pkId = "TestBulkId";
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));
}
foreach (Task <ItemResponse <ToDoActivity> > result in bulkOperations)
{
ItemResponse <ToDoActivity> itemResponse = await result;
Assert.AreEqual(itemResponse.StatusCode, HttpStatusCode.Created);
Assert.IsNull(itemResponse.Resource);
}
}
public async Task VerifyKnownHeaders()
{
HeaderValidationHandler headerValidationHandler = new HeaderValidationHandler();
using CosmosClient client = TestCommon.CreateCosmosClient(x => x.AddCustomHandlers(headerValidationHandler));
Database database = null;
try
{
database = await client.CreateDatabaseAsync(nameof(VerifyKnownHeaders) + Guid.NewGuid().ToString());
Container container = await database.CreateContainerAsync(
Guid.NewGuid().ToString(),
"/pk");
ToDoActivity toDoActivity = ToDoActivity.CreateRandomToDoActivity();
await container.CreateItemAsync(toDoActivity, new PartitionKey(toDoActivity.pk));
await container.ReadItemAsync <ToDoActivity>(toDoActivity.id, new PartitionKey(toDoActivity.pk));
await container.UpsertItemAsync <ToDoActivity>(toDoActivity, new PartitionKey(toDoActivity.pk));
toDoActivity.cost = 8923498;
await container.ReplaceItemAsync <ToDoActivity>(toDoActivity, toDoActivity.id, new PartitionKey(toDoActivity.pk));
await container.DeleteItemAsync <ToDoActivity>(toDoActivity.id, new PartitionKey(toDoActivity.pk));
}
finally
{
if (database != null)
{
await database.DeleteStreamAsync();
}
}
}
private async Task CheckForTracesAsync <ExceptionType>(
Container container,
bool isClientDisposed) where ExceptionType : Exception
{
ToDoActivity toDoActivity = ToDoActivity.CreateRandomToDoActivity();
try
{
await container.CreateItemAsync <ToDoActivity>(
toDoActivity,
new Cosmos.PartitionKey(toDoActivity.pk));
Assert.Fail("Should have thrown");
}
catch (ExceptionType e)
{
if (isClientDisposed)
{
Assert.IsTrue(e.Message.Contains("Cannot access a disposed 'CosmosClient'. Follow best practices and use the CosmosClient as a singleton."));
}
else
{
Assert.IsTrue(e.Message.Contains("The CosmosClient is still active and NOT disposed of. CosmosClient Endpoint:"));
}
Assert.IsFalse(e.Message.Contains("CosmosDiagnostics"));
Assert.IsTrue(e.ToString().Contains("Client Configuration"));
}
}
public async Task QueryMultiPageSinglePartitionOperationTest(ConnectionMode mode)
{
Environment.SetEnvironmentVariable(ClientTelemetryOptions.EnvPropsClientTelemetrySchedulingInSeconds, "20");
Container container = await this.CreateClientAndContainer(mode : mode);
ItemRequestOptions requestOptions = new ItemRequestOptions()
{
ConsistencyLevel = Microsoft.Azure.Cosmos.ConsistencyLevel.ConsistentPrefix
};
ToDoActivity testItem1 = ToDoActivity.CreateRandomToDoActivity("MyTestPkValue1", "MyTestItemId1");
ItemResponse <ToDoActivity> createResponse1 = await container.CreateItemAsync <ToDoActivity>(
item : testItem1,
requestOptions : requestOptions);
ToDoActivity testItem2 = ToDoActivity.CreateRandomToDoActivity("MyTestPkValue2", "MyTestItemId2");
ItemResponse <ToDoActivity> createResponse2 = await container.CreateItemAsync <ToDoActivity>(
item : testItem2,
requestOptions : requestOptions);
if (createResponse1.StatusCode == HttpStatusCode.Created &&
createResponse2.StatusCode == HttpStatusCode.Created)
{
string sqlQueryText = "SELECT * FROM c";
List <object> families = new List <object>();
QueryDefinition queryDefinition = new QueryDefinition(sqlQueryText);
using (FeedIterator <object> queryResultSetIterator = container.GetItemQueryIterator <object>(
queryDefinition: queryDefinition,
requestOptions: new QueryRequestOptions()
{
ConsistencyLevel = Microsoft.Azure.Cosmos.ConsistencyLevel.ConsistentPrefix,
MaxItemCount = 1
}))
{
while (queryResultSetIterator.HasMoreResults)
{
FeedResponse <object> currentResultSet = await queryResultSetIterator.ReadNextAsync();
foreach (object family in currentResultSet)
{
families.Add(family);
}
}
}
Assert.AreEqual(2, families.Count);
}
IDictionary <string, long> expectedRecordCountInOperation = new Dictionary <string, long>
{
{ Documents.OperationType.Query.ToString(), 3 },
{ Documents.OperationType.Create.ToString(), 2 }
};
await this.WaitAndAssert(
expectedOperationCount : 4,
expectedOperationRecordCountMap : expectedRecordCountInOperation,
expectedConsistencyLevel : Microsoft.Azure.Cosmos.ConsistencyLevel.ConsistentPrefix);
}
public async Task TestInitialize()
{
CosmosClientOptions cosmosClientOptions = new CosmosClientOptions()
{
ConnectionMode = ConnectionMode.Gateway,
ConnectionProtocol = Documents.Client.Protocol.Https,
ConsistencyLevel = Cosmos.ConsistencyLevel.Session,
HttpClientFactory = () => new HttpClient(new HttpHandlerMetaDataValidator()),
};
this.cosmosClient = TestCommon.CreateCosmosClient(cosmosClientOptions);
this.database = await this.cosmosClient.CreateDatabaseAsync(
id : Guid.NewGuid().ToString());
ContainerResponse response = await this.database.CreateContainerAsync(
new ContainerProperties(id : Guid.NewGuid().ToString(), partitionKeyPath : PartitionKey),
throughput : 20000,
cancellationToken : default);
Assert.IsNotNull(response);
Assert.IsNotNull(response.Container);
Assert.IsNotNull(response.Resource);
this.Container = (ContainerInlineCore)response;
// Create items with different
for (int i = 0; i < 500; i++)
{
ToDoActivity item = ToDoActivity.CreateRandomToDoActivity();
item.pk = "Status" + i.ToString();
item.id = i.ToString();
ItemResponse <ToDoActivity> itemResponse = await this.Container.CreateItemAsync(item);
Assert.AreEqual(HttpStatusCode.Created, itemResponse.StatusCode);
}
}
[Ignore] // turn this back on when we have tracing diagnostics.
public async Task ChangeFeedDiagnostics(bool disableDiagnostics)
{
string pkValue = "ChangeFeedDiagnostics";
CosmosClient client = TestCommon.CreateCosmosClient();
Container container = client.GetContainer(this.database.Id, this.Container.Id);
List <Task <ItemResponse <ToDoActivity> > > createItemsTasks = new List <Task <ItemResponse <ToDoActivity> > >();
for (int i = 0; i < 100; i++)
{
ToDoActivity item = ToDoActivity.CreateRandomToDoActivity(pk: pkValue);
createItemsTasks.Add(container.CreateItemAsync <ToDoActivity>(item, new PartitionKey(item.status)));
}
await Task.WhenAll(createItemsTasks);
ChangeFeedRequestOptions requestOptions = disableDiagnostics ? ChangeFeedRequestOptionDisableDiagnostic : null;
FeedIterator changeFeedIterator = ((ContainerCore)(container as ContainerInlineCore)).GetChangeFeedStreamIterator(
ChangeFeedStartFrom.Beginning(),
changeFeedRequestOptions: requestOptions);
while (changeFeedIterator.HasMoreResults)
{
using (ResponseMessage response = await changeFeedIterator.ReadNextAsync())
{
CosmosDiagnosticsTests.VerifyChangeFeedDiagnostics(
diagnostics: response.Diagnostics,
disableDiagnostics: disableDiagnostics);
}
}
}
public static async Task <IList <ToDoActivity> > CreateRandomItems(Container container, int pkCount, int perPKItemCount = 1, bool randomPartitionKey = true)
{
Assert.IsFalse(!randomPartitionKey && pkCount > 1);
List <ToDoActivity> createdList = new List <ToDoActivity>();
for (int i = 0; i < pkCount; i++)
{
string pk = "TBD";
if (randomPartitionKey)
{
pk += Guid.NewGuid().ToString();
}
for (int j = 0; j < perPKItemCount; j++)
{
ToDoActivity temp = ToDoActivity.CreateRandomToDoActivity(pk);
createdList.Add(temp);
await container.CreateItemAsync <ToDoActivity>(item : temp);
}
}
return(createdList);
}
public async Task BatchOperationDiagnostic(bool disableDiagnostics)
{
string pkValue = "DiagnosticTestPk";
TransactionalBatch batch = this.Container.CreateTransactionalBatch(new PartitionKey(pkValue));
BatchCore batchCore = (BatchCore)batch;
List <PatchOperation> patch = new List <PatchOperation>()
{
PatchOperation.Remove("/cost")
};
List <ToDoActivity> createItems = new List <ToDoActivity>();
for (int i = 0; i < 50; i++)
{
ToDoActivity item = ToDoActivity.CreateRandomToDoActivity(pk: pkValue);
createItems.Add(item);
batch.CreateItem <ToDoActivity>(item);
}
for (int i = 0; i < 20; i++)
{
batch.ReadItem(createItems[i].id);
batchCore.PatchItem(createItems[i].id, patch);
}
TransactionalBatchRequestOptions requestOptions = disableDiagnostics ? RequestOptionDisableDiagnostic : null;
TransactionalBatchResponse response = await batch.ExecuteAsync(requestOptions);
Assert.IsNotNull(response);
CosmosDiagnosticsTests.VerifyPointDiagnostics(
diagnostics: response.Diagnostics,
disableDiagnostics: disableDiagnostics);
}
public async Task GatewayRetryRequestStatsTest(string uriToThrow, string traceToFind, bool useGateway, int expectedHttpCalls)
{
ToDoActivity item = ToDoActivity.CreateRandomToDoActivity();
ItemResponse <ToDoActivity> createResponse = await this.Container.CreateItemAsync(item);
HttpClient httpClient = new HttpClient(new TimeOutHttpClientHandler(maxRetries: 3, uriToThrow: uriToThrow))
{
Timeout = TimeSpan.FromSeconds(1)
};
CosmosClientOptions options = new CosmosClientOptions
{
ConnectionMode = useGateway ? ConnectionMode.Gateway : ConnectionMode.Direct,
HttpClientFactory = () => httpClient
};
using (CosmosClient cosmosClient = TestCommon.CreateCosmosClient(options))
{
Container container = cosmosClient.GetContainer(this.Database.Id, this.Container.Id);
ItemResponse <ToDoActivity> response = await container.ReadItemAsync <ToDoActivity>(item.id, new PartitionKey(item.pk));
ClientSideRequestStatisticsTraceDatum datum = this.GetClientSideRequestStatsFromTrace(((CosmosTraceDiagnostics)response.Diagnostics).Value, traceToFind);
Assert.IsNotNull(datum.HttpResponseStatisticsList);
Assert.AreEqual(datum.HttpResponseStatisticsList.Count, expectedHttpCalls);
Assert.IsTrue(datum.HttpResponseStatisticsList[0].Exception is OperationCanceledException);
Assert.IsTrue(datum.HttpResponseStatisticsList[1].Exception is OperationCanceledException);
Assert.IsNull(datum.HttpResponseStatisticsList[2].Exception);
Assert.IsNotNull(datum.HttpResponseStatisticsList[2].HttpResponseMessage);
}
}
public async Task QueryOperationTest(ConnectionMode mode)
{
Container container = await this.GetContainer(mode);
ToDoActivity testItem = ToDoActivity.CreateRandomToDoActivity("MyTestPkValue", "MyTestItemId");
ItemResponse <ToDoActivity> createResponse = await container.CreateItemAsync <ToDoActivity>(testItem);
if (createResponse.StatusCode == HttpStatusCode.Created)
{
string sqlQueryText = "SELECT * FROM c";
QueryDefinition queryDefinition = new QueryDefinition(sqlQueryText);
FeedIterator <object> queryResultSetIterator = container.GetItemQueryIterator <object>(queryDefinition);
List <object> families = new List <object>();
while (queryResultSetIterator.HasMoreResults)
{
FeedResponse <object> currentResultSet = await queryResultSetIterator.ReadNextAsync();
foreach (object family in currentResultSet)
{
families.Add(family);
}
}
}
await this.WaitAndAssert(4);
}
public async Task TestInitialize()
{
this.cosmosClient = TestCommon.CreateCosmosClient(useGateway: false);
this.database = await this.cosmosClient.CreateDatabaseAsync(
id : "ClientCreateAndInitializeDatabase");
ContainerResponse response = await this.database.CreateContainerAsync(
new ContainerProperties(id : "ClientCreateAndInitializeContainer", partitionKeyPath : PartitionKey),
throughput : 20000,
cancellationToken : this.cancellationToken);
Assert.IsNotNull(response);
Assert.IsNotNull(response.Container);
Assert.IsNotNull(response.Resource);
this.Container = (ContainerInlineCore)response;
// Create items with different
for (int i = 0; i < 500; i++)
{
ToDoActivity item = ToDoActivity.CreateRandomToDoActivity();
item.pk = "Status" + i.ToString();
item.id = i.ToString();
ItemResponse <ToDoActivity> itemResponse = await this.Container.CreateItemAsync(item);
Assert.AreEqual(HttpStatusCode.Created, itemResponse.StatusCode);
}
}
public async Task TestInitialize()
{
await base.TestInit();
string PartitionKey = "/pk";
this.containerSettings = new ContainerProperties(id: Guid.NewGuid().ToString(), partitionKeyPath: PartitionKey);
ContainerResponse response = await this.database.CreateContainerAsync(
this.containerSettings,
throughput : 20000,
cancellationToken : this.cancellationToken);
Assert.IsNotNull(response);
Assert.IsNotNull(response.Container);
Assert.IsNotNull(response.Resource);
this.Container = response;
// Create items with different pk values
for (int i = 0; i < 500; i++)
{
ToDoActivity item = ToDoActivity.CreateRandomToDoActivity();
item.pk = "pk" + i.ToString();
item.id = i.ToString();
ItemResponse <ToDoActivity> itemResponse = await this.Container.CreateItemAsync(item);
Assert.AreEqual(HttpStatusCode.Created, itemResponse.StatusCode);
}
}
public async Task NoContentResponseTransactionBatchOverrideTest()
{
string pkId = "TestBatchId";
TransactionalBatch batch = this.containerWithFlag.CreateTransactionalBatch(new PartitionKey(pkId));
TransactionalBatchItemRequestOptions requestOptions = new TransactionalBatchItemRequestOptions()
{
EnableContentResponseOnWrite = false
};
int noResponseItemCount = 100;
for (int i = 0; i < noResponseItemCount; i++)
{
ToDoActivity item = ToDoActivity.CreateRandomToDoActivity(pk: pkId);
batch.CreateItem <ToDoActivity>(item, requestOptions: requestOptions);
}
TransactionalBatchResponse response = await batch.ExecuteAsync();
Assert.AreEqual(response.Count, 100);
foreach (TransactionalBatchOperationResult itemResponse in response)
{
Assert.IsTrue(itemResponse.StatusCode == HttpStatusCode.Created);
Assert.IsNull(itemResponse.ResourceStream);
}
}
#pragma warning restore IDE1006 // Naming Styles
public static NestedToDoActivity CreateRandomNestedToDoActivity(string pk, string id)
{
return(new NestedToDoActivity()
{
id = id,
NestedObject = ToDoActivity.CreateRandomToDoActivity(pk: pk)
});
}
public async Task NoSessionTokenCaptureForThrottledUpsertRequestsTest()
{
ToDoActivity testItem = ToDoActivity.CreateRandomToDoActivity();
ResetSessionToken(this.Container);
Assert.IsNull(await GetLSNFromSessionContainer(
this.Container, this.containerSettings, new PartitionKey(testItem.pk)));
ItemResponse <ToDoActivity> response = await this.Container.CreateItemAsync <ToDoActivity>(item : testItem);
Assert.IsNotNull(response);
Assert.IsNotNull(response.Resource);
Assert.IsNotNull(response.Diagnostics);
string sessionTokenHeaderValue = response.Headers[HttpConstants.HttpHeaders.SessionToken];
Assert.IsNotNull(sessionTokenHeaderValue);
long?lsnAfterCreate = await GetLSNFromSessionContainer(
this.Container, this.containerSettings, new PartitionKey(testItem.pk));
Assert.IsNotNull(lsnAfterCreate);
ResetSessionToken(this.Container);
Assert.IsNull(await GetLSNFromSessionContainer(
this.Container, this.containerSettings, new PartitionKey(testItem.pk)));
Container throttledContainer = TransportClientHelper.GetContainerWithIntercepter(
this.database.Id,
this.Container.Id,
(uri, resourceOperation, documentServiceRequest) => { },
useGatewayMode: false,
(uri, resourceOperation, documentServiceRequest) =>
{
StoreResponse throttledResponse = TransportClientHelper.ReturnThrottledStoreResponseOnItemOperation(
uri, resourceOperation, documentServiceRequest, Guid.NewGuid(), string.Empty);
throttledResponse.Headers.Add(HttpConstants.HttpHeaders.SessionToken, sessionTokenHeaderValue);
return(throttledResponse);
},
this.cosmosClient.DocumentClient.sessionContainer);
try
{
//Updated the taskNum field
testItem.taskNum = 9001;
response = await throttledContainer.UpsertItemAsync(testItem, partitionKey : new Cosmos.PartitionKey(testItem.pk));
}
catch (CosmosException cosmosException)
{
Assert.AreEqual(HttpStatusCode.TooManyRequests, cosmosException.StatusCode);
}
long?lsnAfterThrottledRequest = await GetLSNFromSessionContainer(
this.Container, this.containerSettings, new PartitionKey(testItem.pk));
Assert.IsNull(lsnAfterThrottledRequest);
}
public async Task PointOperationDiagnostic()
{
//Checking point operation diagnostics on typed operations
ToDoActivity testItem = ToDoActivity.CreateRandomToDoActivity();
ItemResponse <ToDoActivity> createResponse = await this.Container.CreateItemAsync <ToDoActivity>(item : testItem);
CosmosDiagnosticsTests.VerifyPointDiagnostics(createResponse.Diagnostics);
ItemResponse <ToDoActivity> readResponse = await this.Container.ReadItemAsync <ToDoActivity>(id : testItem.id, partitionKey : new PartitionKey(testItem.status));
Assert.IsNotNull(readResponse.Diagnostics);
testItem.description = "NewDescription";
ItemResponse <ToDoActivity> replaceResponse = await this.Container.ReplaceItemAsync <ToDoActivity>(item : testItem, id : testItem.id, partitionKey : new PartitionKey(testItem.status));
Assert.AreEqual(replaceResponse.Resource.description, "NewDescription");
CosmosDiagnosticsTests.VerifyPointDiagnostics(replaceResponse.Diagnostics);
ItemResponse <ToDoActivity> deleteResponse = await this.Container.DeleteItemAsync <ToDoActivity>(partitionKey : new Cosmos.PartitionKey(testItem.status), id : testItem.id);
Assert.IsNotNull(deleteResponse);
CosmosDiagnosticsTests.VerifyPointDiagnostics(deleteResponse.Diagnostics);
//Checking point operation diagnostics on stream operations
ResponseMessage createStreamResponse = await this.Container.CreateItemStreamAsync(
partitionKey : new PartitionKey(testItem.status),
streamPayload : TestCommon.SerializerCore.ToStream <ToDoActivity>(testItem));
CosmosDiagnosticsTests.VerifyPointDiagnostics(createStreamResponse.Diagnostics);
ResponseMessage readStreamResponse = await this.Container.ReadItemStreamAsync(
id : testItem.id,
partitionKey : new PartitionKey(testItem.status));
CosmosDiagnosticsTests.VerifyPointDiagnostics(readStreamResponse.Diagnostics);
ResponseMessage replaceStreamResponse = await this.Container.ReplaceItemStreamAsync(
streamPayload : TestCommon.SerializerCore.ToStream <ToDoActivity>(testItem),
id : testItem.id,
partitionKey : new PartitionKey(testItem.status));
CosmosDiagnosticsTests.VerifyPointDiagnostics(replaceStreamResponse.Diagnostics);
ResponseMessage deleteStreamResponse = await this.Container.DeleteItemStreamAsync(
id : testItem.id,
partitionKey : new PartitionKey(testItem.status));
CosmosDiagnosticsTests.VerifyPointDiagnostics(deleteStreamResponse.Diagnostics);
// 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));
Assert.IsFalse(createTooBigStreamResponse.IsSuccessStatusCode);
CosmosDiagnosticsTests.VerifyPointDiagnostics(createTooBigStreamResponse.Diagnostics);
}
public async Task AadMockTest()
{
string databaseId = Guid.NewGuid().ToString();
string containerId = Guid.NewGuid().ToString();
using (CosmosClient cosmosClient = TestCommon.CreateCosmosClient())
{
Database database = await cosmosClient.CreateDatabaseAsync(databaseId);
Container container = await database.CreateContainerAsync(
containerId,
"/id");
}
(string endpoint, string authKey) = TestCommon.GetAccountInfo();
LocalEmulatorTokenCredential simpleEmulatorTokenCredential = new LocalEmulatorTokenCredential(authKey);
CosmosClientOptions clientOptions = new CosmosClientOptions()
{
ConnectionMode = ConnectionMode.Gateway,
ConnectionProtocol = Protocol.Https
};
using CosmosClient aadClient = new CosmosClient(
endpoint,
simpleEmulatorTokenCredential,
clientOptions);
TokenCredentialCache tokenCredentialCache = ((AuthorizationTokenProviderTokenCredential)aadClient.AuthorizationTokenProvider).tokenCredentialCache;
// The refresh interval changes slightly based on how fast machine calculate the interval based on the expire time.
Assert.IsTrue(15 <= tokenCredentialCache.BackgroundTokenCredentialRefreshInterval.Value.TotalMinutes, "Default background refresh should be 25% of the token life which is defaulted to 1hr");
Assert.IsTrue(tokenCredentialCache.BackgroundTokenCredentialRefreshInterval.Value.TotalMinutes > 14.7, "Default background refresh should be 25% of the token life which is defaulted to 1hr");
Database aadDatabase = await aadClient.GetDatabase(databaseId).ReadAsync();
Container aadContainer = await aadDatabase.GetContainer(containerId).ReadContainerAsync();
ToDoActivity toDoActivity = ToDoActivity.CreateRandomToDoActivity();
ItemResponse <ToDoActivity> itemResponse = await aadContainer.CreateItemAsync(
toDoActivity,
new PartitionKey(toDoActivity.id));
toDoActivity.cost = 42.42;
await aadContainer.ReplaceItemAsync(
toDoActivity,
toDoActivity.id,
new PartitionKey(toDoActivity.id));
await aadContainer.ReadItemAsync <ToDoActivity>(
toDoActivity.id,
new PartitionKey(toDoActivity.id));
await aadContainer.UpsertItemAsync(toDoActivity);
await aadContainer.DeleteItemAsync <ToDoActivity>(
toDoActivity.id,
new PartitionKey(toDoActivity.id));
}
public async Task PointOperationSummaryTest()
{
ToDoActivity testItem = ToDoActivity.CreateRandomToDoActivity();
ItemResponse <ToDoActivity> response = await this.Container.CreateItemAsync(testItem, new Cosmos.PartitionKey(testItem.pk));
Assert.IsNotNull(response.Diagnostics);
ITrace trace = ((CosmosTraceDiagnostics)response.Diagnostics).Value;
SummaryDiagnostics summaryDiagnostics = new SummaryDiagnostics(trace);
Assert.AreEqual(summaryDiagnostics.DirectRequestsSummary.Value[(201, 0)], 1);
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);
}
using (ResponseMessage responseMessage = await this.container.DeleteItemStreamAsync(
item.id,
new PartitionKey(item.status),
requestOptions: requestOptions))
{
Assert.AreEqual(HttpStatusCode.NoContent, responseMessage.StatusCode);
this.ValidateItemStreamNoContentResponse(responseMessage);
}
}
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 ItemBatchNoResponseTest()
{
TransactionalBatchItemRequestOptions requestOptions = new TransactionalBatchItemRequestOptions()
{
EnableContentResponseOnWrite = false
};
string pkId = "TestBatchId";
TransactionalBatch batch = this.container.CreateTransactionalBatch(new PartitionKey(pkId));
int noResponseItemCount = 100;
for (int i = 0; i < noResponseItemCount; i++)
{
ToDoActivity item = ToDoActivity.CreateRandomToDoActivity(pk: pkId);
batch.CreateItem <ToDoActivity>(item, requestOptions: requestOptions);
}
TransactionalBatchResponse response = await batch.ExecuteAsync();
Assert.AreEqual(100, response.Count);
this.ValidateResponse(response, noResponseItemCount);
pkId = "TestBatchId2";
batch = this.container.CreateTransactionalBatch(new PartitionKey(pkId));
noResponseItemCount = 0;
for (int i = 0; i < 10; i++)
{
ToDoActivity item = ToDoActivity.CreateRandomToDoActivity(pk: pkId);
batch.CreateItem <ToDoActivity>(item, requestOptions: requestOptions);
noResponseItemCount++;
ToDoActivity item2 = ToDoActivity.CreateRandomToDoActivity(pk: pkId);
item2.id = item.id;
batch.ReplaceItem <ToDoActivity>(item2.id, item2, requestOptions);
noResponseItemCount++;
}
int withBodyCount = 0;
for (int i = 0; i < 5; i++)
{
ToDoActivity item = ToDoActivity.CreateRandomToDoActivity(pk: pkId);
batch.CreateItem <ToDoActivity>(item);
withBodyCount++;
batch.ReadItem(item.id);
withBodyCount++;
}
response = await batch.ExecuteAsync();
Assert.AreEqual(noResponseItemCount + withBodyCount, response.Count);
this.ValidateResponse(response, noResponseItemCount);
}
public async Task GatewayRequestStatsTest()
{
ToDoActivity item = ToDoActivity.CreateRandomToDoActivity();
ItemResponse <ToDoActivity> response = await this.Container.CreateItemAsync(item);
ClientSideRequestStatisticsTraceDatum datum = this.GetClientSideRequestStatsFromTrace(((CosmosTraceDiagnostics)response.Diagnostics).Value, "Transport");
Assert.IsNotNull(datum.HttpResponseStatisticsList);
Assert.AreEqual(datum.HttpResponseStatisticsList.Count, 1);
Assert.IsNotNull(datum.HttpResponseStatisticsList[0].HttpResponseMessage);
Assert.AreEqual(datum.RequestEndTimeUtc, datum.HttpResponseStatisticsList[0].RequestEndTime);
}
public async Task ReadManyTestWithIncorrectIntendedContainerRid()
{
for (int i = 0; i < 2; i++)
{
await this.Container.CreateItemAsync <ToDoActivity>(ToDoActivity.CreateRandomToDoActivity("pk", i.ToString()));
}
List <(string, PartitionKey)> itemList = new List <(string, PartitionKey)>();
for (int i = 0; i < 2; i++)
{
itemList.Add((i.ToString(), new PartitionKey("pk")));
}
// pass incorrect Rid.
ReadManyRequestOptions readManyRequestOptions = new ReadManyRequestOptions
{
AddRequestHeaders = (headers) =>
{
headers[Documents.HttpConstants.HttpHeaders.IsClientEncrypted] = bool.TrueString;
headers[Documents.WFConstants.BackendHeaders.IntendedCollectionRid] = "iCoRrecTrID=";
}
};
FeedResponse <ToDoActivity> feedResponse;
try
{
feedResponse = await this.Container.ReadManyItemsAsync <ToDoActivity>(itemList, readManyRequestOptions);
Assert.Fail("ReadManyItemsAsync execution should have failed. ");
}
catch (CosmosException ex)
{
if (ex.StatusCode != HttpStatusCode.BadRequest || ex.SubStatusCode != 1024)
{
Assert.Fail("ReadManyItemsAsync execution should have failed with the StatusCode: BadRequest and SubStatusCode: 1024. ");
}
}
using (ResponseMessage responseMessage = await this.Container.ReadManyItemsStreamAsync(itemList, readManyRequestOptions))
{
if (responseMessage.StatusCode != HttpStatusCode.BadRequest ||
!string.Equals(responseMessage.Headers.Get("x-ms-substatus"), "1024"))
{
Assert.Fail("ReadManyItemsStreamAsync execution should have failed with the StatusCode: BadRequest and SubStatusCode: 1024. ");
}
}
// validate by passing correct Rid.
ContainerInlineCore containerInternal = (ContainerInlineCore)this.Container;
string rid = await containerInternal.GetCachedRIDAsync(forceRefresh : false, NoOpTrace.Singleton, cancellationToken : default);
public async Task ClientConfigTest()
{
ToDoActivity testItem = ToDoActivity.CreateRandomToDoActivity();
ItemResponse <ToDoActivity> response = await this.Container.CreateItemAsync(testItem, new Cosmos.PartitionKey(testItem.pk));
Assert.IsNotNull(response.Diagnostics);
ITrace trace = ((CosmosTraceDiagnostics)response.Diagnostics).Value;
Assert.AreEqual(trace.Data.Count, 1);
ClientConfigurationTraceDatum clientConfigurationTraceDatum = (ClientConfigurationTraceDatum)trace.Data["Client Configuration"];
Assert.IsNotNull(clientConfigurationTraceDatum.UserAgentContainer.UserAgent);
}
