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