public async Task InterServiceExecuteNullEventSender()
        {
            // Setup: Create a query service, and execute params
            var qes           = new QueryExecutionService(null, null);
            var executeParams = new ExecuteStringParams();

            // If: I call the inter-service API to execute a query with a a null event sender
            // Then: It should throw
            await Assert.ThrowsAsync <ArgumentNullException>(
                () => qes.InterServiceExecuteQuery(executeParams, null, null, null, null, null, null));
        }
        public async Task InterServiceExecuteNullExecuteParams()
        {
            // Setup: Create a query service
            var qes         = new QueryExecutionService(null, null);
            var eventSender = new EventFlowValidator <ExecuteRequestResult>().Complete().Object;


            // If: I call the inter-service API to execute with a null execute params
            // Then: It should throw
            await Assert.ThrowsAsync <ArgumentNullException>(
                () => qes.InterServiceExecuteQuery(null, null, eventSender, null, null, null, null));
        }
        public async Task InterServiceExecuteNullFailureFunc()
        {
            // Setup: Create a query service, and execute params
            var qes = new QueryExecutionService(null, null);
            var executeParams = new ExecuteStringParams();
            var eventSender = new EventFlowValidator<ExecuteRequestResult>().Complete().Object;
            Func<Task> successFunc = () => Task.FromResult(0);

            // If: I call the inter-service API to execute a query with a a null failure function
            // Then: It should throw
            await Assert.ThrowsAsync<ArgumentNullException>(
                () => qes.InterServiceExecuteQuery(executeParams, eventSender, successFunc, null));
        }
示例#4
0
        private async Task <EditSession.EditSessionQueryExecutionState> SessionInitializeQueryRunner(string ownerUri,
                                                                                                     IEventSender eventSender, string query)
        {
            // Open a task completion source, effectively creating a synchronous block
            TaskCompletionSource <EditSession.EditSessionQueryExecutionState> taskCompletion =
                new TaskCompletionSource <EditSession.EditSessionQueryExecutionState>();

            // Setup callback for successful query creation
            // NOTE: We do not want to set the task completion source, since we will continue executing the query after
            Func <Query, Task <bool> > queryCreateSuccessCallback = q => Task.FromResult(true);

            // Setup callback for failed query creation
            Func <string, Task> queryCreateFailureCallback = m =>
            {
                taskCompletion.SetResult(new EditSession.EditSessionQueryExecutionState(null, m));
                return(Task.FromResult(0));
            };

            // Setup callback for successful query execution
            Query.QueryAsyncEventHandler queryCompleteSuccessCallback = q =>
            {
                taskCompletion.SetResult(new EditSession.EditSessionQueryExecutionState(q));
                return(Task.FromResult(0));
            };

            // Setup callback for failed query execution
            Query.QueryAsyncErrorEventHandler queryCompleteFailureCallback = (q, e) =>
            {
                taskCompletion.SetResult(new EditSession.EditSessionQueryExecutionState(null));
                return(Task.FromResult(0));
            };

            // Execute the query
            ExecuteStringParams executeParams = new ExecuteStringParams
            {
                Query = query,
                GetFullColumnSchema = true,
                OwnerUri            = ownerUri
            };
            await queryExecutionService.InterServiceExecuteQuery(executeParams, null, eventSender,
                                                                 queryCreateSuccessCallback, queryCreateFailureCallback,
                                                                 queryCompleteSuccessCallback, queryCompleteFailureCallback);

            // Wait for the completion source to complete, this will wait until the query has
            // completed and sent all its events.
            return(await taskCompletion.Task);
        }