public async Task Can_Pass_On_ClientMutationId_For_Relay_Nullable_Mutations()
{
var query = @"
mutation _ {
foo(input: { clientMutationId: ""some-mutation-id-1"", a: 1 }) {
clientMutationId
result
}
bar(input: { clientMutationId: ""some-mutation-id-2"", b: 2 }) {
clientMutationId
result
}
}";
var mutations = new[]
{
typeof(SchemaDefinitionWithMutation <FooMutation>),
typeof(SchemaDefinitionWithMutation <BarMutation>),
};
var engine = GraphQLEngine.New().BuildSchema(mutations);
var result = await engine
.NewExecutor()
.WithQueryString(query)
.Execute();
result.ShouldHaveNoErrors();
result.Data.ShouldHaveFieldWithValue("foo", "clientMutationId", "some-mutation-id-1");
result.Data.ShouldHaveFieldWithValue("foo", "result", 2);
result.Data.ShouldHaveFieldWithValue("bar", "clientMutationId", "some-mutation-id-2");
result.Data.ShouldHaveFieldWithValue("bar", "result", 102);
}
public void Can_Construct_And_Describe_Schema_With_Enums()
{
var engine = GraphQLEngine.New <QueryWithEnums>();
var schema = engine.Describe();
schema.ShouldEqualWhenReformatted(@"
schema {
query: QueryWithEnums
}
enum Enum1 {
OPTION1
OPTION2
OPTION3
}
input InputObject {
anotherField: RenamedEnum
someField: RenamedEnum = SOME_VALUE1
yetAnotherDummyField: RenamedEnum = SOME_VALUE2
yetAnotherField: RenamedEnum!
}
type QueryWithEnums {
field1: Enum1!
field2: RenamedEnum
field3(arg1: RenamedEnum, arg2: Enum1!, arg3: RenamedEnum = SOME_VALUE2, arg4: Enum1 = OPTION3): RenamedEnum!
field4(input: InputObject): RenamedEnum
field5(arg: Enum1): Enum1
}
enum RenamedEnum {
SOME_VALUE1
SOME_VALUE2
}
");
}
public void Can_Construct_And_Describe_Basic_Schema()
{
var engine = GraphQLEngine.New <BasicQuery>();
var schema = engine.Describe();
schema.ShouldEqualWhenReformatted(@"
schema {
query: BasicQuery
}
type BasicQuery {
booleanField1: Boolean
booleanField2: Boolean!
dateField1: Date
dateField2: Date!
doubleField1: Float
doubleField2: Float!
floatField1: Float
floatField2: Float!
fooField1: Foo
fooField2: Foo!
intField1: Int
intField2: Int!
stringField1: String
stringField2: String!
timeSpanField1: TimeSpan
timeSpanField2: TimeSpan!
urlField1: URL
urlField2: URL!
}
type Foo {
id: ID!
}
");
}
internal RequestHandlerImpl(
IDependencyInjector dependencyInjector,
IEnumerable <Type> schemaTypes,
IEnumerable <Type> assemblyTypes,
IEnumerable <Type> exceptionsTreatedAsWarning,
bool useValidation,
bool useProfiling,
FieldResolutionStrategy fieldResolutionStrategy,
ComplexityConfiguration complexityConfiguration,
IEnumerable <Type> middleware,
ITypeResolver typeResolver)
{
_engine = new GraphQLEngine(typeResolver: typeResolver);
_dependencyInjector = dependencyInjector;
_engine.WithAttributesFromAssemblies(assemblyTypes);
_exceptionsTreatedAsWarnings.AddRange(exceptionsTreatedAsWarning);
_useValidation = useValidation;
_useProfiling = useProfiling;
_engine.WithFieldResolutionStrategy(fieldResolutionStrategy);
_engine.BuildSchema(schemaTypes.ToArray());
_complexityConfiguration = complexityConfiguration;
foreach (var type in middleware)
{
_engine.WithMiddleware(type);
}
}
public async Task Will_Provide_Path_And_Code_For_Errors_In_Array_Fields()
{
var engine = GraphQLEngine.New <Query>();
var result = await engine
.NewExecutor()
.WithQueryString("query Blah { getObject { arrayField { test } } }")
.Execute();
result.Data.ShouldHaveFieldWithValue("getObject", "arrayField", 0, "test", "some value");
result.Data.ShouldHaveFieldWithValue("getObject", "arrayField", 1, "test", null);
result.Data.ShouldHaveFieldWithValue("getObject", "arrayField", 2, "test", "some value");
result.Data.ShouldHaveFieldWithValue("getObject", "arrayField", 3, "test", null);
result.Errors.ShouldNotBeNull();
result.Errors.Count.ShouldEqual(2);
var error = result.Errors.ElementAt(0);
error.Message.ShouldEqual("Test error.");
error.Code.ShouldEqual("ARGUMENT");
error.Path.Count().ShouldEqual(4);
error.Path.ElementAt(0).ShouldEqual("getObject");
error.Path.ElementAt(1).ShouldEqual("arrayField");
error.Path.ElementAt(2).ShouldEqual("1");
error.Path.ElementAt(3).ShouldEqual("test");
error = result.Errors.ElementAt(1);
error.Message.ShouldEqual("Test error.");
error.Code.ShouldEqual("ARGUMENT");
error.Path.Count().ShouldEqual(4);
error.Path.ElementAt(0).ShouldEqual("getObject");
error.Path.ElementAt(1).ShouldEqual("arrayField");
error.Path.ElementAt(2).ShouldEqual("3");
error.Path.ElementAt(3).ShouldEqual("test");
}
private void ConfigureGraphQL(IServiceRegistry serviceRegistry)
{
serviceRegistry.Register <IDependencyResolver>(factory => new FuncDependencyResolver(factory.GetInstance), new PerContainerLifetime());
serviceRegistry.Register <IDependencyInjector, GraphQLDependencyInjector>(new PerContainerLifetime());
serviceRegistry.Register <IUserContext, UserContext>();
serviceRegistry.Register <DataLoaderContext>();
serviceRegistry.Register <AircraftTypeQueries>();
serviceRegistry.Register <MarineUnitQueries>();
serviceRegistry.Register <AirportQueries>();
serviceRegistry.Register <PlanningQueries>();
serviceRegistry.Register <SolutionQueries>();
serviceRegistry.Register <AircraftTypeMutations>();
serviceRegistry.Register <MarineUnitMutations>();
serviceRegistry.Register <AirportMutations>();
serviceRegistry.Register <PlanningMutations>();
var graphqlEngine = GraphQLEngine.New();
graphqlEngine.WithQuery <AircraftTypeQueries>();
graphqlEngine.WithQuery <MarineUnitQueries>();
graphqlEngine.WithQuery <AirportQueries>();
graphqlEngine.WithQuery <PlanningQueries>();
graphqlEngine.WithQuery <SolutionQueries>();
graphqlEngine.WithMutation <AircraftTypeMutations>();
graphqlEngine.WithMutation <MarineUnitMutations>();
graphqlEngine.WithMutation <AirportMutations>();
graphqlEngine.WithMutation <PlanningMutations>();
serviceRegistry.RegisterInstance(graphqlEngine.BuildSchema());
}
public void Bug190_Discover_Possible_Types_From_Lists()
{
var schema = GraphQLEngine.New <Bug190Query_2>().GetSchema();
var type = schema.FindType(nameof(Bug190Query_2.TestImpl));
type.ShouldNotBeNull();
}
// This method gets called by the runtime. Use this method to add services to the container.
// For more information on how to configure your application, visit https://go.microsoft.com/fwlink/?LinkID=398940
public void ConfigureServices(IServiceCollection services)
{
var typeAdapter = new GraphTypeAdapter();
var constructor = new SchemaConstructor <ISchema, IGraphType>(typeAdapter);
var schema = constructor.Build(typeof(SchemaDefinition <GraphQl.Query, GraphQl.Mutation, GraphQl.Subscription>));
var graphQLEngine = new GraphQLEngine()
.WithFieldResolutionStrategy(FieldResolutionStrategy.Normal)
.WithQuery <GraphQl.Query>()
.WithMutation <GraphQl.Mutation>()
.WithSubscription <GraphQl.Subscription>()
.BuildSchema();
services.AddSingleton <MessageService>();
services.AddSingleton(schema);
services.AddMvc();
services.AddTransient <IDependencyInjector, Injector>();
services.AddSingleton(provider => graphQLEngine);
services.AddSingleton <IDocumentExecuter, GraphQL.Conventions.DocumentExecuter>();
services.AddSingleton <IDocumentWriter>(x =>
{
var jsonSerializerSettings = x.GetRequiredService <IOptions <JsonSerializerSettings> >();
return(new DocumentWriter(Formatting.None, jsonSerializerSettings.Value));
});
services.AddTransient(typeof(IGraphQLExecuter <>), typeof(DefaultGraphQLExecuter <>));
services.AddTransient <IWebSocketConnectionFactory <ISchema>, WebSocketConnectionFactory <ISchema> >();
services.AddTransient <IOperationMessageListener, LogMessagesListener>();
services.AddTransient <IOperationMessageListener, ProtocolMessageListener>();
}
public void Can_Construct_And_Describe_Schema_With_Injections()
{
var engine = GraphQLEngine.New<Query>();
var schema = engine.Describe();
schema.ShouldEqualWhenReformatted(@"
type Query {
field: String
}
");
}
private async Task <ExecutionResult> ExecuteQuery(string query)
{
var engine = GraphQLEngine.New <Query>();
var result = await engine
.NewExecutor()
.WithQueryString(query)
.Execute();
return(result);
}
public static IServiceCollection AddGraphQL <TQuery, TMutation>(this IServiceCollection services)
{
services.AddTransient <IGraphQLExecutor <ExecutionResult> >(provider =>
GraphQLEngine.New <TQuery, TMutation>()
.NewExecutor()
.WithUserContext(provider.GetService <IUserContext>())
.WithDependencyInjector(provider.GetService <IDependencyInjector>()));
services.AddSingleton <IDocumentWriter, DocumentWriter>();
return(services);
}
public async Task Can_Subscribe()
{
var engine = GraphQLEngine.New().WithSubscription <Subscription>();
var result = await engine
.NewExecutor()
.WithQueryString("subscription { test }")
.ExecuteAsync();
Assert.AreEqual(1, ((SubscriptionExecutionResult)result).Streams.Count);
}
public async Task Can_Execute_Query_On_Schema_Using_Interfaces_With_Generic_Types()
{
var engine = GraphQLEngine.New <Query>();
var result = await engine
.NewExecutor()
.WithQueryString("{ account { id } }")
.EnableValidation()
.ExecuteAsync();
result.ShouldHaveNoErrors();
result.Data.ShouldHaveFieldWithValue("account", "id", 123);
}
public async Task Can_Accept_Null_List_From_Literal()
{
var engine = GraphQLEngine
.New <TestQuery>();
var result = await engine
.NewExecutor()
.WithQueryString(@"query _ { example(testInputs:null) }")
.Execute();
result.ShouldHaveNoErrors();
result.Data.ShouldHaveFieldWithValue("example", "null");
}
public void Can_Construct_And_Describe_Schema_From_Abstract_Types()
{
var engine = GraphQLEngine.New <Query>();
var schema = engine.Describe();
schema.ShouldEqualWhenReformatted(@"
type Query {
commonField(value: Date!): Date!
someOtherField: String
}
");
}
public async void Can_Execute_Query_On_Schema_With_Injections_In_Generic_Methods()
{
var engine = GraphQLEngine.New<QueryWithDIFields>();
var result = await engine
.NewExecutor()
.WithQueryString("{ withDependency }")
.WithDependencyInjector(new DependencyInjector())
.Execute();
result.ShouldHaveNoErrors();
result.Data.ShouldHaveFieldWithValue("withDependency", 3);
}
public async void Can_Execute_Query_On_Schema_With_Injections()
{
var engine = GraphQLEngine.New<Query>();
var result = await engine
.NewExecutor()
.WithQueryString("{ field }")
.WithDependencyInjector(new DependencyInjector())
.Execute();
result.ShouldHaveNoErrors();
result.Data.ShouldHaveFieldWithValue("field", "Some Value");
}
public void Can_Construct_And_Describe_Schema_With_Injections_In_Generic_Methods()
{
var engine = GraphQLEngine.New<QueryWithDIFields>();
var schema = engine.Describe();
schema.ShouldEqualWhenReformatted(@"
schema {
query: QueryWithDIFields
}
type QueryWithDIFields {
withDependency: Int!
}
");
}
public async Task Can_Enable_Validation()
{
var engine = GraphQLEngine.New <Query>();
var result = await engine
.NewExecutor()
.WithQueryString("{ test }")
.EnableValidation()
.ExecuteAsync();
result.Errors.ShouldNotBeNull();
result.Errors.Count.ShouldEqual(1);
result.Errors.First().Message.ShouldEqual("Cannot query field \"test\" on type \"Query\".");
}
private async Task Can_Resolve_Query_Private <TQuery>()
{
var engine = GraphQLEngine
.New <TQuery>();
var result = await engine
.NewExecutor()
.WithQueryString("query { node { ... on ParentNode { id, nested { id } } } }")
.ExecuteAsync();
result.ShouldHaveNoErrors();
result.Data.ShouldHaveFieldWithValue("node", "id", "UGFyZW50Tm9kZTox");
result.Data.ShouldHaveFieldWithValue("node", "nested", "id", "Q2hpbGROb2RlOjE=");
}
public async Task Can_Execute_Query_On_Schema_From_Abstract_Types()
{
var engine = GraphQLEngine.New <Query>();
var result = await engine
.NewExecutor()
.WithQueryString("{ commonField(value: \"1970-01-01T00:00:00Z\") someOtherField }")
.EnableValidation()
.Execute();
result.ShouldHaveNoErrors();
result.Data.ShouldHaveFieldWithValue("commonField", new DateTime(1970, 1, 1));
result.Data.ShouldHaveFieldWithValue("someOtherField", string.Empty);
}
private async Task <ExecutionResult> ExecuteMutation(string query, Dictionary <string, object> inputs = null)
{
var engine = GraphQLEngine
.New()
.WithMutation <Mutation>();
var result = await engine
.NewExecutor()
.WithQueryString(query)
.WithInputs(inputs)
.Execute();
return(result);
}
private async Task <ExecutionResult> ExecuteQuery(
string query, Dictionary <string, object> inputs = null, IUserContext userContext = null)
{
var engine = GraphQLEngine.New <Query>();
var result = await engine
.NewExecutor()
.WithQueryString(query)
.WithInputs(inputs)
.WithUserContext(userContext)
.WithDependencyInjector(new DependencyInjector())
.ExecuteAsync();
return(result);
}
public async void Can_Register_And_Use_Custom_Scalar_Types()
{
var engine = GraphQLEngine
.New()
.RegisterScalarType <Custom, CustomGraphType>()
.WithQuery <CustomTypesQuery>();
var result = await engine
.NewExecutor()
.WithQueryString(@"{ customScalarType(arg:""CUSTOM:Test"") }")
.Execute();
result.ShouldHaveNoErrors();
result.Data.ShouldHaveFieldWithValue("customScalarType", "CUSTOM:WRAPPED:Test");
}
public async Task Will_expose_exceptions_when_enabled()
{
var engine = GraphQLEngine.New <Query>();
var result = await engine
.WithExposedExceptions()
.NewExecutor()
.WithQueryString("query { queryData }")
.Execute();
result.ExposeExceptions.ShouldBeTrue($"{nameof(result.ExposeExceptions)} should be enabled when {nameof(GraphQLEngine.WithExposedExceptions)} is called.");
JObject.FromObject(result)["errors"].First.Value <string>("message")
.Contains("at Tests.Adapters.Engine.ExposingExceptionsTests.Query.QueryData() in")
.ShouldBeTrue($"There should be stack trace in error messages when {nameof(result.ExposeExceptions)} is enabled.");
}
public async void Can_Disable_Validation()
{
var engine = GraphQLEngine.New<Query>();
var result = await engine
.NewExecutor()
.WithQueryString("{ test }")
.DisableValidation()
.Execute();
result.Data.ShouldNotBeNull();
var dict = result.Data as Dictionary<string, object>;
dict.Count.ShouldEqual(0);
result.Errors.ShouldBeNull();
}
public GraphController(
GraphQLEngine engine,
IUserContext userContext,
IDependencyInjector injector,
ILogger <GraphController> logger)
{
_engine = engine;
_userContext = userContext;
_injector = injector;
_logger = logger;
#if !DEBUG
_validationRules = new IValidationRule[] { new ValidationRules.DisableIntrospectionRule() };
#else
_validationRules = null;
#endif
}
public async Task Executor_Should_Use_UserContext_Injector()
{
var engine = new GraphQLEngine(documentExecuter: new ScopedDocumentExecuter())
.WithQuery <Query>()
.BuildSchema();
var executor1 = engine
.NewExecutor()
.WithQueryString("{ field }")
.WithDependencyInjector(new DependencyInjector("Injector"));
var result1 = await executor1.Execute();
result1.ShouldHaveNoErrors();
result1.Data.ShouldHaveFieldWithValue("field", "Injector->ChildScope");
}
private async Task <ExecutionResult> Resolve_Query(string selectedFields = "testMethod noAttribute name", params string[] accessPermissions)
{
var engine = GraphQLEngine
.New <CustomAttributeQuery>();
var user = new TestUserContext(accessPermissions);
var result = await engine
.NewExecutor()
.WithQueryString("query { node { " + selectedFields + " } }")
.WithUserContext(user)
.WithValidationRules(new[] { new TestValidation() })
.ExecuteAsync();
return(result);
}
public async Task Will_Provide_Exception_Data()
{
var engine = GraphQLEngine.New <Query>();
var result = await engine
.NewExecutor()
.WithQueryString("query Blah { errorWithData }")
.Execute();
result.Data.ShouldHaveFieldWithValue("errorWithData", null);
result.Errors.ShouldNotBeNull();
result.Errors.Count.ShouldEqual(1);
result.Errors.First().Message.ShouldEqual("Test error.");
result.Errors.First().Data["someKey"].ShouldEqual("someValue");
}
