func Do(p Params) *Result {
source := source.NewSource(&source.Source{
Body: []byte(p.RequestString),
Name: "GraphQL request",
})
AST, err := parser.Parse(parser.ParseParams{Source: source})
if err != nil {
return &Result{
Errors: gqlerrors.FormatErrors(err),
}
}
validationResult := ValidateDocument(&p.Schema, AST, nil)
if !validationResult.IsValid {
return &Result{
Errors: validationResult.Errors,
}
}
return Execute(ExecuteParams{
Schema: p.Schema,
Root: p.RootObject,
AST: AST,
OperationName: p.OperationName,
Args: p.VariableValues,
Context: p.Context,
})
}
func expectInvalidRule(t *testing.T, schema *graphql.Schema, rules []graphql.ValidationRuleFn, queryString string, expectedErrors []gqlerrors.FormattedError) {
source := source.NewSource(&source.Source{
Body: []byte(queryString),
})
AST, err := parser.Parse(parser.ParseParams{Source: source})
if err != nil {
t.Fatal(err)
}
result := graphql.ValidateDocument(schema, AST, rules)
if len(result.Errors) != len(expectedErrors) {
t.Fatalf("Should have %v errors, got %v", len(expectedErrors), len(result.Errors))
}
if result.IsValid != false {
t.Fatalf("IsValid should be false, got %v", result.IsValid)
}
for _, expectedErr := range expectedErrors {
found := false
for _, err := range result.Errors {
if reflect.DeepEqual(expectedErr, err) {
found = true
break
}
}
if found == false {
t.Fatalf("Unexpected result, Diff: %v", Diff(expectedErrors, result.Errors))
}
}
}
func TestParseProvidesUsefulErrorsWhenUsingSource(t *testing.T) {
test := errorMessageTest{
source.NewSource(&source.Source{
Body: []byte("query"),
Name: "MyQuery.graphql",
}),
`Syntax Error MyQuery.graphql (1:6) Expected {, found EOF`,
false,
}
testErrorMessage(t, test)
}
func expectValid(t *testing.T, schema *graphql.Schema, queryString string) {
source := source.NewSource(&source.Source{
Body: []byte(queryString),
Name: "GraphQL request",
})
AST, err := parser.Parse(parser.ParseParams{Source: source})
if err != nil {
t.Fatalf("Unexpected error: %v", err)
}
validationResult := graphql.ValidateDocument(schema, AST, nil)
if !validationResult.IsValid || len(validationResult.Errors) > 0 {
t.Fatalf("Unexpected error: %v", validationResult.Errors)
}
}
func expectValidRule(t *testing.T, schema *graphql.Schema, rules []graphql.ValidationRuleFn, queryString string) {
source := source.NewSource(&source.Source{
Body: []byte(queryString),
})
AST, err := parser.Parse(parser.ParseParams{Source: source})
if err != nil {
t.Fatal(err)
}
result := graphql.ValidateDocument(schema, AST, rules)
if len(result.Errors) > 0 {
t.Fatalf("Should validate, got %v", result.Errors)
}
if result.IsValid != true {
t.Fatalf("IsValid should be true, got %v", result.IsValid)
}
}
func Parse(p ParseParams) (*ast.Document, error) {
var sourceObj *source.Source
switch p.Source.(type) {
case *source.Source:
sourceObj = p.Source.(*source.Source)
default:
body, _ := p.Source.(string)
sourceObj = source.NewSource(&source.Source{Body: []byte(body)})
}
parser, err := makeParser(sourceObj, p.Options)
if err != nil {
return nil, err
}
doc, err := parseDocument(parser)
if err != nil {
return nil, err
}
return doc, nil
}
// TODO: test and expose parseValue as a public
func parseValue(p ParseParams) (ast.Value, error) {
var value ast.Value
var sourceObj *source.Source
switch p.Source.(type) {
case *source.Source:
sourceObj = p.Source.(*source.Source)
default:
body, _ := p.Source.(string)
sourceObj = source.NewSource(&source.Source{Body: []byte(body)})
}
parser, err := makeParser(sourceObj, p.Options)
if err != nil {
return value, err
}
value, err = parseValueLiteral(parser, false)
if err != nil {
return value, err
}
return value, nil
}
func createSource(body string) *source.Source {
return source.NewSource(&source.Source{Body: []byte(body)})
}
func TestParseCreatesAst(t *testing.T) {
body := `{
node(id: 4) {
id,
name
}
}
`
source := source.NewSource(&source.Source{
Body: []byte(body),
})
document, err := Parse(
ParseParams{
Source: source,
Options: ParseOptions{
NoSource: true,
},
},
)
if err != nil {
t.Fatalf("unexpected error: %v", err)
}
oDef := ast.OperationDefinition{
Kind: "OperationDefinition",
Loc: &ast.Location{
Start: 0, End: 40,
},
Operation: "query",
Directives: []*ast.Directive{},
SelectionSet: &ast.SelectionSet{
Kind: "SelectionSet",
Loc: &ast.Location{
Start: 0, End: 40,
},
Selections: []ast.Selection{
&ast.Field{
Kind: "Field",
Loc: &ast.Location{
Start: 4, End: 38,
},
Name: &ast.Name{
Kind: "Name",
Loc: &ast.Location{
Start: 4, End: 8,
},
Value: "node",
},
Arguments: []*ast.Argument{
{
Kind: "Argument",
Name: &ast.Name{
Kind: "Name",
Loc: &ast.Location{
Start: 9, End: 11,
},
Value: "id",
},
Value: &ast.IntValue{
Kind: "IntValue",
Loc: &ast.Location{
Start: 13, End: 14,
},
Value: "4",
},
Loc: &ast.Location{
Start: 9, End: 14,
},
},
},
Directives: []*ast.Directive{},
SelectionSet: &ast.SelectionSet{
Kind: "SelectionSet",
Loc: &ast.Location{
Start: 16, End: 38,
},
Selections: []ast.Selection{
&ast.Field{
Kind: "Field",
Loc: &ast.Location{
Start: 22, End: 24,
},
Name: &ast.Name{
Kind: "Name",
Loc: &ast.Location{
Start: 22, End: 24,
},
Value: "id",
},
Arguments: []*ast.Argument{},
Directives: []*ast.Directive{},
SelectionSet: nil,
},
&ast.Field{
Kind: "Field",
Loc: &ast.Location{
Start: 30, End: 34,
},
Name: &ast.Name{
Kind: "Name",
Loc: &ast.Location{
Start: 30, End: 34,
},
Value: "name",
},
Arguments: []*ast.Argument{},
Directives: []*ast.Directive{},
SelectionSet: nil,
},
},
},
},
},
},
}
expectedDocument := ast.NewDocument(&ast.Document{
Loc: &ast.Location{
Start: 0, End: 41,
},
Definitions: []ast.Node{&oDef},
})
if !reflect.DeepEqual(document, expectedDocument) {
t.Fatalf("unexpected document, expected: %v, got: %v", expectedDocument, document.Definitions)
}
}