public async Task PointOperationRequestTimeoutDiagnostic(bool disableDiagnostics)
{
ItemRequestOptions requestOptions = new ItemRequestOptions();
if (disableDiagnostics)
{
requestOptions.DiagnosticContextFactory = () => EmptyCosmosDiagnosticsContext.Singleton;
}
;
Guid exceptionActivityId = Guid.NewGuid();
string transportExceptionDescription = "transportExceptionDescription" + Guid.NewGuid();
Container containerWithTransportException = TransportClientHelper.GetContainerWithItemTransportException(
this.database.Id,
this.Container.Id,
exceptionActivityId,
transportExceptionDescription);
//Checking point operation diagnostics on typed operations
ToDoActivity testItem = ToDoActivity.CreateRandomToDoActivity();
try
{
ItemResponse <ToDoActivity> createResponse = await containerWithTransportException.CreateItemAsync <ToDoActivity>(
item : testItem,
requestOptions : requestOptions);
Assert.Fail("Should have thrown a request timeout exception");
}
catch (CosmosException ce) when(ce.StatusCode == System.Net.HttpStatusCode.RequestTimeout)
{
string exception = ce.ToString();
Assert.IsNotNull(exception);
Assert.IsTrue(exception.Contains(exceptionActivityId.ToString()));
Assert.IsTrue(exception.Contains(transportExceptionDescription));
string diagnosics = ce.Diagnostics.ToString();
if (disableDiagnostics)
{
Assert.IsTrue(string.IsNullOrEmpty(diagnosics));
}
else
{
Assert.IsFalse(string.IsNullOrEmpty(diagnosics));
Assert.IsTrue(exception.Contains(diagnosics));
DiagnosticValidator.ValidatePointOperationDiagnostics(ce.DiagnosticsContext);
}
}
}
public async Task ValidateContainerRecreateScenario()
{
CosmosClient cc1 = TestCommon.CreateCosmosClient();
CosmosClient cc2 = TestCommon.CreateCosmosClient();
Database database = null;
try
{
database = await cc1.CreateDatabaseAsync("ContainerRecreateScenarioDb");
Container containerCC1 = await database.CreateContainerAsync("ContainerRecreateContainer", "/pk");
// Create items with different pk values
for (int i = 0; i < 5; i++)
{
ItemResponse <ToDoActivity> itemResponse = await containerCC1.CreateItemAsync(
ToDoActivity.CreateRandomToDoActivity("pk" + i, i.ToString()));
}
List <(string, PartitionKey)> itemList = new List <(string, PartitionKey)>();
for (int i = 0; i < 5; i++)
{
itemList.Add((i.ToString(), new PartitionKey("pk" + i)));
}
FeedResponse <ToDoActivity> feedResponse = await containerCC1.ReadManyItemsAsync <ToDoActivity>(itemList);
Assert.AreEqual(feedResponse.Count, 5);
Database databaseCC2 = cc2.GetDatabase("ContainerRecreateScenarioDb");
Container containerCC2 = cc2.GetContainer("ContainerRecreateScenarioDb", "ContainerRecreateContainer");
await containerCC2.DeleteContainerAsync();
// Recreate container
containerCC2 = await databaseCC2.CreateContainerAsync("ContainerRecreateContainer", "/pk");
// Check if recreate scenario works
feedResponse = await containerCC1.ReadManyItemsAsync <ToDoActivity>(itemList);
Assert.AreEqual(feedResponse.Count, 0);
Assert.IsTrue(feedResponse.StatusCode == HttpStatusCode.OK);
}
finally
{
await database.DeleteAsync();
cc1.Dispose();
cc2.Dispose();
}
}
public async Task ItemLINQQueryWithContinuationTokenTest()
{
//Creating items for query.
IList <ToDoActivity> itemList = await ToDoActivity.CreateRandomItems(container : this.Container, pkCount : 10, perPKItemCount : 1, randomPartitionKey : true);
QueryRequestOptions queryRequestOptions = new QueryRequestOptions();
queryRequestOptions.MaxConcurrency = 1;
queryRequestOptions.MaxItemCount = 5;
IOrderedQueryable <ToDoActivity> linqQueryable = this.Container.GetItemLinqQueryable <ToDoActivity>(requestOptions: queryRequestOptions);
IQueryable <ToDoActivity> queriable = linqQueryable.Where(item => (item.taskNum < 100));
FeedIterator <ToDoActivity> feedIterator = queriable.ToFeedIterator();
int firstItemSet = 0;
string continuationToken = null;
while (feedIterator.HasMoreResults)
{
FeedResponse <ToDoActivity> feedResponse = await feedIterator.ReadNextAsync();
firstItemSet = feedResponse.Count();
continuationToken = feedResponse.ContinuationToken;
if (firstItemSet > 0)
{
break;
}
}
linqQueryable = this.Container.GetItemLinqQueryable <ToDoActivity>(continuationToken: continuationToken, requestOptions: queryRequestOptions);
queriable = linqQueryable.Where(item => (item.taskNum < 100));
feedIterator = queriable.ToFeedIterator();
//Test continuationToken with LINQ query generation and asynchronous feedIterator execution.
int secondItemSet = 0;
while (feedIterator.HasMoreResults)
{
FeedResponse <ToDoActivity> feedResponse = await feedIterator.ReadNextAsync();
secondItemSet += feedResponse.Count();
}
Assert.AreEqual(10 - firstItemSet, secondItemSet);
//Test continuationToken with blocking LINQ execution
linqQueryable = this.Container.GetItemLinqQueryable <ToDoActivity>(allowSynchronousQueryExecution: true, continuationToken: continuationToken, requestOptions: queryRequestOptions);
int linqExecutionItemCount = linqQueryable.Where(item => (item.taskNum < 100)).Count();
Assert.AreEqual(10 - firstItemSet, linqExecutionItemCount);
}
public async Task GatewaySameSessionTokenTest()
{
string createSessionToken = null;
GatewaySessionTokenTests.HttpClientHandlerHelper httpClientHandler = new HttpClientHandlerHelper
{
ResponseCallBack = (result) =>
{
HttpResponseMessage response = result.Result;
if (response.StatusCode != HttpStatusCode.Created)
{
return(response);
}
response.Headers.TryGetValues("x-ms-session-token", out IEnumerable <string> sessionTokens);
foreach (string singleToken in sessionTokens)
{
createSessionToken = singleToken;
break;
}
return(response);
}
};
using (CosmosClient client = TestCommon.CreateCosmosClient(builder => builder
.WithConnectionModeGateway()
.WithConsistencyLevel(Cosmos.ConsistencyLevel.Session)
.WithHttpClientFactory(() => new HttpClient(httpClientHandler))))
{
Container container = client.GetContainer(this.database.Id, this.Container.Id);
ToDoActivity item = ToDoActivity.CreateRandomToDoActivity("Status1001", "1001");
ItemResponse <ToDoActivity> itemResponse = await container.CreateItemAsync(item);
// Read back the created Item and check if the session token is identical.
string docLink = "dbs/" + this.database.Id + "/colls/" + this.Container.Id + "/docs/1001";
Documents.Collections.INameValueCollection headers = new StoreRequestNameValueCollection();
headers.Set(HttpConstants.HttpHeaders.PartitionKey, "[\"Status1001\"]");
DocumentServiceRequest request = DocumentServiceRequest.Create(OperationType.Read, ResourceType.Document, docLink, AuthorizationTokenType.PrimaryMasterKey, headers);
await GatewayStoreModel.ApplySessionTokenAsync(request,
Cosmos.ConsistencyLevel.Session,
client.DocumentClient.sessionContainer,
await client.DocumentClient.GetPartitionKeyRangeCacheAsync(NoOpTrace.Singleton),
await client.DocumentClient.GetCollectionCacheAsync(NoOpTrace.Singleton));
string readSessionToken = request.Headers[HttpConstants.HttpHeaders.SessionToken];
Assert.AreEqual(readSessionToken, createSessionToken);
}
}
public async Task ValidateUserDefinedFunctionsTest()
{
// Prevent failures if previous test did not clean up correctly
await this.scripts.DeleteUserDefinedFunctionAsync("calculateTax");
ToDoActivity item = new ToDoActivity()
{
id = Guid.NewGuid().ToString(),
cost = 9001,
description = "udf_test_item",
status = "Done",
taskNum = 1
};
await this.container.CreateItemAsync <ToDoActivity>(item.status, item);
CosmosUserDefinedFunctionSettings cosmosUserDefinedFunction = await this.scripts.CreateUserDefinedFunctionAsync(
new CosmosUserDefinedFunctionSettings
{
Id = "calculateTax",
Body = @"function(amt) { return amt * 0.05; }"
});
CosmosSqlQueryDefinition sqlQuery = new CosmosSqlQueryDefinition(
"SELECT t.id, t.status, t.cost, udf.calculateTax(t.cost) as total FROM toDoActivity t where t.cost > @expensive and t.status = @status")
.UseParameter("@expensive", 9000)
.UseParameter("@status", "Done");
FeedIterator <dynamic> feedIterator = this.container.CreateItemQuery <dynamic>(
sqlQueryDefinition: sqlQuery,
partitionKey: "Done");
HashSet <string> iterIds = new HashSet <string>();
while (feedIterator.HasMoreResults)
{
foreach (var response in await feedIterator.FetchNextSetAsync())
{
Assert.IsTrue(response.cost > 9000);
Assert.AreEqual(response.cost * .05, response.total);
iterIds.Add(response.id.Value);
}
}
Assert.IsTrue(iterIds.Count > 0);
Assert.IsTrue(iterIds.Contains(item.id));
// Delete existing user defined functions.
await this.scripts.DeleteUserDefinedFunctionAsync(cosmosUserDefinedFunction.Id);
}
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);
}
public async Task VerifyPkRangeCacheRefreshOnTimeoutsAsync()
{
int pkRangeCalls = 0;
HttpClientHandlerHelper httpHandlerHelper = new();
List <string> ifNoneMatchValues = new();
httpHandlerHelper.RequestCallBack = (request, cancellationToken) =>
{
if (!request.RequestUri.ToString().EndsWith("pkranges"))
{
return(null);
}
ifNoneMatchValues.Add(request.Headers.IfNoneMatch.ToString());
pkRangeCalls++;
// Cause timeout on the init
if (pkRangeCalls == 1)
{
return(Task.FromResult(new HttpResponseMessage(HttpStatusCode.RequestTimeout)));
}
return(null);
};
CosmosClientOptions clientOptions = new CosmosClientOptions()
{
HttpClientFactory = () => new HttpClient(httpHandlerHelper),
};
CosmosClient resourceClient = TestCommon.CreateCosmosClient(clientOptions);
string dbName = Guid.NewGuid().ToString();
string containerName = nameof(PartitionKeyRangeCacheTests);
Database db = await resourceClient.CreateDatabaseIfNotExistsAsync(dbName);
Container container = await db.CreateContainerIfNotExistsAsync(
containerName,
"/pk",
400);
ToDoActivity toDoActivity = ToDoActivity.CreateRandomToDoActivity();
await container.CreateItemAsync <ToDoActivity>(toDoActivity);
Assert.AreEqual(3, pkRangeCalls);
Assert.AreEqual(2, ifNoneMatchValues.Count(x => string.IsNullOrEmpty(x)), "First call is a 408");
}
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);
Assert.IsNotNull(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");
Assert.IsNotNull(replaceResponse.Diagnostics);
ItemResponse<ToDoActivity> deleteResponse = await this.Container.DeleteItemAsync<ToDoActivity>(partitionKey: new Cosmos.PartitionKey(testItem.status), id: testItem.id);
Assert.IsNotNull(deleteResponse);
Assert.IsNotNull(deleteResponse.Diagnostics);
//Checking point operation diagnostics on stream operations
ResponseMessage createStreamResponse = await this.Container.CreateItemStreamAsync(
partitionKey: new PartitionKey(testItem.status),
streamPayload: TestCommon.Serializer.ToStream<ToDoActivity>(testItem));
Assert.IsNotNull(createStreamResponse.Diagnostics);
ResponseMessage readStreamResponse = await this.Container.ReadItemStreamAsync(
id: testItem.id,
partitionKey: new PartitionKey(testItem.status));
Assert.IsNotNull(readStreamResponse.Diagnostics);
ResponseMessage replaceStreamResponse = await this.Container.ReplaceItemStreamAsync(
streamPayload: TestCommon.Serializer.ToStream<ToDoActivity>(testItem),
id: testItem.id,
partitionKey: new PartitionKey(testItem.status));
Assert.IsNotNull(replaceStreamResponse.Diagnostics);
ResponseMessage deleteStreamResponse = await this.Container.DeleteItemStreamAsync(
id: testItem.id,
partitionKey: new PartitionKey(testItem.status));
Assert.IsNotNull(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.Serializer.ToStream<ToDoActivity>(testItem));
Assert.IsFalse(createTooBigStreamResponse.IsSuccessStatusCode);
Assert.IsNotNull(createTooBigStreamResponse.Diagnostics);
}
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);
Assert.IsNotNull(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");
Assert.IsNotNull(replaceResponse.Diagnostics);
ItemResponse <ToDoActivity> deleteResponse = await this.Container.DeleteItemAsync <ToDoActivity>(partitionKey : new Cosmos.PartitionKey(testItem.status), id : testItem.id);
Assert.IsNotNull(deleteResponse);
Assert.IsNotNull(deleteResponse.Diagnostics);
//Checking point operation diagnostics on stream operations
ResponseMessage createStreamResponse = await this.Container.CreateItemStreamAsync(
partitionKey : new PartitionKey(testItem.status),
streamPayload : TestCommon.Serializer.ToStream <ToDoActivity>(testItem));
Assert.IsNotNull(createStreamResponse.Diagnostics);
ResponseMessage readStreamResponse = await this.Container.ReadItemStreamAsync(
id : testItem.id,
partitionKey : new PartitionKey(testItem.status));
Assert.IsNotNull(readStreamResponse.Diagnostics);
ResponseMessage replaceStreamResponse = await this.Container.ReplaceItemStreamAsync(
streamPayload : TestCommon.Serializer.ToStream <ToDoActivity>(testItem),
id : testItem.id,
partitionKey : new PartitionKey(testItem.status));
Assert.IsNotNull(replaceStreamResponse.Diagnostics);
ResponseMessage deleteStreamResponse = await this.Container.DeleteItemStreamAsync(
id : testItem.id,
partitionKey : new PartitionKey(testItem.status));
Assert.IsNotNull(deleteStreamResponse.Diagnostics);
}
public async Task CreateDropItemTest()
{
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);
long?lsnAfterCreate = await GetLSNFromSessionContainer(
this.Container, this.containerSettings, new PartitionKey(testItem.pk));
Assert.IsNotNull(lsnAfterCreate);
CosmosTraceDiagnostics diagnostics = (CosmosTraceDiagnostics)response.Diagnostics;
Assert.IsFalse(diagnostics.IsGoneExceptionHit());
Assert.IsFalse(string.IsNullOrEmpty(diagnostics.ToString()));
Assert.IsTrue(diagnostics.GetClientElapsedTime() > TimeSpan.Zero);
response = await this.Container.ReadItemAsync <ToDoActivity>(testItem.id, new Cosmos.PartitionKey(testItem.pk));
Assert.IsNotNull(response);
Assert.IsNotNull(response.Resource);
Assert.IsNotNull(response.Diagnostics);
Assert.IsFalse(string.IsNullOrEmpty(response.Diagnostics.ToString()));
Assert.IsTrue(response.Diagnostics.GetClientElapsedTime() > TimeSpan.Zero);
long?lsnAfterRead = await GetLSNFromSessionContainer(
this.Container, this.containerSettings, new PartitionKey(testItem.pk));
Assert.IsNotNull(lsnAfterRead);
Assert.AreEqual(lsnAfterCreate.Value, lsnAfterRead.Value);
Assert.IsNotNull(response.Headers.GetHeaderValue <string>(Documents.HttpConstants.HttpHeaders.MaxResourceQuota));
Assert.IsNotNull(response.Headers.GetHeaderValue <string>(Documents.HttpConstants.HttpHeaders.CurrentResourceQuotaUsage));
ItemResponse <ToDoActivity> deleteResponse = await this.Container.DeleteItemAsync <ToDoActivity>(partitionKey : new Cosmos.PartitionKey(testItem.pk), id : testItem.id);
Assert.IsNotNull(deleteResponse);
Assert.IsNotNull(response.Diagnostics);
Assert.IsFalse(string.IsNullOrEmpty(response.Diagnostics.ToString()));
Assert.IsTrue(response.Diagnostics.GetClientElapsedTime() > TimeSpan.Zero);
long?lsnAfterDelete = await GetLSNFromSessionContainer(
this.Container, this.containerSettings, new PartitionKey(testItem.pk));
Assert.IsNotNull(lsnAfterDelete);
Assert.IsTrue(lsnAfterDelete.Value > lsnAfterCreate.Value);
}
public override bool Equals(Object obj)
{
ToDoActivity input = obj as ToDoActivity;
if (input == null)
{
return(false);
}
return(string.Equals(this.id, input.id) &&
this.taskNum == input.taskNum &&
this.cost == input.cost &&
string.Equals(this.description, input.description) &&
string.Equals(this.pk, input.pk));
}
public async Task ClientContentResponseReadTest()
{
ToDoActivity item = ToDoActivity.CreateRandomToDoActivity();
ItemResponse <ToDoActivity> itemResponse = await this.containerWithFlag.CreateItemAsync(item);
Assert.AreEqual(HttpStatusCode.Created, itemResponse.StatusCode);
// Ensuring the Reads are returning the Resource
ItemResponse <ToDoActivity> readResponse = await this.containerWithFlag.ReadItemAsync <ToDoActivity>(item.id, new PartitionKey(item.pk));
Assert.AreEqual(HttpStatusCode.OK, readResponse.StatusCode);
Assert.IsNotNull(itemResponse);
Assert.IsNotNull(itemResponse.Resource);
}
public void LinqQueryToIteratorBlockTest(bool isStreamIterator)
{
//Checking for exception in case of ToFeedIterator() use on non cosmos linq IQueryable.
IQueryable <ToDoActivity> nonLinqQueryable = new List <ToDoActivity> {
ToDoActivity.CreateRandomToDoActivity()
}.AsQueryable();
if (isStreamIterator)
{
nonLinqQueryable.ToStreamIterator();
}
else
{
nonLinqQueryable.ToFeedIterator();
}
}
public async Task CachedSerializationTest()
{
ToDoActivity testItem = ToDoActivity.CreateRandomToDoActivity();
ItemResponse <ToDoActivity> response = await this.Container.CreateItemAsync(testItem, new Cosmos.PartitionKey(testItem.pk));
ITrace trace = ((CosmosTraceDiagnostics)response.Diagnostics).Value;
ClientConfigurationTraceDatum clientConfigurationTraceDatum = (ClientConfigurationTraceDatum)trace.Data["Client Configuration"];
Assert.IsNotNull(clientConfigurationTraceDatum.SerializedJson);
TestCommon.CreateCosmosClient();
response = await this.Container.ReadItemAsync <ToDoActivity>(testItem.id, new Cosmos.PartitionKey(testItem.pk));
trace = ((CosmosTraceDiagnostics)response.Diagnostics).Value;
clientConfigurationTraceDatum = (ClientConfigurationTraceDatum)trace.Data["Client Configuration"];
Assert.IsNotNull(clientConfigurationTraceDatum.SerializedJson);
}
public async Task QueryActivityIdWithContinuationTokenAndTraceTest()
{
using (ITrace rootTrace = Trace.GetRootTrace("Root Trace"))
{
CosmosClient client = DirectCosmosClient;
Container container = client.GetContainer(DatabaseId, ContainerId);
// Create items
for (int i = 0; i < 500; i++)
{
await container.CreateItemAsync <ToDoActivity>(ToDoActivity.CreateRandomToDoActivity());
}
QueryRequestOptions queryRequestOptions = new QueryRequestOptions
{
MaxItemCount = 50
};
FeedIteratorInternal feedIterator =
(FeedIteratorInternal)container.GetItemQueryStreamIterator(
"select * from c",
null,
queryRequestOptions);
string continuationToken = (await feedIterator.ReadNextAsync(rootTrace, CancellationToken.None)).ContinuationToken;
rootTrace.Data.TryGetValue("Query Correlated ActivityId",
out object firstCorrelatedActivityId);
// use Continuation Token to create new iterator and use same trace
FeedIteratorInternal feedIteratorNew =
(FeedIteratorInternal)container.GetItemQueryStreamIterator(
"select * from c",
continuationToken,
queryRequestOptions);
while (feedIteratorNew.HasMoreResults)
{
await feedIteratorNew.ReadNextAsync(rootTrace, CancellationToken.None);
}
// Test trace has 2 correlated ActivityIds
rootTrace.Data.TryGetValue("Query Correlated ActivityId",
out object correlatedActivityIds);
List <string> correlatedIdList = correlatedActivityIds.ToString().Split(',').ToList();
Assert.AreEqual(correlatedIdList.Count, 2);
Assert.AreEqual(correlatedIdList[0], firstCorrelatedActivityId.ToString());
}
}
private async Task CheckCancellationTokenTestAsync(
Container container,
CancellationToken cancellationToken)
{
ToDoActivity toDoActivity = ToDoActivity.CreateRandomToDoActivity();
try
{
await container.CreateItemAsync <ToDoActivity>(
toDoActivity,
new Cosmos.PartitionKey(toDoActivity.pk),
cancellationToken : cancellationToken);
Assert.Fail("Should have thrown");
}
catch (CosmosOperationCanceledException ce)
{
Assert.IsNotNull(ce);
string message = ce.Message;
string diagnostics = ce.Diagnostics.ToString();
string toString = ce.ToString();
Assert.IsTrue(toString.Contains(diagnostics));
Assert.IsTrue(message.Contains(diagnostics));
string messageWithoutDiagnostics = message.Substring(0, message.IndexOf(Environment.NewLine)).Trim();
Assert.IsTrue(toString.Contains(messageWithoutDiagnostics));
}
try
{
FeedIterator feedIterator = container.GetItemQueryStreamIterator(
"select * from T");
await feedIterator.ReadNextAsync(cancellationToken : cancellationToken);
Assert.Fail("Should have thrown");
}
catch (CosmosOperationCanceledException ce)
{
string message = ce.Message;
string diagnostics = ce.Diagnostics.ToString();
string toString = ce.ToString();
Assert.IsTrue(toString.Contains(diagnostics));
Assert.IsTrue(message.Contains(diagnostics));
string messageWithoutDiagnostics = message.Substring(0, message.IndexOf(Environment.NewLine)).Trim();
Assert.IsTrue(toString.Contains(messageWithoutDiagnostics));
}
}
public async Task CosmosEndToEndNullReferenceExceptionTestAsync()
{
string errorMessage = Guid.NewGuid().ToString();
RequestHandlerHelper requestHandlerHelper = new RequestHandlerHelper
{
UpdateRequestMessage = (request) => throw new NullReferenceException(errorMessage)
};
using CosmosClient client = TestCommon.CreateCosmosClient(builder => builder.AddCustomHandlers(requestHandlerHelper));
Container containerWithNullRef = client.GetContainer(this.database.Id, this.container.Id);
try
{
ToDoActivity toDoActivity = ToDoActivity.CreateRandomToDoActivity();
await containerWithNullRef.CreateItemAsync(toDoActivity);
Assert.Fail("Create should throw a null reference exception");
}
catch (NullReferenceException nre)
{
Assert.AreEqual(typeof(CosmosNullReferenceException), nre.GetType());
Assert.IsTrue(nre.Message.Contains("CreateItemAsync"));
string cosmosToString = nre.ToString();
Assert.IsFalse(cosmosToString.Contains("Microsoft.Azure.Cosmos.CosmosNullReferenceException"), $"The internal wrapper exception should not be exposed to users. {cosmosToString}");
Assert.IsTrue(cosmosToString.Contains(errorMessage));
Assert.IsTrue(cosmosToString.Contains("CreateItemAsync"));
}
try
{
FeedIterator <ToDoActivity> iterator = containerWithNullRef.GetItemQueryIterator <ToDoActivity>("select * from T");
await iterator.ReadNextAsync();
Assert.Fail("Create should throw a null reference exception");
}
catch (NullReferenceException nre)
{
Assert.AreEqual(typeof(CosmosNullReferenceException), nre.GetType());
Assert.IsTrue(nre.Message.Contains("Typed FeedIterator ReadNextAsync"));
string cosmosToString = nre.ToString();
Assert.IsFalse(cosmosToString.Contains("Microsoft.Azure.Cosmos.CosmosNullReferenceException"), $"The internal wrapper exception should not be exposed to users. {cosmosToString}");
Assert.IsTrue(cosmosToString.Contains(errorMessage));
Assert.IsTrue(cosmosToString.Contains("Typed FeedIterator ReadNextAsync"));
}
}
}
public async Task ReadManyExceptionsTest(HttpStatusCode statusCode)
{
RequestHandler[] requestHandlers = new RequestHandler[1];
requestHandlers[0] = new CustomHandler(statusCode);
CosmosClientBuilder builder = TestCommon.GetDefaultConfiguration();
builder.AddCustomHandlers(requestHandlers);
CosmosClient client = builder.Build();
Database database = await client.CreateDatabaseAsync(Guid.NewGuid().ToString());
Container container = await database.CreateContainerAsync(Guid.NewGuid().ToString(), "/pk");
for (int i = 0; i < 5; i++)
{
await container.CreateItemAsync(
ToDoActivity.CreateRandomToDoActivity("pk" + i, i.ToString()));
}
List <(string, PartitionKey)> itemList = new List <(string, PartitionKey)>();
for (int i = 0; i < 5; i++)
{
itemList.Add(("IncorrectId" + i, new PartitionKey("pk" + i))); // wrong ids
}
using (ResponseMessage responseMessage = await container.ReadManyItemsStreamAsync(itemList))
{
Assert.AreEqual(responseMessage.StatusCode, statusCode);
}
try
{
await container.ReadManyItemsAsync <ToDoActivity>(itemList);
Assert.Fail("Typed API should throw");
}
catch (CosmosException ex)
{
Assert.AreEqual(ex.StatusCode, statusCode);
}
await database.DeleteAsync();
client.Dispose();
}
public async Task RequestStatsForDirectMode()
{
ToDoActivity item = ToDoActivity.CreateRandomToDoActivity();
await this.Container.CreateItemAsync(item);
using (CosmosClient cosmosClient = TestCommon.CreateCosmosClient(useGateway: false))
{
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, "Transport Request");
Assert.IsNotNull(datum.HttpResponseStatisticsList);
// One call for collection cache, 2 calls for PK range cache and 1 call for Address Resolution
Assert.AreEqual(datum.HttpResponseStatisticsList.Count, 4);
}
}
public async Task PointSuccessOperationsTest(ConnectionMode mode)
{
Container container = await this.CreateClientAndContainer(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));
IDictionary <string, long> expectedRecordCountInOperation = new Dictionary <string, long>
{
{ Documents.OperationType.Create.ToString(), 1 },
{ Documents.OperationType.Upsert.ToString(), 1 },
{ Documents.OperationType.Read.ToString(), 1 },
{ Documents.OperationType.Replace.ToString(), 1 },
{ Documents.OperationType.Patch.ToString(), 1 },
{ Documents.OperationType.Delete.ToString(), 1 }
};
await this.WaitAndAssert(expectedOperationCount : 12,
expectedOperationRecordCountMap : expectedRecordCountInOperation);
}
public async Task ValidateTriggersTest()
{
// Prevent failures if previous test did not clean up correctly
try
{
await this.scripts.DeleteTriggerAsync("addTax");
}
catch (CosmosException ex) when(ex.StatusCode == HttpStatusCode.NotFound)
{
//swallow
}
ToDoActivity item = new ToDoActivity()
{
id = Guid.NewGuid().ToString(),
cost = 9001,
description = "trigger_test_item",
status = "Done",
taskNum = 1
};
TriggerProperties cosmosTrigger = await this.scripts.CreateTriggerAsync(
new TriggerProperties
{
Id = "addTax",
Body = TriggersTests.GetTriggerFunction(".20"),
TriggerOperation = Cosmos.Scripts.TriggerOperation.All,
TriggerType = Cosmos.Scripts.TriggerType.Pre
});
ItemRequestOptions options = new ItemRequestOptions()
{
PreTriggers = new List <string>()
{
cosmosTrigger.Id
},
};
ItemResponse <dynamic> createdItem = await this.container.CreateItemAsync <dynamic>(item, requestOptions : options);
double itemTax = createdItem.Resource.tax;
Assert.AreEqual(item.cost * .20, itemTax);
// Delete existing user defined functions.
await this.scripts.DeleteTriggerAsync("addTax");
}
public async Task QueryOperationDiagnostic(bool disableDiagnostics)
{
int totalItems = 3;
IList <ToDoActivity> itemList = await ToDoActivity.CreateRandomItems(
this.Container,
pkCount : totalItems,
perPKItemCount : 1,
randomPartitionKey : true);
long readFeedTotalOutputDocumentCount = await this.ExecuteQueryAndReturnOutputDocumentCount(
queryText : null,
expectedItemCount : totalItems,
disableDiagnostics : disableDiagnostics);
Assert.AreEqual(totalItems, readFeedTotalOutputDocumentCount);
//Checking query metrics on typed query
long totalOutputDocumentCount = await this.ExecuteQueryAndReturnOutputDocumentCount(
queryText : "select * from ToDoActivity",
expectedItemCount : totalItems,
disableDiagnostics : disableDiagnostics);
Assert.AreEqual(totalItems, totalOutputDocumentCount);
totalOutputDocumentCount = await this.ExecuteQueryAndReturnOutputDocumentCount(
queryText : "select * from ToDoActivity t ORDER BY t.cost",
expectedItemCount : totalItems,
disableDiagnostics : disableDiagnostics);
Assert.AreEqual(totalItems, totalOutputDocumentCount);
totalOutputDocumentCount = await this.ExecuteQueryAndReturnOutputDocumentCount(
queryText : "select DISTINCT t.cost from ToDoActivity t",
expectedItemCount : 1,
disableDiagnostics : disableDiagnostics);
Assert.IsTrue(totalOutputDocumentCount >= 1);
totalOutputDocumentCount = await this.ExecuteQueryAndReturnOutputDocumentCount(
queryText : "select * from ToDoActivity OFFSET 1 LIMIT 1",
expectedItemCount : 1,
disableDiagnostics : disableDiagnostics);
Assert.IsTrue(totalOutputDocumentCount >= 1);
}
public async Task ReplaceItemStreamTest()
{
ToDoActivity testItem = this.CreateRandomToDoActivity();
using (Stream stream = this.jsonSerializer.ToStream <ToDoActivity>(testItem))
{
//Replace a non-existing item. It should fail, and not throw an exception.
using (CosmosResponseMessage response = await this.Container.Items.ReplaceItemStreamAsync(
partitionKey: testItem.status,
id: testItem.id,
streamPayload: stream))
{
Assert.IsFalse(response.IsSuccessStatusCode);
Assert.IsNotNull(response);
Assert.AreEqual(HttpStatusCode.NotFound, response.StatusCode, response.ErrorMessage);
}
}
using (Stream stream = this.jsonSerializer.ToStream <ToDoActivity>(testItem))
{
//Create the item
using (CosmosResponseMessage response = await this.Container.Items.CreateItemStreamAsync(partitionKey: testItem.status, streamPayload: stream))
{
Assert.IsNotNull(response);
Assert.AreEqual(HttpStatusCode.Created, response.StatusCode);
}
}
//Updated the taskNum field
testItem.taskNum = 9001;
using (Stream stream = this.jsonSerializer.ToStream <ToDoActivity>(testItem))
{
using (CosmosResponseMessage response = await this.Container.Items.ReplaceItemStreamAsync(partitionKey: testItem.status, id: testItem.id, streamPayload: stream))
{
Assert.IsNotNull(response);
Assert.AreEqual(HttpStatusCode.OK, response.StatusCode);
}
using (CosmosResponseMessage deleteResponse = await this.Container.Items.DeleteItemStreamAsync(partitionKey: testItem.status, id: testItem.id))
{
Assert.IsNotNull(deleteResponse);
Assert.AreEqual(deleteResponse.StatusCode, HttpStatusCode.NoContent);
}
}
}
public async Task MultipleQueriesToSamePartitionTest()
{
for (int i = 0; i < 2500; i++)
{
await this.Container.CreateItemAsync <ToDoActivity>(ToDoActivity.CreateRandomToDoActivity("pk", i.ToString()));
}
List <(string, PartitionKey)> itemList = new List <(string, PartitionKey)>();
for (int i = 0; i < 2500; i++)
{
itemList.Add((i.ToString(), new PartitionKey("pk")));
}
FeedResponse <ToDoActivity> feedResponse = await this.Container.ReadManyItemsAsync <ToDoActivity>(itemList);
Assert.AreEqual(feedResponse.Count, 2500);
}
public async Task ItemMultiplePartitionOrderByQueryStream()
{
IList <ToDoActivity> deleteList = await this.CreateRandomItems(300, randomPartitionKey : true);
CosmosSqlQueryDefinition sql = new CosmosSqlQueryDefinition("SELECT * FROM toDoActivity t ORDER BY t.taskNum ");
CosmosQueryRequestOptions requestOptions = new CosmosQueryRequestOptions()
{
MaxBufferedItemCount = 10,
ResponseContinuationTokenLimitInKb = 500
};
List <ToDoActivity> resultList = new List <ToDoActivity>();
double totalRequstCharge = 0;
CosmosResultSetIterator setIterator =
this.Container.Items.CreateItemQueryAsStream(sql, maxConcurrency: 5, maxItemCount: 1, requestOptions: requestOptions);
while (setIterator.HasMoreResults)
{
using (CosmosQueryResponse iter = await setIterator.FetchNextSetAsync())
{
Assert.IsTrue(iter.IsSuccess);
Assert.IsNull(iter.ErrorMessage);
Assert.IsTrue(iter.Count <= 5);
totalRequstCharge += iter.RequestCharge;
ToDoActivity[] activities = this.jsonSerializer.FromStream <ToDoActivity[]>(iter.Content);
Assert.AreEqual(1, activities.Length);
ToDoActivity response = activities.First();
resultList.Add(response);
}
}
Assert.AreEqual(deleteList.Count, resultList.Count);
Assert.IsTrue(totalRequstCharge > 0);
List <ToDoActivity> verifiedOrderBy = deleteList.OrderBy(x => x.taskNum).ToList();
for (int i = 0; i < verifiedOrderBy.Count(); i++)
{
Assert.AreEqual(verifiedOrderBy[i].taskNum, resultList[i].taskNum);
Assert.AreEqual(verifiedOrderBy[i].id, resultList[i].id);
}
}
public async Task GatewayQueryPlanDiagnostic()
{
int totalItems = 3;
IList <ToDoActivity> itemList = await ToDoActivity.CreateRandomItems(
this.Container,
pkCount : totalItems,
perPKItemCount : 1,
randomPartitionKey : true);
ContainerInternal containerCore = (ContainerInlineCore)this.Container;
MockCosmosQueryClient gatewayQueryPlanClient = new MockCosmosQueryClient(
clientContext: containerCore.ClientContext,
cosmosContainerCore: containerCore,
forceQueryPlanGatewayElseServiceInterop: true);
Container gatewayQueryPlanContainer = new ContainerInlineCore(
containerCore.ClientContext,
(DatabaseInternal)containerCore.Database,
containerCore.Id,
gatewayQueryPlanClient);
QueryRequestOptions queryRequestOptions = new QueryRequestOptions()
{
MaxItemCount = 1,
MaxBufferedItemCount = 0
};
FeedIterator <ToDoActivity> feedIterator = gatewayQueryPlanContainer.GetItemQueryIterator <ToDoActivity>(
"select * from ToDoActivity t ORDER BY t.cost",
requestOptions: queryRequestOptions);
List <ToDoActivity> results = new List <ToDoActivity>();
bool isFirstPage = true;
while (feedIterator.HasMoreResults)
{
FeedResponse <ToDoActivity> response = await feedIterator.ReadNextAsync();
results.AddRange(response);
CosmosDiagnosticsContext diagnosticsContext = (response.Diagnostics as CosmosDiagnosticsCore).Context;
DiagnosticValidator.ValidateQueryGatewayPlanDiagnostics(diagnosticsContext, isFirstPage);
isFirstPage = false;
}
}
public async Task NegativeContainerThroughputTestAsync()
{
// Create a database and container to make sure all the caches are warmed up
Database db1 = await this.cosmosClient.CreateDatabaseAsync(
Guid.NewGuid().ToString(),
400);
// Container does not have an offer
Container container = await db1.CreateContainerAsync(
Guid.NewGuid().ToString(),
"/pk");
await container.CreateItemAsync(ToDoActivity.CreateRandomToDoActivity());
try
{
await container.ReadThroughputAsync(requestOptions : null);
Assert.Fail("Should throw exception");
}
catch (CosmosException ex) when(ex.StatusCode == HttpStatusCode.NotFound)
{
Assert.IsTrue(ex.Message.Contains(container.Id));
}
try
{
await container.ReplaceThroughputAsync(400);
Assert.Fail("Should throw exception");
}
catch (CosmosException ex) when(ex.StatusCode == HttpStatusCode.NotFound)
{
Assert.IsTrue(ex.Message.Contains(container.Id));
}
int?throughput = await container.ReadThroughputAsync();
Assert.IsNull(throughput);
{
ThroughputResponse offerAfterRecreate = await((ContainerInternal)container).ReadThroughputIfExistsAsync(
requestOptions: default,
public async Task ItemRequestOptionAccessConditionTest()
{
// Create an item
ToDoActivity testItem = (await this.CreateRandomItems(1, randomPartitionKey: true)).First();
// Create an access condition that will fail because the etag will be different
AccessCondition accessCondition = new AccessCondition
{
// Random etag
Condition = Guid.NewGuid().ToString(),
Type = AccessConditionType.IfMatch
};
CosmosItemRequestOptions itemRequestOptions = new CosmosItemRequestOptions()
{
AccessCondition = accessCondition
};
try
{
CosmosItemResponse <ToDoActivity> response = await this.Container.Items.ReplaceItemAsync <ToDoActivity>(
partitionKey : testItem.status,
id : testItem.id,
item : testItem,
requestOptions : itemRequestOptions);
Assert.Fail("Access condition should have failed");
}
catch (CosmosException e)
{
Assert.IsNotNull(e);
Assert.AreEqual(HttpStatusCode.PreconditionFailed, e.StatusCode, e.Message);
Assert.IsNotNull(e.ActivityId);
Assert.IsTrue(e.RequestCharge > 0);
}
finally
{
CosmosItemResponse <ToDoActivity> deleteResponse = await this.Container.Items.DeleteItemAsync <ToDoActivity>(partitionKey : testItem.status, id : testItem.id);
Assert.IsNotNull(deleteResponse);
}
}
public async Task VerifyDiagnosticsOrderTest()
{
ToDoActivity testItem = ToDoActivity.CreateRandomToDoActivity();
ItemResponse <ToDoActivity> response = await this.Container.CreateItemAsync(testItem, new Cosmos.PartitionKey(testItem.pk));
ITrace trace = ((CosmosTraceDiagnostics)response.Diagnostics).Value;
TestCommon.CreateCosmosClient();
CancellationToken token = new CancellationToken(canceled: true);
try
{
response = await this.Container.ReadItemAsync <ToDoActivity>(testItem.id, new Cosmos.PartitionKey(testItem.pk), cancellationToken : token);
Assert.Fail("Test should throw/catch a CosmosOperationCanceledException");
}
catch (CosmosOperationCanceledException oce)
{
IReadOnlyList <ITrace> children = ((CosmosTraceDiagnostics)oce.Diagnostics).Value.Children;
ITrace exceptionChild = children[^ 1];
public async Task DefaultNullValueHandling()
{
ToDoActivity document = new ToDoActivity()
{
id = Guid.NewGuid().ToString(),
description = default(string),
status = "TBD",
taskNum = 42,
cost = double.MaxValue
};
await container.UpsertItemAsync(document);
CosmosResponseMessage cosmosResponseMessage = await container.ReadItemStreamAsync(new PartitionKey(document.status), document.id);
StreamReader reader = new StreamReader(cosmosResponseMessage.Content);
string text = reader.ReadToEnd();
Assert.AreEqual(-1, text.IndexOf(nameof(document.description)), "Stored document contains a null attribute");
}
