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