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