public async Task StandByFeedIterator_WithMaxItemCount() { await this.CreateRandomItems(2, randomPartitionKey : true); ContainerCore itemsCore = (ContainerCore)this.Container; FeedIterator feedIterator = itemsCore.GetStandByFeedIterator(maxItemCount: 1, requestOptions: new ChangeFeedRequestOptions() { StartTime = DateTime.MinValue }); while (feedIterator.HasMoreResults) { using (ResponseMessage responseMessage = await feedIterator.ReadNextAsync(this.cancellationToken)) { if (responseMessage.IsSuccessStatusCode) { Collection <ToDoActivity> response = new CosmosJsonSerializerCore().FromStream <CosmosFeedResponseUtil <ToDoActivity> >(responseMessage.Content).Data; if (response.Count > 0) { Assert.AreEqual(1, response.Count); return; } } } } Assert.Fail("Found no batch with size 1"); }
public async Task TestInitialize() { await base.TestInit(); string PartitionKey = "/status"; ContainerResponse response = await this.database.CreateContainerAsync( new CosmosContainerProperties(id : Guid.NewGuid().ToString(), partitionKeyPath : PartitionKey), cancellationToken : this.cancellationToken); Assert.IsNotNull(response); this.container = response; this.jsonSerializer = new CosmosJsonSerializerCore(); }
public void ValidateJson() { CosmosJsonSerializerCore cosmosDefaultJsonSerializer = new CosmosJsonSerializerCore(); using (Stream stream = cosmosDefaultJsonSerializer.ToStream <ToDoActivity>(this.toDoActivity)) { Assert.IsNotNull(stream); using (StreamReader reader = new StreamReader(stream)) { string responseAsString = reader.ReadToEnd(); Assert.IsNotNull(responseAsString); Assert.AreEqual(this.toDoActivityJson, responseAsString); } } }
public async Task StandByFeedIterator_NoFetchNext() { var pkRanges = await this.Container.ClientContext.DocumentClient.ReadPartitionKeyRangeFeedAsync(this.Container.LinkUri); int expected = 25; int iterations = 0; await this.CreateRandomItems(expected, randomPartitionKey : true); ContainerCore itemsCore = (ContainerCore)this.Container; string continuationToken = null; int count = 0; while (true) { ChangeFeedRequestOptions requestOptions = new ChangeFeedRequestOptions() { StartTime = DateTime.MinValue }; FeedIterator feedIterator = itemsCore.GetStandByFeedIterator(continuationToken, requestOptions: requestOptions); using (ResponseMessage responseMessage = await feedIterator.ReadNextAsync(this.cancellationToken)) { continuationToken = responseMessage.Headers.Continuation; if (responseMessage.IsSuccessStatusCode) { Collection <ToDoActivity> response = new CosmosJsonSerializerCore().FromStream <CosmosFeedResponseUtil <ToDoActivity> >(responseMessage.Content).Data; count += response.Count; } } if (count > expected) { Assert.Fail($"{count} does not equal {expected}"); } if (count.Equals(expected)) { break; } if (iterations++ > pkRanges.Count) { Assert.Fail("Feed does not contain all elements even after looping through PK ranges. Either the continuation is not moving forward or there is some state problem."); } } }
public void ValidateSerializer() { CosmosJsonSerializerCore cosmosDefaultJsonSerializer = new CosmosJsonSerializerCore(); using (Stream stream = cosmosDefaultJsonSerializer.ToStream <ToDoActivity>(this.toDoActivity)) { Assert.IsNotNull(stream); ToDoActivity result = cosmosDefaultJsonSerializer.FromStream <ToDoActivity>(stream); Assert.IsNotNull(result); Assert.AreEqual(this.toDoActivity.id, result.id); Assert.AreEqual(this.toDoActivity.taskNum, result.taskNum); Assert.AreEqual(this.toDoActivity.cost, result.cost); Assert.AreEqual(this.toDoActivity.description, result.description); Assert.AreEqual(this.toDoActivity.status, result.status); } }
public async Task StreamIteratorTest() { string containerName = Guid.NewGuid().ToString(); string partitionKeyPath = "/users"; ContainerResponse containerResponse = await this.cosmosDatabase.CreateContainerAsync(containerName, partitionKeyPath); Assert.AreEqual(HttpStatusCode.Created, containerResponse.StatusCode); Assert.AreEqual(containerName, containerResponse.Resource.Id); Assert.AreEqual(partitionKeyPath, containerResponse.Resource.PartitionKey.Paths.First()); containerName = Guid.NewGuid().ToString(); containerResponse = await this.cosmosDatabase.CreateContainerAsync(containerName, partitionKeyPath); Assert.AreEqual(HttpStatusCode.Created, containerResponse.StatusCode); Assert.AreEqual(containerName, containerResponse.Resource.Id); Assert.AreEqual(partitionKeyPath, containerResponse.Resource.PartitionKey.Paths.First()); HashSet <string> containerIds = new HashSet <string>(); FeedIterator resultSet = this.cosmosDatabase.GetContainerQueryStreamIterator( requestOptions: new QueryRequestOptions() { MaxItemCount = 1 }); while (resultSet.HasMoreResults) { using (ResponseMessage message = await resultSet.ReadNextAsync()) { Assert.AreEqual(HttpStatusCode.OK, message.StatusCode); CosmosJsonSerializerCore defaultJsonSerializer = new CosmosJsonSerializerCore(); dynamic containers = defaultJsonSerializer.FromStream <dynamic>(message.Content).DocumentCollections; foreach (dynamic container in containers) { string id = container.id.ToString(); containerIds.Add(id); } } } Assert.IsTrue(containerIds.Count > 0, "The iterator did not find any containers."); Assert.IsTrue(containerIds.Contains(containerName), "The iterator did not find the created container"); containerResponse = await containerResponse.Container.DeleteContainerAsync(); Assert.AreEqual(HttpStatusCode.NoContent, containerResponse.StatusCode); }
public async Task CosmosConflictsStreamIteratorBuildsSettings() { string conflictResponsePayload = @"{ 'Data':[{ id: 'Conflict1', operationType: 'Replace', resourceType: 'trigger' }]}"; CosmosClient mockClient = MockCosmosUtil.CreateMockCosmosClient( (cosmosClientBuilder) => cosmosClientBuilder.WithConnectionModeDirect()); CosmosContainer container = mockClient.GetContainer("database", "container"); FeedIterator feedIterator = container.GetConflicts().GetConflictsStreamIterator(); TestHandler testHandler = new TestHandler((request, cancellationToken) => { Assert.AreEqual(OperationType.ReadFeed, request.OperationType); Assert.AreEqual(ResourceType.Conflict, request.ResourceType); CosmosResponseMessage handlerResponse = TestHandler.ReturnSuccess().Result; MemoryStream stream = new MemoryStream(); StreamWriter writer = new StreamWriter(stream); writer.Write(conflictResponsePayload); writer.Flush(); stream.Position = 0; handlerResponse.Content = stream; return(Task.FromResult(handlerResponse)); }); mockClient.RequestHandler.InnerHandler = testHandler; CosmosResponseMessage streamResponse = await feedIterator.FetchNextSetAsync(); Collection <CosmosConflictSettings> response = new CosmosJsonSerializerCore().FromStream <CosmosFeedResponseUtil <CosmosConflictSettings> >(streamResponse.Content).Data; Assert.AreEqual(1, response.Count()); CosmosConflictSettings responseSettings = response.FirstOrDefault(); Assert.IsNotNull(responseSettings); Assert.AreEqual("Conflict1", responseSettings.Id); Assert.AreEqual(Cosmos.OperationKind.Replace, responseSettings.OperationKind); Assert.AreEqual(typeof(CosmosTriggerSettings), responseSettings.ResourceType); }
public async Task TestInitialize() { this.cancellationTokenSource = new CancellationTokenSource(); this.cancellationToken = this.cancellationTokenSource.Token; this.cosmosClient = TestCommon.CreateCosmosClient(); this.database = await this.cosmosClient.CreateDatabaseAsync(Guid.NewGuid().ToString(), cancellationToken : this.cancellationToken); this.documentClient = TestCommon.CreateClient(true, defaultConsistencyLevel: Documents.ConsistencyLevel.Session); string PartitionKey = "/partitionKey"; ContainerResponse response = await this.database.CreateContainerAsync( new ContainerProperties(id : Guid.NewGuid().ToString(), partitionKeyPath : PartitionKey), cancellationToken : this.cancellationToken); Assert.IsNotNull(response); Assert.IsNotNull(response.Container); Assert.IsNotNull(response.Resource); this.Container = (ContainerCore)response; this.jsonSerializer = new CosmosJsonSerializerCore(); }
private static CosmosClientContext GetMockedClientContext( Func <CosmosRequestMessage, CancellationToken, Task <CosmosResponseMessage> > handlerFunc) { CosmosClient client = MockCosmosUtil.CreateMockCosmosClient(); Mock <PartitionRoutingHelper> partitionRoutingHelperMock = MockCosmosUtil.GetPartitionRoutingHelperMock("0"); PartitionKeyRangeHandler partitionKeyRangeHandler = new PartitionKeyRangeHandler(client, partitionRoutingHelperMock.Object); TestHandler testHandler = new TestHandler(handlerFunc); partitionKeyRangeHandler.InnerHandler = testHandler; CosmosRequestHandler handler = client.RequestHandler.InnerHandler; while (handler != null) { if (handler.InnerHandler is RouterHandler) { handler.InnerHandler = new RouterHandler(partitionKeyRangeHandler, testHandler); break; } handler = handler.InnerHandler; } CosmosJsonSerializer cosmosJsonSerializer = new CosmosJsonSerializerCore(); CosmosResponseFactory responseFactory = new CosmosResponseFactory(cosmosJsonSerializer, cosmosJsonSerializer); return(new CosmosClientContextCore( client: client, clientOptions: null, userJsonSerializer: cosmosJsonSerializer, defaultJsonSerializer: cosmosJsonSerializer, cosmosResponseFactory: responseFactory, requestHandler: client.RequestHandler, documentClient: new MockDocumentClient(), documentQueryClient: new Mock <Query.IDocumentQueryClient>().Object)); }
private async Task VerifyItemNullExceptions( dynamic testItem, ItemRequestOptions requestOptions = null) { TestHandler testHandler = new TestHandler((request, cancellationToken) => { Assert.Fail("Null partition key should be blocked without the correct request option"); return null; }); CosmosClient client = MockCosmosUtil.CreateMockCosmosClient( (cosmosClientBuilder) => cosmosClientBuilder.AddCustomHandlers(testHandler)); CosmosContainer container = client.Databases["testdb"] .Containers["testcontainer"]; await Assert.ThrowsExceptionAsync<ArgumentNullException>(async () => { await container.CreateItemAsync<dynamic>( partitionKey: null, item: testItem, requestOptions: requestOptions); }, "CreateItemAsync should throw ArgumentNullException without the correct request option set."); await Assert.ThrowsExceptionAsync<ArgumentNullException>(async () => { await container.ReadItemAsync<dynamic>( partitionKey: null, id: testItem.id, requestOptions: requestOptions); }, "ReadItemAsync should throw ArgumentNullException without the correct request option set."); await Assert.ThrowsExceptionAsync<ArgumentNullException>(async () => { await container.UpsertItemAsync<dynamic>( partitionKey: null, item: testItem, requestOptions: requestOptions); }, "UpsertItemAsync should throw ArgumentNullException without the correct request option set."); await Assert.ThrowsExceptionAsync<ArgumentNullException>(async () => { await container.ReplaceItemAsync<dynamic>( partitionKey: null, id: testItem.id, item: testItem, requestOptions: requestOptions); }, "ReplaceItemAsync should throw ArgumentNullException without the correct request option set."); await Assert.ThrowsExceptionAsync<ArgumentNullException>(async () => { await container.DeleteItemAsync<dynamic>( partitionKey: null, id: testItem.id, requestOptions: requestOptions); }, "DeleteItemAsync should throw ArgumentNullException without the correct request option set."); CosmosJsonSerializerCore jsonSerializer = new CosmosJsonSerializerCore(); using (Stream itemStream = jsonSerializer.ToStream<dynamic>(testItem)) { await Assert.ThrowsExceptionAsync<ArgumentNullException>(async () => { await container.CreateItemAsStreamAsync( partitionKey: null, streamPayload: itemStream, requestOptions: requestOptions); }, "CreateItemAsync should throw ArgumentNullException without the correct request option set."); await Assert.ThrowsExceptionAsync<ArgumentNullException>(async () => { await container.ReadItemAsStreamAsync( partitionKey: null, id: testItem.id, requestOptions: requestOptions); }, "ReadItemAsync should throw ArgumentNullException without the correct request option set."); await Assert.ThrowsExceptionAsync<ArgumentNullException>(async () => { await container.UpsertItemAsStreamAsync( partitionKey: null, streamPayload: itemStream, requestOptions: requestOptions); }, "UpsertItemAsync should throw ArgumentNullException without the correct request option set."); await Assert.ThrowsExceptionAsync<ArgumentNullException>(async () => { await container.ReplaceItemAsStreamAsync( partitionKey: null, id: testItem.id, streamPayload: itemStream, requestOptions: requestOptions); }, "ReplaceItemAsync should throw ArgumentNullException without the correct request option set."); await Assert.ThrowsExceptionAsync<ArgumentNullException>(async () => { await container.DeleteItemAsStreamAsync( partitionKey: null, id: testItem.id, requestOptions: requestOptions); }, "DeleteItemAsync should throw ArgumentNullException without the correct request option set."); } }
private async Task VerifyItemOperations( object partitionKey, string partitionKeySerialized, dynamic testItem, ItemRequestOptions requestOptions = null) { CosmosResponseMessage response = null; HttpStatusCode httpStatusCode = HttpStatusCode.OK; int testHandlerHitCount = 0; TestHandler testHandler = new TestHandler((request, cancellationToken) => { Assert.IsTrue(request.RequestUri.OriginalString.StartsWith(@"/dbs/testdb/colls/testcontainer")); Assert.AreEqual(requestOptions, request.RequestOptions); Assert.AreEqual(ResourceType.Document, request.ResourceType); Assert.IsNotNull(request.Headers.PartitionKey); Assert.AreEqual(partitionKeySerialized, request.Headers.PartitionKey); testHandlerHitCount++; response = new CosmosResponseMessage(httpStatusCode, request, errorMessage: null); response.Content = request.Content; return Task.FromResult(response); }); CosmosClient client = MockCosmosUtil.CreateMockCosmosClient( (builder) => builder.AddCustomHandlers(testHandler)); CosmosContainer container = client.Databases["testdb"] .Containers["testcontainer"]; ItemResponse<dynamic> itemResponse = await container.CreateItemAsync<dynamic>( partitionKey: partitionKey, item: testItem, requestOptions: requestOptions); Assert.IsNotNull(itemResponse); Assert.AreEqual(httpStatusCode, itemResponse.StatusCode); itemResponse = await container.ReadItemAsync<dynamic>( partitionKey: partitionKey, id: testItem.id, requestOptions: requestOptions); Assert.IsNotNull(itemResponse); Assert.AreEqual(httpStatusCode, itemResponse.StatusCode); itemResponse = await container.UpsertItemAsync<dynamic>( partitionKey: partitionKey, item: testItem, requestOptions: requestOptions); Assert.IsNotNull(itemResponse); Assert.AreEqual(httpStatusCode, itemResponse.StatusCode); itemResponse = await container.ReplaceItemAsync<dynamic>( partitionKey: partitionKey, id: testItem.id, item: testItem, requestOptions: requestOptions); Assert.IsNotNull(itemResponse); Assert.AreEqual(httpStatusCode, itemResponse.StatusCode); itemResponse = await container.DeleteItemAsync<dynamic>( partitionKey: partitionKey, id: testItem.id, requestOptions: requestOptions); Assert.IsNotNull(itemResponse); Assert.AreEqual(httpStatusCode, itemResponse.StatusCode); Assert.AreEqual(5, testHandlerHitCount, "An operation did not make it to the handler"); CosmosJsonSerializerCore jsonSerializer = new CosmosJsonSerializerCore(); using (Stream itemStream = jsonSerializer.ToStream<dynamic>(testItem)) { using (CosmosResponseMessage streamResponse = await container.CreateItemAsStreamAsync( partitionKey: partitionKey, streamPayload: itemStream)) { Assert.IsNotNull(streamResponse); Assert.AreEqual(httpStatusCode, streamResponse.StatusCode); } } using (Stream itemStream = jsonSerializer.ToStream<dynamic>(testItem)) { using (CosmosResponseMessage streamResponse = await container.ReadItemAsStreamAsync( partitionKey: partitionKey, id: testItem.id, requestOptions: requestOptions)) { Assert.IsNotNull(streamResponse); Assert.AreEqual(httpStatusCode, streamResponse.StatusCode); } } using (Stream itemStream = jsonSerializer.ToStream<dynamic>(testItem)) { using (CosmosResponseMessage streamResponse = await container.UpsertItemAsStreamAsync( partitionKey: partitionKey, streamPayload: itemStream, requestOptions: requestOptions)) { Assert.IsNotNull(streamResponse); Assert.AreEqual(httpStatusCode, streamResponse.StatusCode); } } using (Stream itemStream = jsonSerializer.ToStream<dynamic>(testItem)) { using (CosmosResponseMessage streamResponse = await container.ReplaceItemAsStreamAsync( partitionKey: partitionKey, id: testItem.id, streamPayload: itemStream, requestOptions: requestOptions)) { Assert.IsNotNull(streamResponse); Assert.AreEqual(httpStatusCode, streamResponse.StatusCode); } } using (Stream itemStream = jsonSerializer.ToStream<dynamic>(testItem)) { using (CosmosResponseMessage streamResponse = await container.DeleteItemAsStreamAsync( partitionKey: partitionKey, id: testItem.id, requestOptions: requestOptions)) { Assert.IsNotNull(streamResponse); Assert.AreEqual(httpStatusCode, streamResponse.StatusCode); } } Assert.AreEqual(10, testHandlerHitCount, "A stream operation did not make it to the handler"); }
public async Task StandByFeedIterator() { int totalCount = 0; string lastcontinuation = string.Empty; int firstRunTotal = 25; int batchSize = 25; Documents.Routing.Range <string> previousRange = null; Documents.Routing.Range <string> currentRange = null; int pkRangesCount = (await this.Container.ClientContext.DocumentClient.ReadPartitionKeyRangeFeedAsync(this.Container.LinkUri)).Count; int visitedPkRanges = 0; await this.CreateRandomItems(batchSize, randomPartitionKey : true); ContainerCore itemsCore = (ContainerCore)this.Container; FeedIterator feedIterator = itemsCore.GetStandByFeedIterator(requestOptions: new ChangeFeedRequestOptions() { StartTime = DateTime.MinValue }); while (feedIterator.HasMoreResults) { using (ResponseMessage responseMessage = await feedIterator.ReadNextAsync(this.cancellationToken)) { lastcontinuation = responseMessage.Headers.Continuation; List <CompositeContinuationToken> deserializedToken = JsonConvert.DeserializeObject <List <CompositeContinuationToken> >(lastcontinuation); currentRange = deserializedToken[0].Range; Assert.AreEqual(pkRangesCount, deserializedToken.Count); if (responseMessage.IsSuccessStatusCode) { Collection <ToDoActivity> response = new CosmosJsonSerializerCore().FromStream <CosmosFeedResponseUtil <ToDoActivity> >(responseMessage.Content).Data; totalCount += response.Count; } if (!currentRange.Equals(previousRange)) { visitedPkRanges++; } if (visitedPkRanges == pkRangesCount && responseMessage.StatusCode == System.Net.HttpStatusCode.NotModified) { break; } previousRange = currentRange; } } Assert.AreEqual(firstRunTotal, totalCount); int expectedFinalCount = 50; previousRange = null; currentRange = null; visitedPkRanges = 0; // Insert another batch of 25 and use the last continuation token from the first cycle await this.CreateRandomItems(batchSize, randomPartitionKey : true); FeedIterator setIteratorNew = itemsCore.GetStandByFeedIterator(lastcontinuation); while (setIteratorNew.HasMoreResults) { using (ResponseMessage responseMessage = await setIteratorNew.ReadNextAsync(this.cancellationToken)) { lastcontinuation = responseMessage.Headers.Continuation; currentRange = JsonConvert.DeserializeObject <List <CompositeContinuationToken> >(lastcontinuation)[0].Range; if (responseMessage.IsSuccessStatusCode) { Collection <ToDoActivity> response = new CosmosJsonSerializerCore().FromStream <CosmosFeedResponseUtil <ToDoActivity> >(responseMessage.Content).Data; totalCount += response.Count; } if (!currentRange.Equals(previousRange)) { visitedPkRanges++; } if (visitedPkRanges == pkRangesCount && responseMessage.StatusCode == System.Net.HttpStatusCode.NotModified) { break; } previousRange = currentRange; } } Assert.AreEqual(expectedFinalCount, totalCount); }
private async Task VerifyItemNullPartitionKeyExpectations( dynamic testItem, ItemRequestOptions requestOptions = null) { TestHandler testHandler = new TestHandler((request, cancellationToken) => { Assert.IsNotNull(request.Headers.PartitionKey); Assert.AreEqual(Documents.Routing.PartitionKeyInternal.Undefined.ToString(), request.Headers.PartitionKey.ToString()); return(Task.FromResult(new CosmosResponseMessage(HttpStatusCode.OK))); }); CosmosClient client = MockCosmosUtil.CreateMockCosmosClient( (cosmosClientBuilder) => cosmosClientBuilder.AddCustomHandlers(testHandler)); CosmosContainer container = client.GetDatabase("testdb") .GetContainer("testcontainer"); await container.CreateItemAsync <dynamic>( item : testItem, requestOptions : requestOptions); await Assert.ThrowsExceptionAsync <ArgumentNullException>(async() => { await container.ReadItemAsync <dynamic>( partitionKey: null, id: testItem.id, requestOptions: requestOptions); }, "ReadItemAsync should throw ArgumentNullException without the correct request option set."); await container.UpsertItemAsync <dynamic>( item : testItem, requestOptions : requestOptions); await container.ReplaceItemAsync <dynamic>( id : testItem.id, item : testItem, requestOptions : requestOptions); await Assert.ThrowsExceptionAsync <ArgumentNullException>(async() => { await container.DeleteItemAsync <dynamic>( partitionKey: null, id: testItem.id, requestOptions: requestOptions); }, "DeleteItemAsync should throw ArgumentNullException without the correct request option set."); CosmosJsonSerializerCore jsonSerializer = new CosmosJsonSerializerCore(); using (Stream itemStream = jsonSerializer.ToStream <dynamic>(testItem)) { await Assert.ThrowsExceptionAsync <ArgumentNullException>(async() => { await container.CreateItemStreamAsync( partitionKey: null, streamPayload: itemStream, requestOptions: requestOptions); }, "CreateItemAsync should throw ArgumentNullException without the correct request option set."); await Assert.ThrowsExceptionAsync <ArgumentNullException>(async() => { await container.ReadItemStreamAsync( partitionKey: null, id: testItem.id, requestOptions: requestOptions); }, "ReadItemAsync should throw ArgumentNullException without the correct request option set."); await Assert.ThrowsExceptionAsync <ArgumentNullException>(async() => { await container.UpsertItemStreamAsync( partitionKey: null, streamPayload: itemStream, requestOptions: requestOptions); }, "UpsertItemAsync should throw ArgumentNullException without the correct request option set."); await Assert.ThrowsExceptionAsync <ArgumentNullException>(async() => { await container.ReplaceItemStreamAsync( partitionKey: null, id: testItem.id, streamPayload: itemStream, requestOptions: requestOptions); }, "ReplaceItemAsync should throw ArgumentNullException without the correct request option set."); await Assert.ThrowsExceptionAsync <ArgumentNullException>(async() => { await container.DeleteItemStreamAsync( partitionKey: null, id: testItem.id, requestOptions: requestOptions); }, "DeleteItemAsync should throw ArgumentNullException without the correct request option set."); } }