public async Task SingleField_WithAcceptableArgumentsOnMethod_ValidateFields()
{
var server = new TestServerBuilder()
.AddGraphType <SimplePlanGenerationController>()
.Build();
var parser = new GraphQLParser();
var syntaxTree = parser.ParseQueryDocument("query { simple { simpleQueryMethod(arg1: \"bob\", arg2: 15) { property1} } }".AsMemory());
var planGenerator = new DefaultGraphQueryPlanGenerator <GraphSchema>(
server.Schema,
new DefaultGraphQueryDocumentGenerator <GraphSchema>(server.Schema),
new DefaultOperationComplexityCalculator <GraphSchema>());
var plan = await planGenerator.CreatePlan(syntaxTree);
Assert.AreEqual(1, plan.Operations.Count);
Assert.AreEqual(0, plan.Messages.Count);
var queuedContext = plan.RetrieveOperation().FieldContexts[0];
var child = queuedContext.ChildContexts[0];
var arg1 = child.Arguments["arg1"];
var arg2 = child.Arguments["arg2"];
Assert.IsNotNull(arg1);
Assert.IsNotNull(arg2);
Assert.AreEqual("bob", arg1.Value.Resolve(ResolvedVariableCollection.Empty));
Assert.AreEqual(15L, arg2.Value.Resolve(ResolvedVariableCollection.Empty));
}
public void FailureToResolve_YieldErrorMessage()
{
var server = new TestServerBuilder()
.AddGraphType <InputController>()
.Build();
var parser = new GraphQLParser();
// set arg1 to int.max + 1; the int graph type will fail to resolve it
var syntaxTree = parser.ParseQueryDocument("query TestQuery{ input { fetchString(arg1: 2147483648 ) } }".AsMemory());
var docGenerator = new DefaultGraphQueryDocumentGenerator <GraphSchema>(server.Schema);
var document = docGenerator.CreateDocument(syntaxTree);
var queryInputCollection = document.Operations["TestQuery"].FieldSelectionSet[0].FieldSelectionSet[0].Arguments;
var argGenerator = new ArgumentGenerator(server.Schema, queryInputCollection);
var schemaType = server.Schema.KnownTypes.FindGraphType("Query_Input");
var graphFieldArguments = (schemaType as IGraphFieldContainer).Fields["fetchString"].Arguments;
var arg1 = graphFieldArguments["arg1"];
var result = argGenerator.CreateInputArgument(arg1);
Assert.IsNotNull(result);
Assert.IsFalse(result.IsValid);
Assert.IsNull(result.Argument as ResolvedInputArgumentValue);
Assert.IsNotNull(result.Message);
Assert.AreEqual(Constants.ErrorCodes.INVALID_ARGUMENT, result.Message.Code);
}
public async Task SingleField_WhenInputArgumentPassesNull_WhenAcceptable_GeneratesArgumentAsNull()
{
var server = new TestServerBuilder().AddGraphType <SimplePlanGenerationController>().Build();
var parser = new GraphQLParser();
var syntaxTree = parser.ParseQueryDocument(@"query {
simple {
complexQueryMethod(arg1: null) {
property1
}
}
}".AsMemory());
var planGenerator = new DefaultGraphQueryPlanGenerator <GraphSchema>(
server.Schema,
new DefaultGraphQueryDocumentGenerator <GraphSchema>(server.Schema),
new DefaultOperationComplexityCalculator <GraphSchema>());
var plan = await planGenerator.CreatePlan(syntaxTree);
Assert.IsNotNull(plan);
Assert.AreEqual(0, plan.Messages.Count);
Assert.AreEqual(1, plan.Operations.Count);
var queuedContext = plan.RetrieveOperation().FieldContexts[0];
var child = queuedContext.ChildContexts[0];
// Ensure that arg1 exists and is recieved as null
var arg1 = child.Arguments["arg1"];
Assert.IsNull(arg1.Value.Resolve(ResolvedVariableCollection.Empty));
}
public async Task SingleField_WithDirective_ValidateFields()
{
var server = new TestServerBuilder().AddGraphType <SimplePlanGenerationController>().Build();
var parser = new GraphQLParser();
var syntaxTree = parser.ParseQueryDocument("query { simple @skip(if: true) { simpleQueryMethod { property1} } }".AsMemory());
var planGenerator = new DefaultGraphQueryPlanGenerator <GraphSchema>(
server.Schema,
new DefaultGraphQueryDocumentGenerator <GraphSchema>(server.Schema),
new DefaultOperationComplexityCalculator <GraphSchema>());
var plan = await planGenerator.CreatePlan(syntaxTree);
Assert.IsNotNull(plan);
Assert.AreEqual(0, plan.Messages.Count);
Assert.AreEqual(1, plan.Operations.Count);
// the "simple" virtual field queued to be resolved when the plan
// is executed
var queuedContext = plan.RetrieveOperation().FieldContexts[0];
Assert.IsNotNull(queuedContext);
Assert.AreEqual("simple", queuedContext.Name);
Assert.AreEqual(1, queuedContext.Directives.Count);
var directiveContext = queuedContext.Directives[0];
Assert.IsNotNull(directiveContext);
Assert.AreEqual(DirectiveLocation.FIELD, directiveContext.Location);
Assert.AreEqual("skip", directiveContext.Directive.Name);
Assert.AreEqual(1, directiveContext.Arguments.Count);
Assert.AreEqual(true, directiveContext.Arguments["if"].Value.Resolve(ResolvedVariableCollection.Empty));
}
public void NotFoundArgument_GeneratesResultWithDefaultValue()
{
var server = new TestServerBuilder()
.AddGraphType <InputController>()
.Build();
var parser = new GraphQLParser();
var syntaxTree = parser.ParseQueryDocument("query TestQuery{ input { fetchString(arg1: 5) } }".AsMemory());
var docGenerator = new DefaultGraphQueryDocumentGenerator <GraphSchema>(server.Schema);
var document = docGenerator.CreateDocument(syntaxTree);
var queryInputCollection = document.Operations["TestQuery"].FieldSelectionSet[0].FieldSelectionSet[0].Arguments;
var argGenerator = new ArgumentGenerator(server.Schema, queryInputCollection);
var schemaType = server.Schema.KnownTypes.FindGraphType("Query_Input");
var graphFieldArguments = (schemaType as IGraphFieldContainer).Fields["fetchString"].Arguments;
var arg2 = graphFieldArguments["arg2"];
var result = argGenerator.CreateInputArgument(arg2);
Assert.IsNotNull(result);
Assert.IsTrue(result.IsValid);
Assert.IsNotNull(result.Argument as ResolvedInputArgumentValue);
Assert.IsNull(result.Message);
// default value on the parameter
var data = result.Argument.Resolve(ResolvedVariableCollection.Empty);
Assert.AreEqual(15, data);
}
public void ExpectedDeferredList_DoesDefer()
{
var server = new TestServerBuilder()
.AddGraphType <InputController>()
.Build();
var parser = new GraphQLParser();
// set arg1 to int.max + 1; the int graph type will fail to resolve it
var syntaxTree = parser.ParseQueryDocument("query TestQuery($var1: Int!){ input { fetchArrayTotal(arg3: [1, $var1, 3]) } }".AsMemory());
var docGenerator = new DefaultGraphQueryDocumentGenerator <GraphSchema>(server.Schema);
var document = docGenerator.CreateDocument(syntaxTree);
var queryInputCollection = document.Operations["TestQuery"].FieldSelectionSet[0].FieldSelectionSet[0].Arguments;
var argGenerator = new ArgumentGenerator(server.Schema, queryInputCollection);
var schemaType = server.Schema.KnownTypes.FindGraphType("Query_Input");
var graphFieldArguments = (schemaType as IGraphFieldContainer).Fields["fetchArrayTotal"].Arguments;
var arg3 = graphFieldArguments["arg3"];
var result = argGenerator.CreateInputArgument(arg3);
Assert.IsNotNull(result);
Assert.IsTrue(result.IsValid);
Assert.IsNotNull(result.Argument as DeferredInputArgumentValue);
Assert.IsNull(result.Message);
}
public async Task SingleField_WithVariables_UsingDefaults_WithAcceptableArgumentsOnMethod_VariableValueIsAssigned()
{
var server = new TestServerBuilder().AddGraphType <SimplePlanGenerationController>().Build();
var parser = new GraphQLParser();
var syntaxTree = parser.ParseQueryDocument(@"query($var1 : Long = 22)
{
simple {
simpleQueryMethod(arg1: ""bob"", arg2: $var1) {
property1
}
}
}".AsMemory());
var planGenerator = new DefaultGraphQueryPlanGenerator <GraphSchema>(
server.Schema,
new DefaultGraphQueryDocumentGenerator <GraphSchema>(server.Schema),
new DefaultOperationComplexityCalculator <GraphSchema>());
var plan = await planGenerator.CreatePlan(syntaxTree);
Assert.IsNotNull(plan);
Assert.AreEqual(0, plan.Messages.Count);
Assert.AreEqual(1, plan.Operations.Count);
var queuedContext = plan.RetrieveOperation().FieldContexts[0];
var child = queuedContext.ChildContexts[0];
// Ensur the variable $var1 used its default value and that arg2 is assigned that value
var arg2 = child.Arguments["arg2"];
Assert.IsNotNull(arg2);
}
public async Task SingleField_NoExtras_ValidateFields()
{
var server = new TestServerBuilder().AddGraphType <SimplePlanGenerationController>().Build();
var parser = new GraphQLParser();
var syntaxTree = parser.ParseQueryDocument("query { simple { simpleQueryMethod { property1} } }".AsMemory());
var planGenerator = new DefaultGraphQueryPlanGenerator <GraphSchema>(
server.Schema,
new DefaultGraphQueryDocumentGenerator <GraphSchema>(server.Schema),
new DefaultOperationComplexityCalculator <GraphSchema>());
var plan = await planGenerator.CreatePlan(syntaxTree);
Assert.IsNotNull(plan);
Assert.AreEqual(0, plan.Messages.Count);
Assert.AreEqual(1, plan.Operations.Count);
// the "simple" virtual field queued to be resolved when the plan
// is executed
var queuedContext = plan.Operations[string.Empty].FieldContexts[0];
Assert.IsNotNull(queuedContext);
Assert.AreEqual("simple", queuedContext.Name);
Assert.AreEqual("simple", queuedContext.Origin.Path.DotString());
// "simple" should contain 1 child field called "simpleQueryMethod"
Assert.AreEqual(0, queuedContext.Arguments.Count);
Assert.AreEqual(1, queuedContext.ChildContexts.Count);
Assert.IsTrue(queuedContext.Field?.Resolver is GraphRouteFieldResolver);
// simpleQueryMethod should contain 1 property to be resolved
var child = queuedContext.ChildContexts[0];
Assert.IsNotNull(child);
Assert.AreEqual("simpleQueryMethod", child.Name);
Assert.AreEqual("simple.simpleQueryMethod", child.Origin.Path.DotString());
Assert.AreEqual(1, child.ChildContexts.Count);
// the defaults defined on the method should have been assigned when none were supplied
// since both were optional.
Assert.AreEqual(2, child.Arguments.Count);
Assert.IsTrue(child.Field?.Resolver is GraphControllerActionResolver);
var arg1 = child.Arguments["arg1"];
var arg2 = child.Arguments["arg2"];
Assert.AreEqual("default string", arg1.Value.Resolve(ResolvedVariableCollection.Empty));
Assert.AreEqual(5, arg2.Value.Resolve(ResolvedVariableCollection.Empty));
// "property1"
var prop1 = child.ChildContexts[0];
Assert.IsNotNull(prop1);
Assert.AreEqual("property1", prop1.Name);
Assert.AreEqual("simple.simpleQueryMethod.property1", prop1.Origin.Path.DotString());
Assert.AreEqual(0, prop1.ChildContexts.Count);
Assert.AreEqual(0, prop1.Arguments.Count);
Assert.IsTrue(prop1.Field?.Resolver is GraphObjectPropertyResolver);
}
private static object GetInputValue(GraphQLParser.Input input)
{
if (input.IsBoolean) return ((GraphQLParser.Input.Boolean)input).Item;
if (input.IsFloat) return ((GraphQLParser.Input.Float)input).Item;
if (input.IsInt) return ((GraphQLParser.Input.Int)input).Item;
if (input.IsString) return ((GraphQLParser.Input.String)input).Item;
throw new Exception("Shouldn't be here");
}
public void ParseDocument_KitchenSinkParses()
{
var qualifiedQuery = ResourceLoader.ReadAllLines("KitchenSink", "KitchenSink.graphql");
var parser = new GraphQLParser();
var syntaxTree = parser.ParseQueryDocument(qualifiedQuery.AsMemory());
Assert.IsNotNull(syntaxTree);
}
public void ParseDocument_EmptyQueryParsesDefaultQuery()
{
var qualifiedQuery = "{}";
var parser = new GraphQLParser();
var syntaxTree = parser.ParseQueryDocument(qualifiedQuery.AsMemory());
Assert.AreEqual(1, syntaxTree.Nodes.Count);
}
public void ParseDocument_InvalidDocumentThrowsException()
{
var text = "query someQuery{field1, field2";
Assert.Throws <GraphQLSyntaxException>(() =>
{
var parser = new GraphQLParser();
var syntaxTree = parser.ParseQueryDocument(text.AsMemory());
});
}
public void ParseDocument_NonQueryThrowsException()
{
var qualifiedQuery = string.Empty;
Assert.Throws <GraphQLSyntaxException>(() =>
{
var parser = new GraphQLParser();
var syntaxTree = parser.ParseQueryDocument(qualifiedQuery.AsMemory());
});
}
public GraphQlDocument(String query)
{
var lexer = new GraphQLLexer(new AntlrInputStream(query));
var cts = new CommonTokenStream(lexer);
GraphQLParser parser = new GraphQLParser(cts);
documentContext = parser.document();
}
public Document Build(string data)
{
var stream = new MemoryStream(Encoding.UTF8.GetBytes(data));
var reader = new StreamReader(stream);
var input = new AntlrInputStream(reader);
var lexer = new GraphQLLexer(input);
var tokens = new CommonTokenStream(lexer);
var parser = new GraphQLParser(tokens);
var documentTree = parser.document();
var vistor = new GraphQLVisitor();
return vistor.Visit(documentTree) as Document;
}
public Document Build(string data)
{
var stream = new MemoryStream(Encoding.UTF8.GetBytes(data));
var reader = new StreamReader(stream);
var input = new AntlrInputStream(reader);
var lexer = new GraphQLLexer(input);
var tokens = new CommonTokenStream(lexer);
var parser = new GraphQLParser(tokens);
var documentTree = parser.document();
var vistor = new GraphQLVisitor();
return(vistor.Visit(documentTree) as Document);
}
public async Task MultipleTypeRestrictedFragments_GeneratesCorrectFieldContexts_WithDuplciatedFieldNamesOnFragments()
{
var server = new TestServerBuilder()
.AddGraphType <FragmentProcessingController>()
.Build();
var query = @"
query {
fragTester {
makeHybridData {
...aData
...bData
}
}
}
fragment aData on FragmentDataA{
property1
}
fragment bData on FragmentDataB{
property1
}";
var parser = new GraphQLParser();
var syntaxTree = parser.ParseQueryDocument(query.AsMemory());
var planGenerator = new DefaultGraphQueryPlanGenerator <GraphSchema>(
server.Schema,
new DefaultGraphQueryDocumentGenerator <GraphSchema>(server.Schema),
new DefaultOperationComplexityCalculator <GraphSchema>());
var plan = await planGenerator.CreatePlan(syntaxTree);
Assert.IsNotNull(plan);
Assert.AreEqual(1, plan.Operations.Count);
Assert.AreEqual(0, plan.Messages.Count);
var fragTester = plan.RetrieveOperation().FieldContexts[0];
Assert.IsNotNull(fragTester);
var makeHybridData = fragTester.ChildContexts[0];
Assert.IsNotNull(makeHybridData);
Assert.AreEqual(2, makeHybridData.ChildContexts.Count);
Assert.IsTrue(makeHybridData.ChildContexts.Any(x => x.ExpectedSourceType == typeof(FragmentDataA) && x.Field.Name == "property1"));
Assert.IsTrue(makeHybridData.ChildContexts.Any(x => x.ExpectedSourceType == typeof(FragmentDataB) && x.Field.Name == "property1"));
}
public void ExpectedNonDeferredComplexObject_DoesNotDefer()
{
var server = new TestServerBuilder()
.AddGraphType <InputController>()
.Build();
var parser = new GraphQLParser();
// set arg1 to int.max + 1; the int graph type will fail to resolve it
var syntaxTree = parser.ParseQueryDocument(@"
query TestQuery{
input {
fetchComplexValue(arg4: {
property1: ""bob""
property2: 10
}
)
}
}".AsMemory());
var docGenerator = new DefaultGraphQueryDocumentGenerator <GraphSchema>(server.Schema);
var document = docGenerator.CreateDocument(syntaxTree);
var queryInputCollection = document.Operations["TestQuery"].FieldSelectionSet[0].FieldSelectionSet[0].Arguments;
var argGenerator = new ArgumentGenerator(server.Schema, queryInputCollection);
var schemaType = server.Schema.KnownTypes.FindGraphType("Query_Input");
var graphFieldArguments = (schemaType as IGraphFieldContainer).Fields["fetchComplexValue"].Arguments;
var arg3 = graphFieldArguments["arg4"];
var result = argGenerator.CreateInputArgument(arg3);
Assert.IsNotNull(result);
Assert.IsTrue(result.IsValid);
Assert.IsNotNull(result.Argument as ResolvedInputArgumentValue);
Assert.IsNull(result.Message);
var data = result.Argument.Resolve(ResolvedVariableCollection.Empty) as TwoPropertyObject;
Assert.IsNotNull(data);
Assert.AreEqual("bob", data.Property1);
Assert.AreEqual(10, data.Property2);
}
public async Task MultiOperationDocument_SelectsCorrectOperationInPlan()
{
var server = new TestServerBuilder()
.AddGraphType <SimplePlanGenerationController>()
.Build();
var str = @"
query Operation1{ simple { simpleQueryMethod { property1} } }
query Operation2{ simple { simpleQueryMethod { property2} } }
";
var parser = new GraphQLParser();
var syntaxTree = parser.ParseQueryDocument(str.AsMemory());
var planGenerator = new DefaultGraphQueryPlanGenerator <GraphSchema>(
server.Schema,
new DefaultGraphQueryDocumentGenerator <GraphSchema>(server.Schema),
new DefaultOperationComplexityCalculator <GraphSchema>());
var plan = await planGenerator.CreatePlan(syntaxTree);
Assert.IsNotNull(plan);
Assert.AreEqual(0, plan.Messages.Count);
Assert.AreEqual(2, plan.Operations.Count);
// the "simple" virtual field queued to be resolved when the plan
// is executed
var queuedContext = plan.RetrieveOperation("Operation1").FieldContexts[0];
Assert.IsNotNull(queuedContext);
Assert.AreEqual("simple", queuedContext.Name);
// simpleQueryMethod should contain 1 property to be resolved
var child = queuedContext.ChildContexts[0];
Assert.IsNotNull(child);
Assert.AreEqual("simpleQueryMethod", child.Name);
// "property1"
var prop1 = child.ChildContexts[0];
Assert.IsNotNull(prop1);
Assert.AreEqual("property1", prop1.Name);
}
public async Task Union_WhenAnInterfaceIsSpreadInAUnion_ShouldReturnTheInterfaceFields_ForEachMemberOfTheUnionThatImplementsTheInterface()
{
var server = new TestServerBuilder()
.AddGraphType <SimplePlanGenerationController>()
.AddGraphType <ITwoPropertyObject>()
.Build();
// unionQuery returns a union graphtype of (TwoPropObject | TwoPropObjectV2)
// TwoPropObject implement the interface graphtype TwoPropertyInterface and property1 should
// be included in hte plan for that object graph type reference
// since TwoPropObjectV2 does not implement TwoPropertyInterface it should not be included
var query = @"
query {
simple {
unionQuery {
...RequestedProperties
}
}
}
fragment RequestedProperties on TwoPropertyInterface {
property1
}";
var parser = new GraphQLParser();
var syntaxTree = parser.ParseQueryDocument(query.AsMemory());
var planGenerator = new DefaultGraphQueryPlanGenerator <GraphSchema>(
server.Schema,
new DefaultGraphQueryDocumentGenerator <GraphSchema>(server.Schema),
new DefaultOperationComplexityCalculator <GraphSchema>());
var plan = await planGenerator.CreatePlan(syntaxTree);
Assert.IsNotNull(plan);
Assert.AreEqual(0, plan.Messages.Count);
// simple -> SimpleQueryMthod
var unionQueryField = plan.RetrieveOperation().FieldContexts[0].ChildContexts[0];
// prop1 for TwoPropObject
Assert.AreEqual(1, unionQueryField.ChildContexts.Count);
Assert.IsTrue(unionQueryField.ChildContexts.Any(x => x.Name == "property1" && x.ExpectedSourceType == typeof(TwoPropertyObject)));
}
public async Task Union_TypeName_AsAFieldSelectionDirectlyOnAUnion_ProducesTypeNameFieldForAllMembersOfTheUnion()
{
var server = new TestServerBuilder().AddGraphType <SimplePlanGenerationController>().Build();
// unionQuery returns a union graphtype of TwoPropObject and TwoPropObjectV2
// specific fields for V1 are requested but V2 should be included with __typename as well
var query = @"
query {
simple {
unionQuery {
...RequestedProperties
__typename
}
}
}
fragment RequestedProperties on TwoPropertyObject {
property1
property2
}";
var parser = new GraphQLParser();
var syntaxTree = parser.ParseQueryDocument(query.AsMemory());
var planGenerator = new DefaultGraphQueryPlanGenerator <GraphSchema>(
server.Schema,
new DefaultGraphQueryDocumentGenerator <GraphSchema>(server.Schema),
new DefaultOperationComplexityCalculator <GraphSchema>());
var plan = await planGenerator.CreatePlan(syntaxTree);
Assert.IsNotNull(plan);
Assert.AreEqual(0, plan.Messages.Count);
// simple -> SimpleQueryMthod
var unionQueryField = plan.RetrieveOperation().FieldContexts[0].ChildContexts[0];
// prop1 for TwoPropObject, prop2 fro TwoPropObject, __typename for TwoPropObject, __typename for TwoPropObjectV2
Assert.AreEqual(4, unionQueryField.ChildContexts.Count);
Assert.IsTrue(unionQueryField.ChildContexts.Any(x => x.Name == "property1" && x.ExpectedSourceType == typeof(TwoPropertyObject)));
Assert.IsTrue(unionQueryField.ChildContexts.Any(x => x.Name == "property2" && x.ExpectedSourceType == typeof(TwoPropertyObject)));
Assert.IsTrue(unionQueryField.ChildContexts.Any(x => x.Name == "__typename" && x.ExpectedSourceType == typeof(TwoPropertyObject)));
Assert.IsTrue(unionQueryField.ChildContexts.Any(x => x.Name == "__typename" && x.ExpectedSourceType == typeof(TwoPropertyObjectV2)));
}
public async Task WhenTheSameFieldIsReferencedMoreThanOnce_ForAGivenType_FieldsAreMerged_Correctly()
{
var server = new TestServerBuilder().AddGraphType <SimplePlanGenerationController>().Build();
// Property 1 is referenced in the query and in the fragment such that when spread prop1 would be included twice
// at the same level
//
// These two instnaces can be merged and Property 1 (for the TwoPropertyObject) should only end up in the plan once
var query = @"
query {
simple {
simpleQueryMethod {
property1
...methodProperties
}
}
}
fragment methodProperties on TwoPropertyObject {
property1
property2
}";
var parser = new GraphQLParser();
var syntaxTree = parser.ParseQueryDocument(query.AsMemory());
var planGenerator = new DefaultGraphQueryPlanGenerator <GraphSchema>(
server.Schema,
new DefaultGraphQueryDocumentGenerator <GraphSchema>(server.Schema),
new DefaultOperationComplexityCalculator <GraphSchema>());
var plan = await planGenerator.CreatePlan(syntaxTree);
Assert.IsNotNull(plan);
Assert.AreEqual(0, plan.Messages.Count);
// simple -> SimpleQueryMthod
var simpleQueryMethodField = plan.RetrieveOperation().FieldContexts[0].ChildContexts[0];
Assert.AreEqual(2, simpleQueryMethodField.ChildContexts.Count);
Assert.IsTrue(simpleQueryMethodField.ChildContexts.Any(x => x.Name == "property1"));
Assert.IsTrue(simpleQueryMethodField.ChildContexts.Any(x => x.Name == "property2"));
}
public static Query Parse(string query)
{
var parsed = GraphQLParser.parse(query);
if (parsed.Value == null)
{
throw new Exception("i dunno man");
}
if (!parsed.Value.IsQueryOperation)
{
throw new NotSupportedException("Only Query operations are currently supported");
}
var op = (GraphQLParser.Definition.QueryOperation)parsed.Value;
return(new Query
{
Name = op.Item.Item1,
Inputs = GetInputs(op.Item.Item2),
Fields = WalkSelection(op.Item.Item3)
});
}
public async Task SingleField_WithVariables_UsingDefaultValues_NestedInInputObjects_YieldsCorrectInputObject()
{
var server = new TestServerBuilder().AddGraphType <SimplePlanGenerationController>().Build();
// arg1 represents a TWoPropertyObjectV2 with a prop1 type of float
var parser = new GraphQLParser();
var syntaxTree = parser.ParseQueryDocument(@"query($var1 : Float! = 15.5)
{
simple {
complexQueryMethod(arg1: { property1: $var1, property2: 0} ) {
property1
}
}
}".AsMemory());
var planGenerator = new DefaultGraphQueryPlanGenerator <GraphSchema>(
server.Schema,
new DefaultGraphQueryDocumentGenerator <GraphSchema>(server.Schema),
new DefaultOperationComplexityCalculator <GraphSchema>());
var plan = await planGenerator.CreatePlan(syntaxTree);
Assert.IsNotNull(plan);
Assert.AreEqual(0, plan.Messages.Count);
Assert.AreEqual(1, plan.Operations.Count);
var queuedContext = plan.RetrieveOperation().FieldContexts[0];
Assert.AreEqual(1, queuedContext.ChildContexts.Count);
var child = queuedContext.ChildContexts[0];
// Ensure the variable $var1 is used as the value of property1
// using hte default value in the query
var arg1 = child.Arguments["arg1"];
Assert.IsNotNull(arg1);
}
public void StripInsignificantWhiteSpace_StripsAsExpected(string text, string output)
{
var parser = new GraphQLParser();
Assert.AreEqual(output, parser.StripInsignificantWhiteSpace(text));
}
public async Task SingleField_WithFragment_AndMultiLevelDirectives_ValidateDirectiveAssociations()
{
var server = new TestServerBuilder()
.AddGraphType <SimplePlanGenerationController>()
.AddGraphType <Sample1Directive>()
.AddGraphType <Sample2Directive>()
.AddGraphType <Sample3Directive>()
.Build();
var query = @"
query {
simple {
simpleQueryMethod {
...methodProperties @sample2
}
}
}
fragment methodProperties on TwoPropertyObject @sample1 {
property1 @sample3
property2
}";
var parser = new GraphQLParser();
var syntaxTree = parser.ParseQueryDocument(query.AsMemory());
var planGenerator = new DefaultGraphQueryPlanGenerator <GraphSchema>(
server.Schema,
new DefaultGraphQueryDocumentGenerator <GraphSchema>(server.Schema),
new DefaultOperationComplexityCalculator <GraphSchema>());
var plan = await planGenerator.CreatePlan(syntaxTree);
Assert.IsNotNull(plan);
Assert.AreEqual(1, plan.Operations.Count);
Assert.AreEqual(0, plan.Messages.Count);
// the "simple" virtual field queued to be resolved when the plan
// is executed
var queuedContext = plan.RetrieveOperation().FieldContexts[0];
Assert.IsNotNull(queuedContext);
Assert.AreEqual("simple", queuedContext.Name);
// simpleQueryMethod should contain 2 properties to be resolved (the two props on the fragment)
var child = queuedContext.ChildContexts[0];
Assert.IsNotNull(child);
Assert.AreEqual("simpleQueryMethod", child.Name);
Assert.AreEqual(2, child.ChildContexts.Count);
// "property1"
var prop1 = child.ChildContexts[0];
Assert.IsNotNull(prop1);
Assert.AreEqual(3, prop1.Directives.Count);
Assert.AreEqual("sample2", prop1.Directives[0].Directive.Name);
Assert.AreEqual("sample1", prop1.Directives[1].Directive.Name);
Assert.AreEqual("sample3", prop1.Directives[2].Directive.Name);
// "property2"
var prop2 = child.ChildContexts[1];
Assert.IsNotNull(prop2);
Assert.AreEqual(2, prop2.Directives.Count);
Assert.AreEqual("sample2", prop2.Directives[0].Directive.Name);
Assert.AreEqual("sample1", prop2.Directives[1].Directive.Name);
}
public async Task SingleField_WithFragment_ValidateFields()
{
var server = new TestServerBuilder().AddGraphType <SimplePlanGenerationController>().Build();
var query = @"
query {
simple {
simpleQueryMethod {
...methodProperties
}
}
}
fragment methodProperties on TwoPropertyObject {
property1
property2
}";
var parser = new GraphQLParser();
var syntaxTree = parser.ParseQueryDocument(query.AsMemory());
var planGenerator = new DefaultGraphQueryPlanGenerator <GraphSchema>(
server.Schema,
new DefaultGraphQueryDocumentGenerator <GraphSchema>(server.Schema),
new DefaultOperationComplexityCalculator <GraphSchema>());
var plan = await planGenerator.CreatePlan(syntaxTree);
Assert.IsNotNull(plan);
Assert.AreEqual(0, plan.Messages.Count);
Assert.AreEqual(1, plan.Operations.Count);
// the "simple" virtual field queued to be resolved when the plan
// is executed
var queuedContext = plan.RetrieveOperation().FieldContexts[0];
Assert.IsNotNull(queuedContext);
Assert.AreEqual("simple", queuedContext.Name);
// "simple" should contain 1 child field called "simpleQueryMethod"
Assert.AreEqual(0, queuedContext.Arguments.Count);
Assert.AreEqual(1, queuedContext.ChildContexts.Count);
Assert.IsTrue(queuedContext.Field?.Resolver is GraphRouteFieldResolver);
// simpleQueryMethod should contain 2 properties to be resolved (the two props on the fragment)
var child = queuedContext.ChildContexts[0];
Assert.IsNotNull(child);
Assert.AreEqual("simpleQueryMethod", child.Name);
Assert.AreEqual(2, child.ChildContexts.Count);
// the defaults defined on the method should have been assigned when none were supplied
// but both were optional.
Assert.AreEqual(2, child.Arguments.Count);
Assert.IsTrue(child.Field?.Resolver is GraphControllerActionResolver);
// "property1"
var prop1 = child.ChildContexts[0];
Assert.IsNotNull(prop1);
Assert.AreEqual("property1", prop1.Name);
Assert.AreEqual(0, prop1.ChildContexts.Count);
Assert.AreEqual(0, prop1.Arguments.Count);
Assert.IsTrue(prop1.Field?.Resolver is GraphObjectPropertyResolver);
// "property2"
var prop2 = child.ChildContexts[1];
Assert.IsNotNull(prop2);
Assert.AreEqual("property2", prop2.Name);
Assert.AreEqual(0, prop2.ChildContexts.Count);
Assert.AreEqual(0, prop2.Arguments.Count);
Assert.IsTrue(prop2.Field?.Resolver is GraphObjectPropertyResolver);
}
private static Document Build(
AntlrDocumentBuilder antlrDocumentBuilder,
string data )
{
using( MemoryStream memoryStream = new MemoryStream( Encoding.UTF8.GetBytes( data ) ) )
using( StreamReader streamReader = new StreamReader( memoryStream ) )
{
AntlrInputStream inputStream = new AntlrInputStream( streamReader );
GraphQLLexer lexer = new GraphQLLexer( inputStream );
if( antlrDocumentBuilder.LexerErrorListeners != null )
{
lexer.RemoveErrorListeners();
antlrDocumentBuilder.LexerErrorListeners.Apply( x => lexer.AddErrorListener( x ) );
}
CommonTokenStream tokenStream = new CommonTokenStream( lexer );
GraphQLParser parser = new GraphQLParser( tokenStream );
if( antlrDocumentBuilder.ParserErrorListeners != null )
{
parser.RemoveErrorListeners();
antlrDocumentBuilder.ParserErrorListeners.Apply( x => parser.AddErrorListener( x ) );
}
GraphQLVisitor vistor = new GraphQLVisitor();
return vistor.Visit( parser.document() ) as Document;
}
}
