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