protected async Task <IBatchQueryResult> ExecuteBatchAsync( HttpContext context, IRequestExecutor requestExecutor, IHttpRequestInterceptor requestInterceptor, IReadOnlyList <GraphQLRequest> requests) { var requestBatch = new IReadOnlyQueryRequest[requests.Count]; for (var i = 0; i < requests.Count; i++) { QueryRequestBuilder requestBuilder = QueryRequestBuilder.From(requests[i]); await requestInterceptor.OnCreateAsync( context, requestExecutor, requestBuilder, context.RequestAborted); requestBatch[i] = requestBuilder.Create(); } return(await requestExecutor.ExecuteBatchAsync( requestBatch, cancellationToken : context.RequestAborted)); }
public async Task Create_Boolean_OrderBy_Nullable() { // arrange IRequestExecutor tester = _cache.CreateSchema <FooNullable, FooNullableSortType>( _fooNullableEntities); // act IExecutionResult res1 = await tester.ExecuteAsync( QueryRequestBuilder.New() .SetQuery("{ rootExecutable(order: { bar: ASC}){ bar}}") .Create()); IExecutionResult res2 = await tester.ExecuteAsync( QueryRequestBuilder.New() .SetQuery("{ rootExecutable(order: { bar: DESC}){ bar}}") .Create()); // assert res1.MatchSnapshot("ASC"); res2.MatchSnapshot("DESC"); }
public async Task Create_BooleanNotEqual_Expression() { // arrange IRequestExecutor?tester = _cache.CreateSchema <Foo, FooFilterInput>(_fooEntities); // act // assert IExecutionResult?res1 = await tester.ExecuteAsync( QueryRequestBuilder.New() .SetQuery("{ root(where: { bar: { neq: true}}){ bar}}") .Create()); res1.MatchSnapshot("true"); IExecutionResult?res2 = await tester.ExecuteAsync( QueryRequestBuilder.New() .SetQuery("{ root(where: { bar: { neq: false}}){ bar}}") .Create()); res2.MatchSnapshot("false"); }
public async Task GetItems_DescSorting_AllItems_Are_Returned_DescSorted() { // arrange var serviceCollection = new ServiceCollection(); serviceCollection.AddSingleton(sp => { IMongoDatabase database = _mongoResource.CreateDatabase(); IMongoCollection <Model> collection = database.GetCollection <Model>("col"); collection.InsertMany(new[] { new Model { Foo = "abc", Bar = 1, Baz = true }, new Model { Foo = "def", Bar = 2, Baz = false }, }); return(collection); }); ISchema schema = SchemaBuilder.New() .AddQueryType <QueryType>() .AddServices(serviceCollection.BuildServiceProvider()) .Create(); IQueryExecutor executor = schema.MakeExecutable(); IReadOnlyQueryRequest request = QueryRequestBuilder.New() .SetQuery("{ items(order_by: { foo: DESC }) { foo } }") .Create(); // act IExecutionResult result = await executor.ExecuteAsync(request); // assert Assert.Empty(result.Errors); result.MatchSnapshot(); }
public async Task Custom_Scalar_Delegated_Input_Argument() { // arrange IHttpClientFactory clientFactory = CreateRemoteSchemas(); var serviceCollection = new ServiceCollection(); serviceCollection.AddSingleton(clientFactory); serviceCollection.AddStitchedSchema(builder => builder .AddSchemaFromHttp("special") .AddExtensionsFromString("extend type Query { custom_scalar_complex_stitched(bar: CustomInputValueInput): MyCustomScalarValue @delegate(schema: \"special\", path: \"custom_scalar_complex(bar: $arguments:bar)\") }") .AddSchemaConfiguration(c => { c.RegisterType <MyCustomScalarType>(); })); IServiceProvider services = serviceCollection.BuildServiceProvider(); IQueryExecutor executor = services .GetRequiredService <IQueryExecutor>(); IExecutionResult result = null; // act using (IServiceScope scope = services.CreateScope()) { IReadOnlyQueryRequest request = QueryRequestBuilder.New() .SetQuery("query ($bar: CustomInputValueInput) { custom_scalar_complex_stitched(bar: $bar) }") .SetVariableValue("bar", new Dictionary <string, object> { { "from", "2019-11-11" }, { "to", "2019-11-17" } }) .SetServices(scope.ServiceProvider) .Create(); result = await executor.ExecuteAsync(request); } // assert result.MatchSnapshot(); }
public void TestSchema() { IRequestExecutor executor = MakeExecutor(); IServiceProvider serviceProvider = BuildServiceProvider(); IReadOnlyQueryRequest request = QueryRequestBuilder.New() .SetQuery(@"{ projects { id evaluations { id participants { id } questions { id answers { id } actions { id notes { id } } } } } }") .SetServices(serviceProvider) .Create(); IExecutionResult result = executor.Execute(request); IReadOnlyList <IError> errors = result.Errors ?? new List <IError>(); foreach (IError err in errors) { throw err.Exception; } }
public async Task DateTimeType_GreaterThan_Filter() { // arrange var serviceCollection = new ServiceCollection(); IServiceProvider services = new ServiceCollection() .AddSingleton <IMongoCollection <Model> >(sp => { IMongoDatabase database = _mongoResource.CreateDatabase(); IMongoCollection <Model> collection = database.GetCollection <Model>("col"); collection.InsertMany(new[] { new Model { Time = new DateTime(2000, 1, 1, 1, 1, 1, DateTimeKind.Utc) }, new Model { Time = new DateTime(2016, 1, 1, 1, 1, 1, DateTimeKind.Utc) }, }); return(collection); }) .AddGraphQL() .AddQueryType <QueryType>() .Services .BuildServiceProvider(); IRequestExecutor executor = await services.GetRequiredService <IRequestExecutorResolver>() .GetRequestExecutorAsync(); IReadOnlyQueryRequest request = QueryRequestBuilder.New() .SetQuery("{ items(where: { time_gt: \"2001-01-01\" }) { time } }") .Create(); // act IExecutionResult result = await executor.ExecuteAsync(request); // assert result.MatchSnapshot(); }
private IReadOnlyQueryRequest NormalizeRequest( IReadOnlyQueryRequest originalRequest) { ImmutableDictionary <string, object> normalizedVariables = ImmutableDictionary <string, object> .Empty; OperationDefinitionNode operation = null; foreach (KeyValuePair <string, object> variable in originalRequest.VariableValues) { if (variable.Value as IValueNode is null) { if (operation is null) { operation = ResolveOperationDefinition( originalRequest.Query, originalRequest.OperationName); } IValueNode normalizedValue = RewriteVariable( operation, variable.Key, variable.Value); normalizedVariables = normalizedVariables.SetItem(variable.Key, normalizedValue); } } if (normalizedVariables.Count > 0) { QueryRequestBuilder builder = QueryRequestBuilder.From(originalRequest); foreach (KeyValuePair <string, object> normalized in normalizedVariables) { builder.SetVariableValue(normalized.Key, normalized.Value); } return(builder.Create()); } return(originalRequest); }
public async Task UseSchemaBuilder() { // arrange IHttpClientFactory clientFactory = CreateRemoteSchemas(); var serviceCollection = new ServiceCollection(); serviceCollection.AddSingleton(clientFactory); serviceCollection.AddStitchedSchema(builder => builder.AddSchemaFromHttp("contract") .AddSchemaFromHttp("customer") .AddSchemaConfiguration(c => c .RegisterType <PaginationAmountType>() .Extend().OnBeforeBuild(b => b.AddType( new ObjectTypeExtension(d => d .Name("Query") .Field("foo") .Type <StringType>() .Resolver("bar")))))); IServiceProvider services = serviceCollection.BuildServiceProvider(); IQueryExecutor executor = services .GetRequiredService <IQueryExecutor>(); IExecutionResult result = null; // act using (IServiceScope scope = services.CreateScope()) { result = await executor.ExecuteAsync( QueryRequestBuilder.New() .SetQuery("{ foo }") .SetServices(scope.ServiceProvider) .Create()); } // assert Snapshot.Match(result); }
public async Task ListVariableIsCorrectlyPassed() { // arrange var serviceCollection = new ServiceCollection(); var connections = new Dictionary <string, HttpClient>(); serviceCollection.AddSingleton(CreateRemoteSchemas(connections)); serviceCollection.AddStitchedSchema(builder => builder .AddSchemaFromHttp("contract") .AddSchemaFromHttp("customer")); IServiceProvider services = serviceCollection.BuildServiceProvider(); IQueryExecutor executor = services .GetRequiredService <IQueryExecutor>(); // act IExecutionResult result = null; using (IServiceScope scope = services.CreateScope()) { IReadOnlyQueryRequest request = QueryRequestBuilder.New() .SetQuery("query foo ($ids: [ID!]!) { customers(ids: $ids) { id } }") .SetServices(scope.ServiceProvider) .SetVariableValue("ids", new List <object> { "Q3VzdG9tZXIteDE=", "Q3VzdG9tZXIteDE=" }) .Create(); result = await executor.ExecuteAsync(request); } // assert result.MatchSnapshot(new SnapshotNameExtension("result")); executor.Schema.ToString().MatchSnapshot( new SnapshotNameExtension("schema")); }
public async Task <IActionResult> ExecuteFunctionsQueryAsync( HttpContext httpContext, IDictionary <string, object> context, CancellationToken cancellationToken) { using var stream = httpContext.Request.Body; var requestQuery = await _requestParser .ReadJsonRequestAsync(stream, cancellationToken) .ConfigureAwait(false); var builder = QueryRequestBuilder.New(); if (requestQuery.Count > 0) { var firstQuery = requestQuery[0]; builder .SetQuery(firstQuery.Query) .SetOperation(firstQuery.OperationName) .SetQueryName(firstQuery.QueryName); foreach (var item in context) { builder.AddProperty(item.Key, item.Value); } if (firstQuery.Variables != null && firstQuery.Variables.Count > 0) { builder.SetVariableValues(firstQuery.Variables); } } var result = await Executor.ExecuteAsync(builder.Create()); await _jsonQueryResultSerializer.SerializeAsync((IReadOnlyQueryResult)result, httpContext.Response.Body); return(new EmptyResult()); }
public async Task Boolean_Filter_Not_Equals() { // arrange IServiceProvider services = new ServiceCollection() .AddSingleton <IMongoCollection <Model> >(sp => { IMongoDatabase database = _mongoResource.CreateDatabase(); IMongoCollection <Model> collection = database.GetCollection <Model>("col"); collection.InsertMany(new[] { new Model { Foo = "abc", Bar = 1, Baz = true }, new Model { Foo = "def", Bar = 2, Baz = false }, }); return(collection); }) .AddGraphQL() .AddQueryType <QueryType>() .Services .BuildServiceProvider(); IRequestExecutor executor = await services.GetRequiredService <IRequestExecutorResolver>() .GetRequestExecutorAsync(); IReadOnlyQueryRequest request = QueryRequestBuilder.New() .SetQuery("{ paging(where: { baz_not: false }) { nodes { foo } } }") .Create(); // act IExecutionResult result = await executor.ExecuteAsync(request); // assert result.MatchSnapshot(); }
public async Task ExecuteExportScalar() { // arrange Snapshot.FullName(); IRequestExecutor executor = await CreateExecutorAsync(c => c .AddStarWarsTypes() .AddExportDirectiveType() .Services .AddStarWarsRepositories()); // act var batch = new List <IReadOnlyQueryRequest> { QueryRequestBuilder.New() .SetQuery( @" query getHero { hero(episode: EMPIRE) { id @export } }") .Create(), QueryRequestBuilder.New() .SetQuery( @" query getHuman { human(id: $id) { name } }") .Create() }; IBatchQueryResult batchResult = await executor.ExecuteBatchAsync(batch); // assert await batchResult.ToJsonAsync().MatchSnapshotAsync(); }
public async Task GetItems_NoSorting_AllItems_Are_Returned_Unsorted() { // arrange IServiceProvider services = new ServiceCollection() .AddSingleton <IMongoCollection <Model> >(sp => { IMongoDatabase database = _mongoResource.CreateDatabase(); IMongoCollection <Model> collection = database.GetCollection <Model>("col"); collection.InsertMany(new[] { new Model { Foo = "abc", Bar = 1, Baz = true }, new Model { Foo = "def", Bar = 2, Baz = false }, }); return(collection); }) .AddGraphQL() .AddQueryType <QueryType>() .Services .BuildServiceProvider(); IRequestExecutor executor = await services.GetRequiredService <IRequestExecutorResolver>() .GetRequestExecutorAsync(); IReadOnlyQueryRequest request = QueryRequestBuilder.New() .SetQuery("{ items { foo } }") .Create(); // act IExecutionResult result = await executor.ExecuteAsync(request); // assert Assert.Null(result.Errors); result.MatchSnapshot(); }
public async Task Get_New_Basket_For_Owner() { var result = await ServiceProvider.ExecuteRequestAsync( QueryRequestBuilder .New() .SetQuery(@" query BasketByOwnerId($id: ID!) { basketByOwnerId(id: $id) { ownerId basketType items { id name } } } ") .SetVariableValue(name : "id", value : "600dca30-c6e2-4035-ad15-783c122d6ea6") .Create()); result.MatchSnapshot(); }
public void AddAndUpdate() { // Setup EnsureTestGraph(); Console.WriteLine(JsonConvert.SerializeObject(_trustBuilder.Package, Formatting.Indented)); // Test Add and schema validation var result = (ObjectResult)_packageController.PostPackage(_trustBuilder.Package).GetAwaiter().GetResult(); Assert.IsNotNull(result); //var httpResult = (HttpResult)result.Value; //Assert.AreEqual(HttpResultStatusType.Success.ToString(), httpResult.Status, httpResult.Message + " : " + httpResult.Data); var builder = new PackageBuilder(); builder.SetServer("testserver"); builder.AddClaim("A", "B", PackageBuilder.BINARY_CLAIM_DTP1, BinaryTrustFalseAttributes); builder.Build().Sign(); result = (ObjectResult)_packageController.PostPackage(builder.Package).GetAwaiter().GetResult(); Assert.IsNotNull(result); //httpResult = (HttpResult)result.Value; //Assert.AreEqual(HttpResultStatusType.Success.ToString(), httpResult.Status, httpResult.Message + " : " + httpResult.Data); // Test Graph var queryBuilder = new QueryRequestBuilder(PackageBuilder.BINARY_CLAIM_DTP1); BuildQuery(queryBuilder, "A", "B"); // Execute var context = _graphQueryService.Execute(queryBuilder.Query); var trust = context.Results.Claims[0]; VerfifyResult(context, "A", "B"); Assert.AreEqual(BinaryTrustFalseAttributes, trust.Value, $"Attributes are wrong!"); }
public async Task HandleAsync( IWebSocketContext context, GenericOperationMessage message, CancellationToken cancellationToken) { QueryRequestDto payload = message.Payload.ToObject <QueryRequestDto>(); IQueryRequestBuilder requestBuilder = QueryRequestBuilder.New() .SetQuery(payload.Query) .SetOperation(payload.OperationName) .SetVariableValues(QueryMiddlewareUtilities .ToDictionary(payload.Variables)) .SetServices(context.HttpContext.CreateRequestServices()); await context.PrepareRequestAsync(requestBuilder) .ConfigureAwait(false); IExecutionResult result = await context.QueryExecutor.ExecuteAsync( requestBuilder.Create(), cancellationToken) .ConfigureAwait(false); if (result is IResponseStream responseStream) { context.RegisterSubscription( new Subscription(context, responseStream, message.Id)); } else if (result is IReadOnlyQueryResult queryResult) { await context.SendSubscriptionDataMessageAsync( message.Id, queryResult, cancellationToken) .ConfigureAwait(false); await context.SendSubscriptionCompleteMessageAsync( message.Id, cancellationToken) .ConfigureAwait(false); } }
public async Task Create_NullableStringIdNotIn_Expression() { // arrange IRequestExecutor?tester = _cache.CreateSchema <FooNullable, FooNullableFilterInput>( _fooNullableEntities); // act // assert IExecutionResult?res1 = await tester.ExecuteAsync( QueryRequestBuilder.New() .SetQuery( @"{ root(where: { bar: { nin: [ ""Rm8KZHRlc3RhdGVzdA=="" ""Rm8KZHRlc3RidGVzdA=="" ] } }){ bar } }") .Create()); res1.MatchSnapshot("testatestAndtestb"); IExecutionResult?res2 = await tester.ExecuteAsync( QueryRequestBuilder.New() .SetQuery( "{ root(where: { bar: { nin: [\"Rm8KZHRlc3RidGVzdA==\" null]}}){ bar}}") .Create()); res2.MatchSnapshot("testbtestAndNull"); IExecutionResult?res3 = await tester.ExecuteAsync( QueryRequestBuilder.New() .SetQuery("{ root(where: { bar: { nin: [ \"Rm8KZHRlc3RhdGVzdA==\" ]}}){ bar}}") .Create()); res3.MatchSnapshot("testatest"); }
public async Task Create_BufferedRequest() { // 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") .Create(); IQueryRequest requestB = QueryRequestBuilder.New() .SetQuery(queryB) .SetVariableValue("id", "1") .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(); }
public void BuildRequest_QueryAndSetExtensions_RequestIsCreated_4() { // arrange IDictionary <string, object> ext = new Dictionary <string, object> { { "three", "baz" } }; // act IReadOnlyQueryRequest request = QueryRequestBuilder.New() .SetQuery("{ foo }") .AddExtension("one", "foo") .AddExtension("two", "bar") .SetExtensions(ext) .Create(); // assert // only three should exist request.MatchSnapshot(); }
public async Task EnsureQueryResultContainsExtensionTracing() { // arrange Schema schema = CreateSchema(); IQueryExecutor executor = QueryExecutionBuilder .BuildDefault(schema, new QueryExecutionOptions { TracingPreference = TracingPreference.Always }); var request = QueryRequestBuilder.New() .SetQuery("{ a }") .Create(); // act IExecutionResult result = await executor.ExecuteAsync(request); // assert Assert.NotEmpty(result.Extensions); Assert.True(result.Extensions.ContainsKey("tracing")); }
public async Task LastMetadataQuery() { //Arrange //Connect to database IServiceProvider serviceProvider = new ServiceCollection() .AddSingleton <IMetadataRepository, MetadataRepository>() .AddSingleton <IDatabaseConfig>(sp => new DatabaseConfig() { DatabaseConnectionString = dbConnectionString } ) .BuildServiceProvider(); IQueryExecutor executor = Schema.Create(c => { c.RegisterQueryType(new ObjectType <MetadataQuery>(d => d.Name("Query"))); c.RegisterType <List <MetadataType> >(); }) .MakeExecutable(); IReadOnlyQueryRequest request = QueryRequestBuilder.New() .SetQuery(@"{metadata(sensorID:1, onlyLast:true) {metadataID,sensorID,locationID,name,serialNumber,number, modelNumber,department,company, ownerID, purchaseDate,lending,lendingPrice,cableLength,checkOnInspectionRound,inspectionRound, company, servicePartner,voltage,coordinate, altitude, locationDescription, cableLength, identificator, measureArea, picture, plannedDisposal, actualDisposal, warrantyDate, voltage, signal, tag1, tag2, tag3, timeless, tollerance createdAt, updatedAt, outdatedFrom}}") .SetServices(serviceProvider) .Create(); // act IExecutionResult result = await executor.ExecuteAsync(request); //Assert Snapshot.Match(result); //result.MatchSnapshot(); }
public async Task DateType_GreaterThan_Filter() { // arrange var serviceCollection = new ServiceCollection(); serviceCollection.AddSingleton <IMongoCollection <Model> >(sp => { IMongoDatabase database = _mongoResource.CreateDatabase(); IMongoCollection <Model> collection = database.GetCollection <Model>("col"); collection.InsertMany(new[] { new Model { Date = new DateTime(2000, 1, 1, 1, 1, 1, DateTimeKind.Utc).Date }, new Model { Date = new DateTime(2016, 1, 1, 1, 1, 1, DateTimeKind.Utc).Date }, }); return(collection); }); ISchema schema = SchemaBuilder.New() .AddQueryType <QueryType>() .AddServices(serviceCollection.BuildServiceProvider()) .Create(); IQueryExecutor executor = schema.MakeExecutable(); IReadOnlyQueryRequest request = QueryRequestBuilder.New() .SetQuery("{ items(where: { date_gt: \"2001-01-01\" }) { date } }") .Create(); // act IExecutionResult result = await executor.ExecuteAsync(request); // assert result.MatchSnapshot(); }
public async Task GetItems_EqualsFilter_FirstItems_Is_Returned() { // arrange var serviceCollection = new ServiceCollection(); serviceCollection.AddSingleton <IMongoCollection <Model> >(sp => { IMongoDatabase database = _mongoResource.CreateDatabase(); var collection = database.GetCollection <Model>("col"); collection.InsertMany(new[] { new Model { Foo = "abc", Bar = 1, Baz = true }, new Model { Foo = "def", Bar = 2, Baz = false }, }); return(collection); }); ISchema schema = SchemaBuilder.New() .AddQueryType <QueryType>() .AddServices(serviceCollection.BuildServiceProvider()) .Create(); IQueryExecutor executor = schema.MakeExecutable(); IReadOnlyQueryRequest request = QueryRequestBuilder.New() .SetQuery("{ items(where: { foo: \"abc\" }) { foo } }") .Create(); // act IExecutionResult result = await executor.ExecuteAsync(request); // assert result.MatchSnapshot(); }
public static IEnumerable <(IQueryRequest, IEnumerable <BufferedRequest>)> MergeRequests( IEnumerable <BufferedRequest> requests, ISet <string> requestVariableNames) { foreach (var group in requests.GroupBy(t => t.Operation.Operation)) { var rewriter = new MergeRequestRewriter(requestVariableNames); var variableValues = new Dictionary <string, object?>(); var operationName = group .Select(r => r.Request.OperationName) .Where(n => n != null) .Distinct() .FirstOrDefault(); if (operationName is not null) { rewriter.SetOperationName(new NameNode(operationName)); } var i = 0; BufferedRequest first = null !; foreach (BufferedRequest request in group) { first = request; MergeRequest(request, rewriter, variableValues, $"__{i++}_"); } IQueryRequest batch = QueryRequestBuilder.New() .SetQuery(rewriter.Merge()) .SetOperation(operationName) .SetVariableValues(variableValues) .TrySetServices(first.Request.Services) .Create(); yield return(batch, group); } }
public void Source1Target1() { // Build up EnsureTestGraph(); var queryBuilder = new QueryRequestBuilder(ClaimType); BuildQuery(queryBuilder, "A", "D"); // Execute var context = _graphQueryService.Execute(queryBuilder.Query); PrintJson(context.Results); // Verify //Assert.AreEqual(4, context.Results.Trusts.Count, $"Should be {4} results!"); VerfifyResult(context, "A", "B"); VerfifyResult(context, "B", "C"); VerfifyResult(context, "B", "E"); VerfifyResult(context, "C", "D"); VerfifyResult(context, "E", "D"); }
public async Task Execute_DateTime_Filter() { // arrange ISchema schema = SchemaBuilder.New() .AddQueryType <QueryFooDateTime>(d => d .Name("Query") .Field(y => y.Foo) .UseFiltering()) .Create(); IQueryExecutor executor = schema.MakeExecutable(); IReadOnlyQueryRequest request = QueryRequestBuilder.New() .SetQuery("{ foo(where: { foo_gte: \"2019-06-01\"}) { foo } }") .Create(); // act IExecutionResult result = await executor.ExecuteAsync(request); // assert result.MatchSnapshot(); }
public async Task Should_NotInitializeObject_When_ResultOfLeftJoinIsNull() { // arrange IRequestExecutor tester = _cache.CreateSchema(_barWithoutRelation, OnModelCreating); // act // assert IExecutionResult res1 = await tester.ExecuteAsync( QueryRequestBuilder.New() .SetQuery( @" { root { foo { id } } }") .Create()); res1.MatchSqlSnapshot(); }
public async Task ApolloTracing_OnDemand_WithHeader() { // arrange IRequestExecutor executor = await CreateExecutorAsync(c => c .AddDocumentFromString( @" type Query { a: String }") .AddResolver("Query", "a", () => "hello world a") .AddApolloTracing(TracingPreference.OnDemand, new TestTimestampProvider())); // act IExecutionResult result = await executor.ExecuteAsync( QueryRequestBuilder.New() .SetQuery("{ a }") .SetProperty(WellKnownContextData.EnableTracing, true) .Create()); // assert result.ToJson().MatchSnapshot(); }
OnCreateQueryRequestAsync(HttpContext context) { using (Stream stream = context.Request.Body) { IReadOnlyList <GraphQLRequest> batch = null; switch (context.Request.ContentType.Split(';')[0]) { case ContentType.Json: batch = await _requestHelper .ReadJsonRequestAsync(stream) .ConfigureAwait(false); break; case ContentType.GraphQL: batch = await _requestHelper .ReadGraphQLQueryAsync(stream) .ConfigureAwait(false); break; default: throw new NotSupportedException(); } // TODO : batching support has to be added later GraphQLRequest request = batch[0]; return(QueryRequestBuilder.New() .SetQuery(request.Query) .SetQueryName(request.QueryName) .SetQueryName(request.QueryName) // TODO : we should have a hash here .SetOperation(request.OperationName) .SetVariableValues(request.Variables) .SetProperties(request.Extensions)); } }