Пример #1
0
        /// <iniheritdoc />
        public Task <IExecutionResult> ExecuteAsync(
            IQueryRequest request,
            CancellationToken cancellationToken = default)
        {
            var bufferRequest = BufferedRequest.Create(request, Schema);

            _semaphore.Wait(cancellationToken);

            try
            {
                _bufferedRequests.Add(bufferRequest);

                if (!_taskRegistered)
                {
                    _batchScheduler.Schedule(() => ExecuteRequestsInternal(cancellationToken));
                    _taskRegistered = true;
                }
            }
            finally
            {
                _semaphore.Release();
            }

            return(bufferRequest.Promise.Task);
        }
Пример #2
0
        public async Task Create_BufferedRequest_Rewrite_Variables_To_Literals()
        {
            // arrange
            ISchema schema =
                await new ServiceCollection()
                .AddGraphQL()
                .AddCustomerSchema()
                .BuildSchemaAsync();

            var query = "query abc($id: ID) { customer(id: $id) { name } }";

            IQueryRequest request =
                QueryRequestBuilder.New()
                .SetQuery(query)
                .SetVariableValue("id", 1)
                .Create();

            // act
            var bufferedRequest = BufferedRequest.Create(request, schema);

            // assert
            Assert.NotEqual(request, bufferedRequest.Request);
            Assert.Collection(bufferedRequest.Request.VariableValues !,
                              t => Assert.IsType <StringValueNode>(t.Value));
        }
Пример #3
0
        public async Task Create_BufferedRequest_Operation_Correctly_Resolved()
        {
            // arrange
            ISchema schema =
                await new ServiceCollection()
                .AddGraphQL()
                .AddCustomerSchema()
                .BuildSchemaAsync();

            var query = "query abc($id: ID) { customer(id: $id) { name } } " +
                        "query def($id: ID) { customer(id: $id) { name } }";

            IQueryRequest request =
                QueryRequestBuilder.New()
                .SetQuery(query)
                .SetOperation("def")
                .Create();

            // act
            var bufferedRequest = BufferedRequest.Create(request, schema);

            // assert
            Assert.Equal(request, bufferedRequest.Request);
            Assert.Equal(query, bufferedRequest.Document.ToString(false));
            Assert.Equal(
                bufferedRequest.Document.Definitions.OfType <OperationDefinitionNode>().Last(),
                bufferedRequest.Operation);
            Assert.NotNull(bufferedRequest.Promise);
            Assert.Null(bufferedRequest.Aliases);
        }
Пример #4
0
        public async Task Create_BufferedRequest_With_Mixed_Operations()
        {
            // arrange
            ISchema schema =
                await new ServiceCollection()
                .AddGraphQL()
                .AddCustomerSchema()
                .BuildSchemaAsync();

            var variableNames = new HashSet <string> {
                "id"
            };

            var queryA = "query abc($id: ID) { customer(id: $id) { name } }";
            var queryB = "query abc($id: ID) { customer(id: $id) { id } }";
            var queryC = "mutation { createCustomer(input: { name: \"a\" }) { customer { id } } }";

            IQueryRequest requestA =
                QueryRequestBuilder.New()
                .SetQuery(queryA)
                .SetVariableValue("id", "1")
                .Create();

            IQueryRequest requestB =
                QueryRequestBuilder.New()
                .SetQuery(queryB)
                .SetVariableValue("id", "1")
                .Create();

            IQueryRequest requestC =
                QueryRequestBuilder.New()
                .SetQuery(queryC)
                .Create();

            var bufferedRequestA = BufferedRequest.Create(requestA, schema);
            var bufferedRequestB = BufferedRequest.Create(requestB, schema);
            var bufferedRequestC = BufferedRequest.Create(requestC, schema);

            // act
            IEnumerable <(IQueryRequest, IEnumerable <BufferedRequest>)> mergeResult =
                MergeRequestHelper.MergeRequests(new[]
            {
                bufferedRequestA,
                bufferedRequestB,
                bufferedRequestC
            },
                                                 variableNames);

            // assert
            string.Join(Environment.NewLine + "-------" + Environment.NewLine,
                        mergeResult
                        .Select(t => t.Item1)
                        .Select(t => Utf8GraphQLParser.Parse(t.Query !.AsSpan()).ToString(true)))
            .MatchSnapshot();
        }
        public async Task Merge_Requests_With_Variables_On_Directives()
        {
            // arrange
            ISchema schema =
                await new ServiceCollection()
                .AddGraphQL()
                .AddCustomerSchema()
                .BuildSchemaAsync();

            var queryA =
                @"query abc($id: ID $if: Boolean) {
                    customer(id: $id) {
                        name @include(id: $if)
                    }
                }";

            var queryB =
                @"query abc($id: ID  $if: Boolean) {
                    customer(id: $id) {
                        id @include(id: $if)
                    }
                }";

            IQueryRequest requestA =
                QueryRequestBuilder.New()
                .SetQuery(queryA)
                .SetVariableValue("id", "1")
                .SetVariableValue("if", true)
                .Create();

            IQueryRequest requestB =
                QueryRequestBuilder.New()
                .SetQuery(queryB)
                .SetVariableValue("id", "1")
                .SetVariableValue("if", true)
                .Create();

            var bufferedRequestA = BufferedRequest.Create(requestA, schema);
            var bufferedRequestB = BufferedRequest.Create(requestB, schema);

            // act
            IEnumerable <(IQueryRequest, IEnumerable <BufferedRequest>)> mergeResult =
                MergeRequestHelper.MergeRequests(new[] { bufferedRequestA, bufferedRequestB });

            // assert
            string.Join(Environment.NewLine + "-------" + Environment.NewLine,
                        mergeResult
                        .Select(t => t.Item1)
                        .Select(t => Utf8GraphQLParser.Parse(t.Query !.AsSpan()).ToString(true)))
            .MatchSnapshot();
        }
Пример #6
0
        public void Create_BufferedRequest_Schema_Is_Null()
        {
            // arrange
            var query = "query abc($id: ID) { customer(id: $id) { name } }";

            IQueryRequest request =
                QueryRequestBuilder.New()
                .SetQuery(query)
                .Create();

            // act
            void Action() => BufferedRequest.Create(request, null !);

            // assert
            Assert.Throws <ArgumentNullException>(Action);
        }
Пример #7
0
        public async Task Create_BufferedRequest_Request_Query_Is_Null()
        {
            // arrange
            ISchema schema =
                await new ServiceCollection()
                .AddGraphQL()
                .AddCustomerSchema()
                .BuildSchemaAsync();

            IQueryRequest request =
                QueryRequestBuilder.New()
                .SetQueryId("abc")
                .Create();

            // act
            void Action() => BufferedRequest.Create(request, schema);

            // assert
            Assert.Throws <ArgumentException>(Action);
        }
        public async Task Create_BufferedRequest_AutoGenerated()
        {
            // arrange
            ISchema schema =
                await new ServiceCollection()
                .AddGraphQL()
                .AddCustomerSchema()
                .BuildSchemaAsync();

            var queryA = "query abc($id: ID) { customer(id: $id) { name } }";
            var queryB = "query abc($id: ID) { customer(id: $id) { id } }";

            IQueryRequest requestA =
                QueryRequestBuilder.New()
                .SetQuery(queryA)
                .SetVariableValue("id", "1")
                .SetProperty(WellKnownContextData.IsAutoGenerated, true)
                .Create();

            IQueryRequest requestB =
                QueryRequestBuilder.New()
                .SetQuery(queryB)
                .SetVariableValue("id", "1")
                .SetProperty(WellKnownContextData.IsAutoGenerated, true)
                .Create();

            var bufferedRequestA = BufferedRequest.Create(requestA, schema);
            var bufferedRequestB = BufferedRequest.Create(requestB, schema);

            // act
            IEnumerable <(IQueryRequest, IEnumerable <BufferedRequest>)> mergeResult =
                MergeRequestHelper.MergeRequests(
                    new[] { bufferedRequestA, bufferedRequestB });

            // assert
            string.Join(Environment.NewLine + "-------" + Environment.NewLine,
                        mergeResult
                        .Select(t => t.Item1)
                        .Select(t => Utf8GraphQLParser.Parse(t.Query !.AsSpan()).ToString(true)))
            .MatchSnapshot();
        }