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