public async Task AllowBatchingRequestsSendsToExecutor_Read() { (ContainerInternal container, Mock <BatchAsyncContainerExecutor> mockedExecutor) = this.CreateMockBulkCosmosClientContext(); dynamic testItem = new { id = Guid.NewGuid().ToString(), pk = "FF627B77-568E-4541-A47E-041EAC10E46F", }; Cosmos.PartitionKey partitionKey = new Cosmos.PartitionKey(testItem.pk); ItemResponse <dynamic> response = await container.ReadItemAsync <dynamic>( id : testItem.id, partitionKey : partitionKey); mockedExecutor.Verify(c => c.AddAsync(It.IsAny <ItemBatchOperation>(), It.IsAny <ItemRequestOptions>(), It.IsAny <CancellationToken>()), Times.Once); }
public async Task ThrowsOnNotFoundReplace() { string itemId = "1"; Cosmos.PartitionKey partitionKey = new Cosmos.PartitionKey("1"); DocumentServiceLeaseCore leaseToUpdate = new DocumentServiceLeaseCore(); Mock <ContainerCore> mockedItems = new Mock <ContainerCore>(); mockedItems.Setup(i => i.ReadItemAsync <DocumentServiceLeaseCore>( It.Is <string>((id) => id == itemId), It.Is <Cosmos.PartitionKey>(pk => pk.Equals(partitionKey)), It.IsAny <ItemRequestOptions>(), It.IsAny <CancellationToken>())) .ReturnsAsync(() => { var itemResponse = new Mock <ItemResponse <DocumentServiceLeaseCore> >(); itemResponse.Setup(i => i.Resource).Returns(leaseToUpdate); return(itemResponse.Object); }); mockedItems.SetupSequence(i => i.ReplaceItemAsync <DocumentServiceLeaseCore>( It.Is <DocumentServiceLeaseCore>((lease) => lease == leaseToUpdate), It.Is <string>((id) => id == itemId), It.Is <Cosmos.PartitionKey>(pk => pk.Equals(partitionKey)), It.IsAny <ItemRequestOptions>(), It.IsAny <CancellationToken>())) .Returns(() => { throw new CosmosException(HttpStatusCode.NotFound, ""); }) .Returns(() => { var itemResponse = new Mock <ItemResponse <DocumentServiceLeaseCore> >(); itemResponse.Setup(i => i.Resource).Returns(leaseToUpdate); return(Task.FromResult(itemResponse.Object)); }); var updater = new DocumentServiceLeaseUpdaterCosmos(DocumentServiceLeaseUpdaterCosmosTests.GetMockedContainer(mockedItems)); var updatedLease = await updater.UpdateLeaseAsync(leaseToUpdate, itemId, partitionKey, serverLease => { serverLease.Owner = "newHost"; return(serverLease); }); }
public async Task <StoredProcedureExecuteResponse <TOutput> > ExecuteStoredProcedureAsync <TOutput>( CosmosDiagnosticsContext diagnosticsContext, string storedProcedureId, Cosmos.PartitionKey partitionKey, dynamic[] parameters, StoredProcedureRequestOptions requestOptions, CancellationToken cancellationToken) { ResponseMessage response = await this.ExecuteStoredProcedureStreamAsync( diagnosticsContext : diagnosticsContext, storedProcedureId : storedProcedureId, partitionKey : partitionKey, parameters : parameters, requestOptions : requestOptions, cancellationToken : cancellationToken); return(this.ClientContext.ResponseFactory.CreateStoredProcedureExecuteResponse <TOutput>(response)); }
public async Task ThrowsOnNotFoundRead() { string itemId = "1"; Cosmos.PartitionKey partitionKey = new Cosmos.PartitionKey("1"); DocumentServiceLeaseCore leaseToUpdate = new DocumentServiceLeaseCore(); Mock <ContainerCore> mockedItems = new Mock <ContainerCore>(); mockedItems.Setup(i => i.ReadItemStreamAsync( It.Is <string>((id) => id == itemId), It.Is <Cosmos.PartitionKey>(pk => pk.Equals(partitionKey)), It.IsAny <ItemRequestOptions>(), It.IsAny <CancellationToken>())) .ReturnsAsync(() => { return(new ResponseMessage(HttpStatusCode.NotFound)); }); mockedItems.SetupSequence(i => i.ReplaceItemStreamAsync( It.IsAny <Stream>(), It.Is <string>((id) => id == itemId), It.Is <Cosmos.PartitionKey>(pk => pk.Equals(partitionKey)), It.IsAny <ItemRequestOptions>(), It.IsAny <CancellationToken>())) .Returns(() => { return(Task.FromResult(new ResponseMessage(HttpStatusCode.PreconditionFailed))); }) .Returns(() => { return(Task.FromResult(new ResponseMessage(HttpStatusCode.OK) { Content = new CosmosJsonDotNetSerializer().ToStream(leaseToUpdate) })); }); var updater = new DocumentServiceLeaseUpdaterCosmos(DocumentServiceLeaseUpdaterCosmosTests.GetMockedContainer(mockedItems)); var updatedLease = await updater.UpdateLeaseAsync(leaseToUpdate, itemId, partitionKey, serverLease => { serverLease.Owner = "newHost"; return(serverLease); }); }
public async Task UpdatesLease() { string itemId = "1"; Cosmos.PartitionKey partitionKey = new Cosmos.PartitionKey("1"); DocumentServiceLeaseCore leaseToUpdate = new DocumentServiceLeaseCore(); Mock <ContainerCore> mockedItems = new Mock <ContainerCore>(); mockedItems.Setup(i => i.ReplaceItemAsync <DocumentServiceLeaseCore>( It.Is <DocumentServiceLeaseCore>((lease) => lease == leaseToUpdate), It.Is <string>((id) => id == itemId), It.Is <Cosmos.PartitionKey>(pk => pk == partitionKey), It.IsAny <ItemRequestOptions>(), It.IsAny <CancellationToken>())) .ReturnsAsync(() => { var itemResponse = new Mock <ItemResponse <DocumentServiceLeaseCore> >(); itemResponse.Setup(i => i.Resource).Returns(leaseToUpdate); return(itemResponse.Object); }); var updater = new DocumentServiceLeaseUpdaterCosmos(DocumentServiceLeaseUpdaterCosmosTests.GetMockedContainer(mockedItems)); var updatedLease = await updater.UpdateLeaseAsync(leaseToUpdate, itemId, partitionKey, serverLease => { serverLease.Owner = "newHost"; return(serverLease); }); Assert.AreEqual("newHost", updatedLease.Owner); Mock.Get(mockedItems.Object) .Verify(items => items.ReplaceItemAsync( It.Is <DocumentServiceLeaseCore>((lease) => lease == leaseToUpdate), It.Is <string>((id) => id == itemId), It.Is <Cosmos.PartitionKey>(pk => pk == partitionKey), It.IsAny <ItemRequestOptions>(), It.IsAny <CancellationToken>()), Times.Once); Mock.Get(mockedItems.Object) .Verify(items => items.ReadItemAsync <DocumentServiceLeaseCore>( It.Is <string>((id) => id == itemId), It.Is <Cosmos.PartitionKey>((pk) => pk == partitionKey), It.IsAny <ItemRequestOptions>(), It.IsAny <CancellationToken>()), Times.Never); }
public override Task <StoredProcedureExecuteResponse <TOutput> > ExecuteStoredProcedureAsync <TInput, TOutput>( Cosmos.PartitionKey partitionKey, string id, TInput input, StoredProcedureRequestOptions requestOptions = null, CancellationToken cancellationToken = default(CancellationToken)) { if (string.IsNullOrEmpty(id)) { throw new ArgumentNullException(nameof(id)); } CosmosContainerCore.ValidatePartitionKey(partitionKey, requestOptions); Stream parametersStream; if (input != null && !input.GetType().IsArray) { parametersStream = this.clientContext.CosmosSerializer.ToStream <TInput[]>(new TInput[1] { input }); } else { parametersStream = this.clientContext.CosmosSerializer.ToStream <TInput>(input); } Uri linkUri = this.clientContext.CreateLink( parentLink: this.container.LinkUri.OriginalString, uriPathSegment: Paths.StoredProceduresPathSegment, id: id); Task <CosmosResponseMessage> response = this.ProcessStreamOperationAsync( resourceUri: linkUri, resourceType: ResourceType.StoredProcedure, operationType: OperationType.ExecuteJavaScript, partitionKey: partitionKey, streamPayload: parametersStream, requestOptions: requestOptions, cancellationToken: cancellationToken); return(this.clientContext.ResponseFactory.CreateStoredProcedureExecuteResponseAsync <TOutput>(response)); }
public async Task DeleteSendsCorrectPayload() { const string expectedId = "something"; Cosmos.PartitionKey partitionKey = new Cosmos.PartitionKey("pk"); Uri expectedRequestUri = new Uri($"/dbs/conflictsDb/colls/conflictsColl/conflicts/{expectedId}", UriKind.Relative); ContainerCore container = CosmosConflictTests.GetMockedContainer((request, cancellationToken) => { Assert.AreEqual(OperationType.Delete, request.OperationType); Assert.AreEqual(ResourceType.Conflict, request.ResourceType); Assert.AreEqual(expectedRequestUri, request.RequestUri); return(TestHandler.ReturnSuccess()); }); ConflictProperties conflictSettings = new ConflictProperties(); conflictSettings.Id = expectedId; await container.Conflicts.DeleteAsync(conflictSettings, partitionKey); }
public async Task AllowBatchingRequestsSendsToExecutor_Delete() { ClientContextCore clientContextCore = this.CreateMockBulkClientContextCore(); DatabaseCore db = new DatabaseCore(clientContextCore, "test"); ExecutorContainerCore container = new ExecutorContainerCore(clientContextCore, db, "test"); dynamic testItem = new { id = Guid.NewGuid().ToString(), pk = "FF627B77-568E-4541-A47E-041EAC10E46F", }; Cosmos.PartitionKey partitionKey = new Cosmos.PartitionKey(testItem.pk); ItemResponse <dynamic> response = await container.DeleteItemAsync <dynamic>( partitionKey : partitionKey, id : testItem.id); container.MockedExecutor.Verify(c => c.AddAsync(It.IsAny <ItemBatchOperation>(), It.IsAny <ItemRequestOptions>(), It.IsAny <CancellationToken>()), Times.Once); }
public async Task ReadCurrentGetsCorrectRID() { const string expectedRID = "something"; Cosmos.PartitionKey partitionKey = new Cosmos.PartitionKey("pk"); // Using "test" as container name because the Mocked DocumentClient has it hardcoded Uri expectedRequestUri = new Uri($"dbs/conflictsDb/colls/test/docs/{expectedRID}", UriKind.Relative); ContainerCore container = CosmosConflictTests.GetMockedContainer((request, cancellationToken) => { Assert.AreEqual(OperationType.Read, request.OperationType); Assert.AreEqual(ResourceType.Document, request.ResourceType); Assert.AreEqual(expectedRequestUri, request.RequestUri); return(TestHandler.ReturnSuccess()); }); ConflictProperties conflictSettings = new ConflictProperties(); conflictSettings.SourceResourceId = expectedRID; await container.Conflicts.ReadCurrentAsync <JObject>(conflictSettings, partitionKey); }
public async Task AllowBatchingRequestsSendsToExecutor_DeleteStream() { (ContainerInternal container, Mock <BatchAsyncContainerExecutor> mockedExecutor) = this.CreateMockBulkCosmosClientContext(); dynamic testItem = new { id = Guid.NewGuid().ToString(), pk = "FF627B77-568E-4541-A47E-041EAC10E46F", }; ItemRequestOptions itemRequestOptions = new ItemRequestOptions(); Cosmos.PartitionKey partitionKey = new Cosmos.PartitionKey(testItem.pk); using (ResponseMessage streamResponse = await container.DeleteItemStreamAsync( partitionKey: partitionKey, id: testItem.id)) { mockedExecutor.Verify(c => c.AddAsync(It.IsAny <ItemBatchOperation>(), It.IsAny <ITrace>(), It.IsAny <ItemRequestOptions>(), It.IsAny <CancellationToken>()), Times.Once); } }
private Task <CosmosResponseMessage> ProcessStreamOperationAsync( Uri resourceUri, ResourceType resourceType, OperationType operationType, Cosmos.PartitionKey partitionKey, Stream streamPayload, RequestOptions requestOptions, CancellationToken cancellationToken) { return(this.clientContext.ProcessResourceOperationStreamAsync( resourceUri: resourceUri, resourceType: resourceType, operationType: operationType, requestOptions: requestOptions, cosmosContainerCore: this.container, partitionKey: partitionKey, streamPayload: streamPayload, requestEnricher: null, cancellationToken: cancellationToken)); }
public override Task <ResponseMessage> ExecuteStoredProcedureStreamAsync( string storedProcedureId, Cosmos.PartitionKey partitionKey, dynamic[] parameters, StoredProcedureRequestOptions requestOptions = null, CancellationToken cancellationToken = default(CancellationToken)) { Stream streamPayload = null; if (parameters != null) { streamPayload = this.clientContext.SerializerCore.ToStream <dynamic[]>(parameters); } return(this.ExecuteStoredProcedureStreamAsync( storedProcedureId: storedProcedureId, partitionKey: partitionKey, streamPayload: streamPayload, requestOptions: requestOptions, cancellationToken: cancellationToken)); }
public void RoundTripTests() { Cosmos.PartitionKey[] partitionKeys = new Cosmos.PartitionKey[] { // None partition key is not serializable. // Cosmos.PartitionKey.None, Cosmos.PartitionKey.Null, new Cosmos.PartitionKey(true), new Cosmos.PartitionKey(false), new Cosmos.PartitionKey(42), new Cosmos.PartitionKey("asdf"), }; foreach (Cosmos.PartitionKey partitionKey in partitionKeys) { string serializedPartitionKey = partitionKey.ToJsonString(); Assert.IsTrue(Cosmos.PartitionKey.TryParseJsonString(serializedPartitionKey, out Cosmos.PartitionKey parsedPartitionKey)); Assert.AreEqual(parsedPartitionKey.ToJsonString(), serializedPartitionKey); } Assert.IsFalse(Cosmos.PartitionKey.TryParseJsonString("Ceci n'est pas une partition key.", out Cosmos.PartitionKey thisNotAPartitionKey)); }
private async Task VerifyPartitionKeyDeleteOperation( Cosmos.PartitionKey partitionKey, string partitionKeySerialized, RequestOptions requestOptions = null) { ResponseMessage 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.PartitionKey, request.ResourceType); Assert.IsNotNull(request.Headers.PartitionKey); Assert.AreEqual(partitionKeySerialized, request.Headers.PartitionKey); testHandlerHitCount++; response = new ResponseMessage(httpStatusCode, request, errorMessage: null) { Content = request.Content }; return(Task.FromResult(response)); }); CosmosClient client = MockCosmosUtil.CreateMockCosmosClient( (builder) => builder.AddCustomHandlers(testHandler)); Container container = client.GetDatabase("testdb") .GetContainer("testcontainer"); ContainerInternal containerInternal = (ContainerInternal)container; ResponseMessage responseMessage = await containerInternal.DeleteAllItemsByPartitionKeyStreamAsync( partitionKey : partitionKey, requestOptions : requestOptions); Assert.IsNotNull(responseMessage); Assert.AreEqual(httpStatusCode, responseMessage.StatusCode); Assert.AreEqual(1, testHandlerHitCount, "The operation did not make it to the handler"); }
public async Task AllowBatchingRequestsSendsToExecutor_ReplaceStream() { ClientContextCore clientContextCore = new ClientContextCore( MockCosmosUtil.CreateMockCosmosClient(), new CosmosClientOptions() { AllowBulkExecution = true }, new CosmosJsonDotNetSerializer(), new CosmosJsonDotNetSerializer(), new CosmosJsonDotNetSerializer(), null, null, new MockDocumentClient() ); DatabaseCore db = new DatabaseCore(clientContextCore, "test"); ExecutorContainerCore container = new ExecutorContainerCore(clientContextCore, db, "test"); dynamic testItem = new { id = Guid.NewGuid().ToString(), pk = "FF627B77-568E-4541-A47E-041EAC10E46F", }; using (Stream itemStream = MockCosmosUtil.Serializer.ToStream <dynamic>(testItem)) { ItemRequestOptions itemRequestOptions = new ItemRequestOptions(); Cosmos.PartitionKey partitionKey = new Cosmos.PartitionKey(testItem.pk); using (ResponseMessage streamResponse = await container.ReplaceItemStreamAsync( partitionKey: partitionKey, id: testItem.id, streamPayload: itemStream)) { container.MockedExecutor.Verify(c => c.AddAsync(It.IsAny <ItemBatchOperation>(), It.IsAny <ItemRequestOptions>(), It.IsAny <CancellationToken>()), Times.Once); } } }
public Task <ResponseMessage> ExecuteStoredProcedureStreamAsync( CosmosDiagnosticsContext diagnosticsContext, string storedProcedureId, Cosmos.PartitionKey partitionKey, dynamic[] parameters, StoredProcedureRequestOptions requestOptions, CancellationToken cancellationToken) { Stream streamPayload = null; if (parameters != null) { streamPayload = this.ClientContext.SerializerCore.ToStream <dynamic[]>(parameters); } return(this.ExecuteStoredProcedureStreamAsync( diagnosticsContext: diagnosticsContext, storedProcedureId: storedProcedureId, partitionKey: partitionKey, streamPayload: streamPayload, requestOptions: requestOptions, cancellationToken: cancellationToken)); }
internal PassThroughQueryTestInput( string description, string query, SqlQuerySpec sqlQuerySpec, bool expectedPassThrough, string partitionKeyPath, Cosmos.PartitionKey partitionKeyValue) : base(description) { this.PartitionKeyDefinition = new PartitionKeyDefinition() { Paths = new Collection <string>() { partitionKeyPath }, Kind = PartitionKind.Hash, Version = PartitionKeyDefinitionVersion.V2, }; this.SqlQuerySpec = sqlQuerySpec; this.ExpectedPassThrough = expectedPassThrough; this.Query = query; this.PartitionKeyValue = partitionKeyValue; }
private async Task <DocumentServiceLeaseCore> TryReplaceLeaseAsync( DocumentServiceLeaseCore lease, Cosmos.PartitionKey partitionKey, string itemId) { try { ItemRequestOptions itemRequestOptions = this.CreateIfMatchOptions(lease); ItemResponse <DocumentServiceLeaseCore> response = await this.container.ReplaceItemAsync <DocumentServiceLeaseCore>( id : itemId, item : lease, partitionKey : partitionKey, requestOptions : itemRequestOptions).ConfigureAwait(false); if (response.StatusCode == HttpStatusCode.NotFound) { throw new LeaseLostException(lease, true); } return(response.Resource); } catch (CosmosException ex) { DefaultTrace.TraceWarning("Lease operation exception, status code: {0}", ex.StatusCode); if (ex.StatusCode == HttpStatusCode.PreconditionFailed) { return(null); } if (ex.StatusCode == HttpStatusCode.Conflict) { throw new LeaseLostException(lease, ex, false); } throw; } }
public async Task ThrowsAfterMaxRetries() { string itemId = "1"; Cosmos.PartitionKey partitionKey = new Cosmos.PartitionKey("1"); DocumentServiceLeaseCore leaseToUpdate = new DocumentServiceLeaseCore(); Mock <CosmosContainerCore> mockedItems = new Mock <CosmosContainerCore>(); mockedItems.Setup(i => i.ReadItemAsync <DocumentServiceLeaseCore>( It.Is <Cosmos.PartitionKey>(pk => pk == partitionKey), It.Is <string>((id) => id == itemId), It.IsAny <ItemRequestOptions>(), It.IsAny <CancellationToken>())) .ReturnsAsync(() => { var itemResponse = new Mock <ItemResponse <DocumentServiceLeaseCore> >(); itemResponse.Setup(i => i.Resource).Returns(leaseToUpdate); return(itemResponse.Object); }); mockedItems.Setup(i => i.ReplaceItemAsync <DocumentServiceLeaseCore>( It.Is <string>((id) => id == itemId), It.Is <DocumentServiceLeaseCore>((lease) => lease == leaseToUpdate), It.Is <Cosmos.PartitionKey>(pk => pk == partitionKey), It.IsAny <ItemRequestOptions>(), It.IsAny <CancellationToken>())) .Throws(new CosmosException(string.Empty, HttpStatusCode.PreconditionFailed, 0, string.Empty, 0)); var updater = new DocumentServiceLeaseUpdaterCosmos(DocumentServiceLeaseUpdaterCosmosTests.GetMockedContainer(mockedItems)); var updatedLease = await updater.UpdateLeaseAsync(leaseToUpdate, itemId, partitionKey, serverLease => { serverLease.Owner = "newHost"; return(serverLease); }); }
public abstract Task <ResponseMessage> DeleteAllItemsByPartitionKeyStreamAsync( Cosmos.PartitionKey partitionKey, RequestOptions requestOptions = null, CancellationToken cancellationToken = default(CancellationToken));
private async Task VerifyItemOperations( Cosmos.PartitionKey partitionKey, string partitionKeySerialized, dynamic testItem, ItemRequestOptions requestOptions = null) { ResponseMessage 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 ResponseMessage(httpStatusCode, request, errorMessage: null) { Content = request.Content }; return(Task.FromResult(response)); }); using CosmosClient client = MockCosmosUtil.CreateMockCosmosClient( (builder) => builder.AddCustomHandlers(testHandler)); Container container = client.GetDatabase("testdb") .GetContainer("testcontainer"); ItemResponse <dynamic> itemResponse = await container.CreateItemAsync <dynamic>( 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>( item : testItem, requestOptions : requestOptions); Assert.IsNotNull(itemResponse); Assert.AreEqual(httpStatusCode, itemResponse.StatusCode); itemResponse = await container.ReplaceItemAsync <dynamic>( 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"); using (Stream itemStream = MockCosmosUtil.Serializer.ToStream <dynamic>(testItem)) { using (ResponseMessage streamResponse = await container.CreateItemStreamAsync( partitionKey: partitionKey, streamPayload: itemStream, requestOptions: requestOptions)) { Assert.IsNotNull(streamResponse); Assert.AreEqual(httpStatusCode, streamResponse.StatusCode); } } using (Stream itemStream = MockCosmosUtil.Serializer.ToStream <dynamic>(testItem)) { using (ResponseMessage streamResponse = await container.ReadItemStreamAsync( partitionKey: partitionKey, id: testItem.id, requestOptions: requestOptions)) { Assert.IsNotNull(streamResponse); Assert.AreEqual(httpStatusCode, streamResponse.StatusCode); } } using (Stream itemStream = MockCosmosUtil.Serializer.ToStream <dynamic>(testItem)) { using (ResponseMessage streamResponse = await container.UpsertItemStreamAsync( partitionKey: partitionKey, streamPayload: itemStream, requestOptions: requestOptions)) { Assert.IsNotNull(streamResponse); Assert.AreEqual(httpStatusCode, streamResponse.StatusCode); } } using (Stream itemStream = MockCosmosUtil.Serializer.ToStream <dynamic>(testItem)) { using (ResponseMessage streamResponse = await container.ReplaceItemStreamAsync( partitionKey: partitionKey, id: testItem.id, streamPayload: itemStream, requestOptions: requestOptions)) { Assert.IsNotNull(streamResponse); Assert.AreEqual(httpStatusCode, streamResponse.StatusCode); } } using (Stream itemStream = MockCosmosUtil.Serializer.ToStream <dynamic>(testItem)) { using (ResponseMessage streamResponse = await container.DeleteItemStreamAsync( 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 TestMultipleNestedPartitionKeyValueFromStreamAsync() { ContainerInternal originalContainer = (ContainerInternal)MockCosmosUtil.CreateMockCosmosClient().GetContainer("TestDb", "Test"); Mock <ContainerCore> mockedContainer = new Mock <ContainerCore>( originalContainer.ClientContext, (DatabaseInternal)originalContainer.Database, originalContainer.Id, null) { CallBase = true }; mockedContainer.Setup(e => e.GetPartitionKeyPathTokensAsync(It.IsAny <ITrace>(), It.IsAny <CancellationToken>())) .Returns(Task.FromResult((IReadOnlyList <IReadOnlyList <string> >) new List <IReadOnlyList <string> > { new List <string> { "a", "b", "c" }, new List <string> { "a", "e", "f" } })); ContainerInternal containerWithMockPartitionKeyPath = mockedContainer.Object; List <dynamic> validNestedItems = new List <dynamic> { ( new // a/b/c (Specify only one partition key) { id = Guid.NewGuid().ToString(), a = new { b = new { c = 10, } } }, "[10.0,{}]" ), ( new // { id = Guid.NewGuid().ToString(), a = new { b = new { c = 10, }, e = new { f = 15, } } }, "[10.0,15.0]" ), ( new { id = Guid.NewGuid().ToString(), a = new { b = new { c = 10, }, e = new { f = default(string), //null } } }, "[10.0,null]" ), ( new { id = Guid.NewGuid().ToString(), a = new { e = new { f = 10, } } }, "[{},10.0]" ), ( new { id = Guid.NewGuid().ToString(), a = new { e = 10, b = new { k = 10, } } }, "[{},{}]" ) }; foreach (dynamic poco in validNestedItems) { Cosmos.PartitionKey pk = await containerWithMockPartitionKeyPath.GetPartitionKeyValueFromStreamAsync( MockCosmosUtil.Serializer.ToStream(poco.Item1), NoOpTrace.Singleton, default(CancellationToken)); string partitionKeyString = pk.InternalKey.ToJsonString(); Assert.AreEqual(poco.Item2, partitionKeyString); } }
private async Task <(Container, IReadOnlyList <CosmosObject>)> CreateContainerAndIngestDocumentsAsync( CollectionTypes collectionType, IEnumerable <string> documents, string partitionKey = "/id", Cosmos.IndexingPolicy indexingPolicy = null) { Container container = collectionType switch { CollectionTypes.NonPartitioned => await this.CreateNonPartitionedContainerAsync(indexingPolicy), CollectionTypes.SinglePartition => await this.CreateSinglePartitionContainer(partitionKey, indexingPolicy), CollectionTypes.MultiPartition => await this.CreateMultiPartitionContainer(partitionKey, indexingPolicy), _ => throw new ArgumentException($"Unknown {nameof(CollectionTypes)} : {collectionType}"), }; List <CosmosObject> insertedDocuments = new List <CosmosObject>(); foreach (string document in documents) { JObject documentObject = JsonConvert.DeserializeObject <JObject>(document); // Add an id if (documentObject["id"] == null) { documentObject["id"] = Guid.NewGuid().ToString(); } // Get partition key value. Cosmos.PartitionKey pkValue; if (partitionKey != null) { string jObjectPartitionKey = partitionKey.Remove(0, 1); JValue pkToken = (JValue)documentObject[jObjectPartitionKey]; if (pkToken == null) { pkValue = Cosmos.PartitionKey.None; } else { switch (pkToken.Type) { case JTokenType.Integer: case JTokenType.Float: pkValue = new Cosmos.PartitionKey(pkToken.Value <double>()); break; case JTokenType.String: pkValue = new Cosmos.PartitionKey(pkToken.Value <string>()); break; case JTokenType.Boolean: pkValue = new Cosmos.PartitionKey(pkToken.Value <bool>()); break; case JTokenType.Null: pkValue = Cosmos.PartitionKey.Null; break; default: throw new ArgumentException("Unknown partition key type"); } } } else { pkValue = Cosmos.PartitionKey.None; } JObject createdDocument = await container.CreateItemAsync(documentObject, pkValue); CosmosObject insertedDocument = CosmosObject.Parse <CosmosObject>(createdDocument.ToString()); insertedDocuments.Add(insertedDocument); } return(container, insertedDocuments); }