private static CosmosClientContext GetMockedClientContext(
Func <RequestMessage, CancellationToken, Task <ResponseMessage> > 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;
RequestHandler handler = client.RequestHandler.InnerHandler;
while (handler != null)
{
if (handler.InnerHandler is RouterHandler)
{
handler.InnerHandler = new RouterHandler(partitionKeyRangeHandler, testHandler);
break;
}
handler = handler.InnerHandler;
}
CosmosResponseFactory responseFactory = new CosmosResponseFactory(MockCosmosUtil.Serializer);
return(new ClientContextCore(
client: client,
clientOptions: new CosmosClientOptions(),
serializerCore: MockCosmosUtil.Serializer,
cosmosResponseFactory: responseFactory,
requestHandler: client.RequestHandler,
documentClient: new MockDocumentClient()));
}
public CosmosLinqQuery(
ContainerCore container,
CosmosResponseFactory responseFactory,
CosmosQueryClientCore queryClient,
string continuationToken,
QueryRequestOptions cosmosQueryRequestOptions,
Expression expression,
bool allowSynchronousQueryExecution,
CosmosSerializationOptions serializationOptions = null)
{
this.container = container ?? throw new ArgumentNullException(nameof(container));
this.responseFactory = responseFactory ?? throw new ArgumentNullException(nameof(responseFactory));
this.queryClient = queryClient ?? throw new ArgumentNullException(nameof(queryClient));
this.continuationToken = continuationToken;
this.cosmosQueryRequestOptions = cosmosQueryRequestOptions;
this.Expression = expression ?? Expression.Constant(this);
this.allowSynchronousQueryExecution = allowSynchronousQueryExecution;
this.correlatedActivityId = Guid.NewGuid();
this.serializationOptions = serializationOptions;
this.queryProvider = new CosmosLinqQueryProvider(
container,
responseFactory,
queryClient,
this.continuationToken,
cosmosQueryRequestOptions,
this.allowSynchronousQueryExecution,
this.queryClient.OnExecuteScalarQueryCallback,
this.serializationOptions);
}
/// <summary>
/// All the operations / requests for exercising client-side encryption functionality need to be made using this EncryptionContainer instance.
/// </summary>
/// <param name="container">Regular cosmos container.</param>
/// <param name="encryptor">Provider that allows encrypting and decrypting data.</param>
/// <param name="toEncrypt">Dictionary of List of paths and their corresponding key for property encryption</param>
public EncryptionContainer(
Container container,
Encryptor encryptor,
IReadOnlyDictionary <List <string>, string> toEncrypt = null)
{
this.container = container ?? throw new ArgumentNullException(nameof(container));
this.Encryptor = encryptor ?? throw new ArgumentNullException(nameof(encryptor));
this.pathsToEncrypt = toEncrypt;
this.ResponseFactory = this.Database.Client.ResponseFactory;
this.cosmosSerializer = this.Database.Client.ClientOptions.Serializer;
if (toEncrypt != null)
{
List <EncryptionOptions> propertyEncryptionOptions = new List <EncryptionOptions>();
foreach (KeyValuePair <List <string>, string> entry in toEncrypt)
{
propertyEncryptionOptions.Add(
new EncryptionOptions()
{
DataEncryptionKeyId = entry.Value,
EncryptionAlgorithm = CosmosEncryptionAlgorithm.AEAD_AES_256_CBC_HMAC_SHA256,
PathsToEncrypt = entry.Key,
});
}
this.propertyEncryptionOptions = propertyEncryptionOptions;
}
}
/// <summary>
/// All the operations / requests for exercising client-side encryption functionality need to be made using this EncryptionContainer instance.
/// </summary>
/// <param name="container">Regular cosmos container.</param>
/// <param name="encryptor">Provider that allows encrypting and decrypting data.</param>
public EncryptionContainer(
Container container,
Encryptor encryptor)
{
this.container = container ?? throw new ArgumentNullException(nameof(container));
this.encryptor = encryptor ?? throw new ArgumentNullException(nameof(encryptor));
this.responseFactory = this.Database.Client.ResponseFactory;
this.cosmosSerializer = this.Database.Client.ClientOptions.Serializer;
}
public EncryptionFeedIterator(
EncryptionFeedIterator feedIterator,
CosmosResponseFactory responseFactory)
{
if (!(feedIterator is EncryptionFeedIterator))
{
throw new ArgumentOutOfRangeException($"{nameof(feedIterator)} must be of type {nameof(EncryptionFeedIterator)}.");
}
this.feedIterator = feedIterator;
this.responseFactory = responseFactory;
}
public EncryptionFeedIterator(
EncryptionFeedIterator feedIterator,
CosmosResponseFactory responseFactory)
{
this.feedIterator = feedIterator ?? throw new ArgumentNullException(nameof(feedIterator));
if (feedIterator is not EncryptionFeedIterator)
{
throw new ArgumentOutOfRangeException($"{nameof(feedIterator)} must be of type {nameof(EncryptionFeedIterator)}. ");
}
this.responseFactory = responseFactory ?? throw new ArgumentNullException(nameof(responseFactory));
}
public CosmosLinqQuery(
ContainerCore container,
CosmosResponseFactory responseFactory,
CosmosQueryClientCore queryClient,
string continuationToken,
QueryRequestOptions cosmosQueryRequestOptions,
bool allowSynchronousQueryExecution)
: this(
container,
responseFactory,
queryClient,
continuationToken,
cosmosQueryRequestOptions,
null,
allowSynchronousQueryExecution)
{
}
public CosmosLinqQueryProvider(
ContainerCore container,
CosmosResponseFactory responseFactory,
CosmosQueryClientCore queryClient,
string continuationToken,
QueryRequestOptions cosmosQueryRequestOptions,
bool allowSynchronousQueryExecution,
Action <IQueryable> onExecuteScalarQueryCallback = null)
{
this.container = container;
this.responseFactory = responseFactory;
this.queryClient = queryClient;
this.continuationToken = continuationToken;
this.cosmosQueryRequestOptions = cosmosQueryRequestOptions;
this.allowSynchronousQueryExecution = allowSynchronousQueryExecution;
this.onExecuteScalarQueryCallback = onExecuteScalarQueryCallback;
}
private static CosmosClientContext GetMockedClientContext(
Func <RequestMessage, CancellationToken, Task <ResponseMessage> > handlerFunc)
{
CosmosClient client = MockCosmosUtil.CreateMockCosmosClient();
Mock <PartitionRoutingHelper> partitionRoutingHelperMock = MockCosmosUtil.GetPartitionRoutingHelperMock("0");
TestHandler testHandler = new TestHandler(handlerFunc);
// Similar to FeedPipeline but with replaced transport
RequestHandler[] feedPipeline = new RequestHandler[]
{
new NamedCacheRetryHandler(),
new PartitionKeyRangeHandler(client),
testHandler,
};
RequestHandler feedHandler = ClientPipelineBuilder.CreatePipeline(feedPipeline);
RequestHandler handler = client.RequestHandler.InnerHandler;
while (handler != null)
{
if (handler.InnerHandler is RouterHandler)
{
handler.InnerHandler = new RouterHandler(feedHandler, testHandler);
break;
}
handler = handler.InnerHandler;
}
CosmosResponseFactory responseFactory = new CosmosResponseFactory(MockCosmosUtil.Serializer);
return(new ClientContextCore(
client: client,
clientOptions: new CosmosClientOptions(),
serializerCore: MockCosmosUtil.Serializer,
cosmosResponseFactory: responseFactory,
requestHandler: client.RequestHandler,
documentClient: new MockDocumentClient(),
userAgent: null));
}
public CosmosLinqQuery(
ContainerInternal container,
CosmosResponseFactory responseFactory,
CosmosQueryClientCore queryClient,
string continuationToken,
QueryRequestOptions cosmosQueryRequestOptions,
bool allowSynchronousQueryExecution,
CosmosSerializationOptions serializationOptions = null)
: this(
container,
responseFactory,
queryClient,
continuationToken,
cosmosQueryRequestOptions,
null,
allowSynchronousQueryExecution,
serializationOptions)
{
}
public async Task ValidateResponseFactoryJsonSerializer()
{
ResponseMessage databaseResponse = this.CreateResponse();
ResponseMessage containerResponse = this.CreateResponse();
ResponseMessage storedProcedureExecuteResponse = this.CreateResponse();
ResponseMessage storedProcedureResponse = this.CreateResponse();
ResponseMessage triggerResponse = this.CreateResponse();
ResponseMessage udfResponse = this.CreateResponse();
ResponseMessage itemResponse = this.CreateResponse();
ResponseMessage feedResponse = this.CreateResponse();
Mock <CosmosSerializer> mockUserJsonSerializer = new Mock <CosmosSerializer>();
Mock <CosmosSerializer> mockDefaultJsonSerializer = new Mock <CosmosSerializer>();
CosmosResponseFactory cosmosResponseFactory = new CosmosResponseFactory(
defaultJsonSerializer: mockDefaultJsonSerializer.Object,
userJsonSerializer: mockUserJsonSerializer.Object);
// Test the user specified response
mockUserJsonSerializer.Setup(x => x.FromStream <ToDoActivity>(itemResponse.Content)).Returns(new ToDoActivity());
mockUserJsonSerializer.Setup(x => x.FromStream <ToDoActivity>(storedProcedureExecuteResponse.Content)).Returns(new ToDoActivity());
mockUserJsonSerializer.Setup(x => x.FromStream <CosmosFeedResponseUtil <ToDoActivity> >(feedResponse.Content)).Returns(new CosmosFeedResponseUtil <ToDoActivity>()
{
Data = new Collection <ToDoActivity>()
});
// Verify all the user types use the user specified version
await cosmosResponseFactory.CreateItemResponseAsync <ToDoActivity>(Task.FromResult(itemResponse));
await cosmosResponseFactory.CreateStoredProcedureExecuteResponseAsync <ToDoActivity>(Task.FromResult(storedProcedureExecuteResponse));
cosmosResponseFactory.CreateResultSetQueryResponse <ToDoActivity>(feedResponse);
// Throw if the setups were not called
mockUserJsonSerializer.VerifyAll();
// Test the system specified response
ContainerProperties containerSettings = new ContainerProperties("mockId", "/pk");
DatabaseProperties databaseSettings = new DatabaseProperties()
{
Id = "mock"
};
StoredProcedureProperties cosmosStoredProcedureSettings = new StoredProcedureProperties()
{
Id = "mock"
};
TriggerProperties cosmosTriggerSettings = new TriggerProperties()
{
Id = "mock"
};
UserDefinedFunctionProperties cosmosUserDefinedFunctionSettings = new UserDefinedFunctionProperties()
{
Id = "mock"
};
mockDefaultJsonSerializer.Setup(x => x.FromStream <DatabaseProperties>(databaseResponse.Content)).Returns(databaseSettings);
mockDefaultJsonSerializer.Setup(x => x.FromStream <ContainerProperties>(containerResponse.Content)).Returns(containerSettings);
mockDefaultJsonSerializer.Setup(x => x.FromStream <StoredProcedureProperties>(storedProcedureResponse.Content)).Returns(cosmosStoredProcedureSettings);
mockDefaultJsonSerializer.Setup(x => x.FromStream <TriggerProperties>(triggerResponse.Content)).Returns(cosmosTriggerSettings);
mockDefaultJsonSerializer.Setup(x => x.FromStream <UserDefinedFunctionProperties>(udfResponse.Content)).Returns(cosmosUserDefinedFunctionSettings);
Mock <Container> mockContainer = new Mock <Container>();
Mock <Database> mockDatabase = new Mock <Database>();
// Verify all the system types that should always use default
await cosmosResponseFactory.CreateContainerResponseAsync(mockContainer.Object, Task.FromResult(containerResponse));
await cosmosResponseFactory.CreateDatabaseResponseAsync(mockDatabase.Object, Task.FromResult(databaseResponse));
await cosmosResponseFactory.CreateStoredProcedureResponseAsync(Task.FromResult(storedProcedureResponse));
await cosmosResponseFactory.CreateTriggerResponseAsync(Task.FromResult(triggerResponse));
await cosmosResponseFactory.CreateUserDefinedFunctionResponseAsync(Task.FromResult(udfResponse));
// Throw if the setups were not called
mockDefaultJsonSerializer.VerifyAll();
}
