public async Task RequestCustomContext() { // arrange var options = new Mock <IQueryExecutionOptionsAccessor>(); options .SetupGet(o => o.ExecutionTimeout) .Returns(TimeSpan.FromSeconds(30)); ISchema schema = CreateSchema(ExecutionScope.Request); IQueryExecuter executer = QueryExecutionBuilder .BuildDefault(schema, options.Object); // act var results = new List <IExecutionResult>(); results.Add(await executer.ExecuteAsync( new QueryRequest("{ a: a b: a }"))); results.Add(await executer.ExecuteAsync( new QueryRequest("{ a: a b: a }"))); results.Add(await executer.ExecuteAsync( new QueryRequest("{ a: a b: a }"))); results.Add(await executer.ExecuteAsync( new QueryRequest("{ a: a b: a }"))); // assert Assert.Collection(results, t => Assert.Null(t.Errors), t => Assert.Null(t.Errors), t => Assert.Null(t.Errors), t => Assert.Null(t.Errors)); results.Snapshot(); }
public async Task RequestDataLoader() { // arrange ISchema schema = CreateSchema(ExecutionScope.Request); IQueryExecutionOptionsAccessor options = CreateOptions(); IQueryExecuter executer = QueryExecutionBuilder .BuildDefault(schema, options); // act List <IExecutionResult> results = new List <IExecutionResult>(); results.Add(await executer.ExecuteAsync(new QueryRequest( @"{ a: withDataLoader(key: ""a"") b: withDataLoader(key: ""b"") }"))); results.Add(await executer.ExecuteAsync(new QueryRequest( @"{ a: withDataLoader(key: ""a"") }"))); results.Add(await executer.ExecuteAsync(new QueryRequest( @"{ c: withDataLoader(key: ""c"") }"))); results.Add(await executer.ExecuteAsync(new QueryRequest( "{ loads }"))); // assert Assert.Collection(results, t => Assert.Null(t.Errors), t => Assert.Null(t.Errors), t => Assert.Null(t.Errors), t => Assert.Null(t.Errors)); results.Snapshot(); }
public async Task SubscribeToReview() { // arrange IQueryExecuter executer = CreateSchema().MakeExecutable(); // act var responseStream = (IResponseStream)await executer.ExecuteAsync( "subscription { onCreateReview(episode: NEWHOPE) " + "{ stars } }"); // assert IExecutionResult result = await executer.ExecuteAsync(@" mutation { createReview(episode: NEWHOPE, review: { stars: 5 commentary: ""foo"" }) { stars commentary } }"); IReadOnlyQueryResult eventResult; using (var cts = new CancellationTokenSource(2000)) { eventResult = await responseStream.ReadAsync(); } eventResult.Snapshot(); }
public async Task ClassDataLoaderWithKey() { // arrange IServiceProvider serviceProvider = new ServiceCollection() .AddDataLoaderRegistry() .BuildServiceProvider(); var schema = Schema.Create(c => { c.RegisterQueryType <Query>(); c.Options.DeveloperMode = true; }); IQueryExecuter executer = schema.MakeExecutable(); IServiceScope scope = serviceProvider.CreateScope(); // act var results = new List <IExecutionResult>(); results.Add(await executer.ExecuteAsync(new QueryRequest( @"{ a: withDataLoader2(key: ""a"") b: withDataLoader2(key: ""b"") }") { Services = scope.ServiceProvider })); results.Add(await executer.ExecuteAsync(new QueryRequest( @"{ a: withDataLoader2(key: ""a"") }") { Services = scope.ServiceProvider })); results.Add(await executer.ExecuteAsync(new QueryRequest( @"{ c: withDataLoader2(key: ""c"") }") { Services = scope.ServiceProvider })); results.Add(await executer.ExecuteAsync(new QueryRequest( "{ loads loads2 }") { Services = scope.ServiceProvider })); // assert Assert.Collection(results, t => Assert.Empty(t.Errors), t => Assert.Empty(t.Errors), t => Assert.Empty(t.Errors), t => Assert.Empty(t.Errors)); results.Snapshot(); }
public async Task ExecuteQueryWithPaging() { // arrange ISchema schema = Schema.Create( c => c.RegisterQueryType <QueryType>()); IQueryExecuter executer = schema.MakeExecutable(); string query = @" { s(last:2) { edges { cursor node } pageInfo { hasNextPage } } } "; // act IExecutionResult result = await executer .ExecuteAsync(new QueryRequest(query)); // assert result.Snapshot(); }
public async Task AddClassErrorFilter() { // arrange ISchema schema = Schema.Create("type Query { foo: String }", c => c.BindResolver( ctx => { throw new Exception("Foo"); }).To("Query", "foo")); var options = new QueryExecutionOptions { IncludeExceptionDetails = false }; IQueryExecuter executer = schema.MakeExecutable(builder => builder.UseDefaultPipeline(options) .AddErrorFilter <DummyErrorFilter>()); // act IExecutionResult result = await executer.ExecuteAsync("{ foo }"); // assert result.Snapshot(); }
public async Task FetchSingleDataLoader() { // arrange IServiceProvider serviceProvider = new ServiceCollection() .AddDataLoaderRegistry() .BuildServiceProvider(); var schema = Schema.Create( @"type Query { fetchItem: String }", c => { c.BindResolver(async ctx => { IDataLoader <string, string> dataLoader = ctx.DataLoader <string, string>( "fetchItems", key => Task.FromResult(key)); return(await dataLoader.LoadAsync("fooBar")); }).To("Query", "fetchItem"); }); IQueryExecuter executer = schema.MakeExecutable(); IServiceScope scope = serviceProvider.CreateScope(); // act IExecutionResult result = await executer.ExecuteAsync( new QueryRequest("{ fetchItem }") { Services = scope.ServiceProvider });; // assert result.Snapshot(); }
public async Task MiddlewareConfig_MapWithDelegate() { // arrange ISchema schema = Schema.Create( "type Query { a: String b: String }", c => c.Map( new FieldReference("Query", "a"), next => context => { context.Result = "123"; return(Task.CompletedTask); }) .Map( new FieldReference("Query", "b"), next => context => { context.Result = "456"; return(Task.CompletedTask); })); IQueryExecuter executer = schema.MakeExecutable(); // act IExecutionResult result = await executer.ExecuteAsync("{ a b }"); // assert result.Snapshot(); }
public static Task <IExecutionResult> ExecuteAsync( this IQueryExecuter executer, string query) { return(executer.ExecuteAsync( new QueryRequest(query), CancellationToken.None)); }
public static Task <IExecutionResult> ExecuteAsync( this IQueryExecuter executer, QueryRequest request) { return(executer.ExecuteAsync( request, CancellationToken.None)); }
public async Task GlobalDataLoader() { // arrange ISchema schema = CreateSchema(ExecutionScope.Global); IQueryExecutionOptionsAccessor options = CreateOptions(); IQueryExecuter executer = QueryExecutionBuilder .BuildDefault(schema, options); // act List <IExecutionResult> results = new List <IExecutionResult>(); results.Add(await executer.ExecuteAsync(new QueryRequest( @"{ a: withDataLoader(key: ""a"") b: withDataLoader(key: ""b"") }"))); results.Add(await executer.ExecuteAsync(new QueryRequest( @"{ a: withDataLoader(key: ""a"") }"))); results.Add(await executer.ExecuteAsync(new QueryRequest( @"{ c: withDataLoader(key: ""c"") }"))); // assert Assert.Collection(results, t => Assert.Null(t.Errors), t => Assert.Null(t.Errors), t => Assert.Null(t.Errors)); results.Snapshot(); var keyLoads = new HashSet <string>(); var loads = (IQueryExecutionResult)await executer .ExecuteAsync(new QueryRequest("{ loads }")); foreach (object o in (IEnumerable <object>)loads.Data["loads"]) { string[] keys = o.ToString().Split(','); foreach (string key in keys) { Assert.True(keyLoads.Add(key)); } } }
public static async Task <IExecutionResult> ExecuteAsync( this ISchema schema, QueryRequest request, CancellationToken cancellationToken = default) { using (IQueryExecuter executer = QueryExecutionBuilder.New() .UseDefaultPipeline().Build(schema)) { return(await executer.ExecuteAsync(request, cancellationToken)); } }
public static Task <IExecutionResult> ExecuteAsync( this IQueryExecuter executer, string query, IReadOnlyDictionary <string, object> variableValues) { return(executer.ExecuteAsync( new QueryRequest(query) { VariableValues = variableValues }, CancellationToken.None)); }
public async Task Subscribe_RaiseEvent_ReceiveSubscriptionResult() { // arrange var registry = new InMemoryEventRegistry(); var services = new Mock <IServiceProvider>(); services.Setup(t => t.GetService(It.IsAny <Type>())) .Returns(new Func <Type, object>(t => { if (t == typeof(IEventRegistry) || t == typeof(IEventSender)) { return(registry); } return(null); })); ISchema schema = Schema.Create(c => { c.RegisterServiceProvider(services.Object); c.RegisterMutationType <MutationType>(); c.RegisterSubscriptionType <SubscriptionType>(); }); IQueryExecuter executer = schema.MakeExecutable(); var responseStream = await executer.ExecuteAsync("subscription { foo }") as IResponseStream; // act await executer.ExecuteAsync("mutation { foo }"); // assert IReadOnlyQueryResult result = await responseStream.ReadAsync(); Assert.False(responseStream.IsCompleted); Assert.Equal("bar", result.Data["foo"]); }
public async Task TypeIntrospectionOnQuery() { // arrange string query = "{ __type (type: \"Foo\") { name } }"; IQueryExecuter executer = CreateSchema().MakeExecutable(); // act IExecutionResult result = await executer.ExecuteAsync(query); // assert Assert.Empty(result.Errors); result.Snapshot(); }
private async Task <IExecutionResult> ExecuteQuery( string query, Action errorHandled) { IQueryExecuter queryExecuter = CreateSchema().MakeExecutable( b => b.UseDefaultPipeline().AddErrorFilter((error, ex) => { errorHandled(); return(error); })); return(await queryExecuter.ExecuteAsync(query)); }
public async Task GlobalCustomContext() { // arrange ISchema schema = CreateSchema(ExecutionScope.Global); IQueryExecuter executer = QueryExecutionBuilder.BuildDefault(schema); // act var results = new List <IExecutionResult>(); results.Add(await executer.ExecuteAsync(new QueryRequest("{ a }"))); results.Add(await executer.ExecuteAsync(new QueryRequest("{ a }"))); results.Add(await executer.ExecuteAsync(new QueryRequest("{ a }"))); results.Add(await executer.ExecuteAsync(new QueryRequest("{ a }"))); // assert Assert.Collection(results, t => Assert.Null(t.Errors), t => Assert.Null(t.Errors), t => Assert.Null(t.Errors), t => Assert.Null(t.Errors)); results.Snapshot(); }
public async Task ExecuteGraphiQLIntrospectionQuery() { // arrange string query = FileResource.Open("IntrospectionQuery.graphql"); IQueryExecuter executer = CreateSchema().MakeExecutable(); // act IExecutionResult result = await executer.ExecuteAsync(query); // assert Assert.Empty(result.Errors); result.Snapshot(); }
public async Task ExecuteShortHandQuery() { // arrange Schema schema = CreateSchema(); IQueryExecuter executer = QueryExecutionBuilder .BuildDefault(schema); var request = new QueryRequest("{ a }"); // act IExecutionResult result = await executer.ExecuteAsync(request); // assert Assert.Empty(result.Errors); result.Snapshot(); }
public async Task FilterOnlyNullRefExceptions() { // arrange ISchema schema = Schema.Create( "type Query { foo: String bar: String }", c => { // will be handled by the default filter logic c.BindResolver( ctx => { throw new Exception("Foo"); }).To("Query", "foo"); // will be handled by the custom filter logic c.BindResolver( ctx => { throw new NullReferenceException("Foo"); }).To("Query", "bar"); }); var options = new QueryExecutionOptions { IncludeExceptionDetails = false, ExecutionTimeout = TimeSpan.FromMinutes(10) }; IQueryExecuter executer = schema.MakeExecutable(builder => builder.UseDefaultPipeline(options) .AddErrorFilter((error, exception) => { if (exception is NullReferenceException) { return(error.WithCode("NullRef")); } return(error); })); // act IExecutionResult result = await executer.ExecuteAsync("{ foo bar }"); // assert result.Snapshot(); }
public async Task ExecuteShortHandQueryWithTracing() { // arrange Schema schema = CreateSchema(); IQueryExecuter executer = QueryExecutionBuilder .BuildDefault(schema, new QueryExecutionOptions { EnableTracing = true }); var request = new QueryRequest("{ a }"); // act IExecutionResult result = await executer.ExecuteAsync(request); // assert Assert.NotEmpty(result.Extensions); Assert.True(result.Extensions.ContainsKey("tracing")); }
public Task <IExecutionResult> RedirectQueryAsync( IDirectiveContext directiveContext) { if (directiveContext == null) { throw new ArgumentNullException(nameof(directiveContext)); } string schemaName = directiveContext.FieldSelection.GetSchemaName(); var stitchingCtx = directiveContext.Service <IStitchingContext>(); IQueryExecuter queryExecuter = stitchingCtx.GetQueryExecuter(schemaName); QueryRequest queryRequest = CreateQuery(directiveContext); return(queryExecuter.ExecuteAsync( queryRequest, directiveContext.RequestAborted)); }
public async Task ExecuteWithMissingVariables_Error() { // arrange var variableValues = new Dictionary <string, object>(); Schema schema = CreateSchema(); IQueryExecuter executer = QueryExecutionBuilder .BuildDefault(schema); var request = new QueryRequest( "query x($a: String!) { b(a: $a) }") { VariableValues = variableValues }; // act IExecutionResult result = await executer.ExecuteAsync(request); // assert Assert.NotNull(result.Errors); result.Snapshot(); }
public async Task ContextDataIsPassedAllongCorrectly() { // arrange bool allDataIsPassedAlong = false; ISchema schema = Schema.Create( "type Query { foo: String }", c => c.Use(next => context => { context.ContextData["field"] = "abc"; context.Result = context.ContextData["request"]; return(Task.CompletedTask); })); IQueryExecuter executer = schema.MakeExecutable( b => b.UseDefaultPipeline() .Use(next => context => { if (context.ContextData.ContainsKey("request") && context.ContextData.ContainsKey("field")) { allDataIsPassedAlong = true; } return(Task.CompletedTask); })); // act IExecutionResult result = await executer.ExecuteAsync( new QueryRequest("{ foo }") { Properties = new Dictionary <string, object> { { "request", "123" } } }); // assert Assert.True(allDataIsPassedAlong); result.Snapshot(); }
public async Task <IExecutionResult> GraphQLOrgFieldExample() { string query = @" { hero { name # Queries can have comments! friends { name } } }"; return(await _queryExecuter.ExecuteAsync( new QueryRequest(query), CancellationToken.None)); }
public async Task ExecuteQueryOnStitchedSchema() { // arrange string schema_a = @" type Query { foo: Foo } type Foo { name: String }"; string schema_b = @" type Query { bar: Bar } type Bar { name: String }"; string schema_stiched = @" type Query { foo: Foo @schema(name: ""a"") @delegate } type Foo { name: String @schema(name: ""a"") bar: Bar @schema(name: ""b"") @delegate } type Bar { name: String @schema(name: ""b"") }"; string query = @" { foo { name bar { name } } }"; DocumentNode queryDocument = Parser.Default.Parse(query); FieldNode fieldSelection = queryDocument.Definitions .OfType <OperationDefinitionNode>().First() .SelectionSet.Selections.OfType <FieldNode>().First() .SelectionSet.Selections.OfType <FieldNode>().Last(); var schemas = new Dictionary <string, IQueryExecuter>(); schemas["a"] = QueryExecutionBuilder.BuildDefault( Schema.Create(schema_a, c => c.Use(next => context => { context.Result = "foo"; return(Task.CompletedTask); }))); schemas["b"] = QueryExecutionBuilder.BuildDefault( Schema.Create(schema_b, c => c.Use(next => context => { context.Result = "bar"; return(Task.CompletedTask); }))); var services = new ServiceCollection(); services.AddSingleton <IStitchingContext>( new StitchingContext(schemas)); services.AddSingleton <IQueryBroker, QueryBroker>(); services.AddSingleton <ISchema>(sp => Schema.Create( schema_stiched, c => { c.RegisterServiceProvider(sp); c.UseStitching(); })); var schema = services.BuildServiceProvider().GetService <ISchema>(); IQueryExecuter executer = schema.MakeExecutable( t => t.UseDefaultPipeline().AddParser <AnnotationQueryParser>()); // act IExecutionResult result = await executer.ExecuteAsync(query); // assert result.Snapshot(); }