func TestSchemaParser_UnionWithTwoTypes(t *testing.T) {
body := `union Hello = Wo | Rld`
astDoc := parse(t, body)
expected := ast.NewDocument(&ast.Document{
Loc: loc(0, 22),
Definitions: []ast.Node{
ast.NewUnionTypeDefinition(&ast.UnionTypeDefinition{
Loc: loc(0, 22),
Name: ast.NewName(&ast.Name{
Value: "Hello",
Loc: loc(6, 11),
}),
Types: []*ast.NamedType{
ast.NewNamedType(&ast.NamedType{
Loc: loc(14, 16),
Name: ast.NewName(&ast.Name{
Value: "Wo",
Loc: loc(14, 16),
}),
}),
ast.NewNamedType(&ast.NamedType{
Loc: loc(19, 22),
Name: ast.NewName(&ast.Name{
Value: "Rld",
Loc: loc(19, 22),
}),
}),
},
}),
},
})
if !reflect.DeepEqual(astDoc, expected) {
t.Fatalf("unexpected document, expected: %v, got: %v", expected, astDoc)
}
}
func TestSchemaParser_DoubleValueEnum(t *testing.T) {
body := `enum Hello { WO, RLD }`
astDoc := parse(t, body)
expected := ast.NewDocument(&ast.Document{
Loc: loc(0, 22),
Definitions: []ast.Node{
ast.NewEnumTypeDefinition(&ast.EnumTypeDefinition{
Loc: loc(0, 22),
Name: ast.NewName(&ast.Name{
Value: "Hello",
Loc: loc(5, 10),
}),
Values: []*ast.EnumValueDefinition{
ast.NewEnumValueDefinition(&ast.EnumValueDefinition{
Name: ast.NewName(&ast.Name{
Value: "WO",
Loc: loc(13, 15),
}),
Loc: loc(13, 15),
}),
ast.NewEnumValueDefinition(&ast.EnumValueDefinition{
Name: ast.NewName(&ast.Name{
Value: "RLD",
Loc: loc(17, 20),
}),
Loc: loc(17, 20),
}),
},
}),
},
})
if !reflect.DeepEqual(astDoc, expected) {
t.Fatalf("unexpected document, expected: %v, got: %v", expected, astDoc)
}
}
func TestSchemaParser_SimpleTypeInheritingInterface(t *testing.T) {
body := `type Hello implements World { }`
astDoc := parse(t, body)
expected := ast.NewDocument(&ast.Document{
Loc: loc(0, 31),
Definitions: []ast.Node{
ast.NewObjectTypeDefinition(&ast.ObjectTypeDefinition{
Loc: loc(0, 31),
Name: ast.NewName(&ast.Name{
Value: "Hello",
Loc: loc(5, 10),
}),
Interfaces: []*ast.NamedType{
ast.NewNamedType(&ast.NamedType{
Name: ast.NewName(&ast.Name{
Value: "World",
Loc: loc(22, 27),
}),
Loc: loc(22, 27),
}),
},
Fields: []*ast.FieldDefinition{},
}),
},
})
if !reflect.DeepEqual(astDoc, expected) {
t.Fatalf("unexpected document, expected: %v, got: %v", expected, astDoc)
}
}
func TestSchemaParser_SimpleFieldWithListArg(t *testing.T) {
body := `
type Hello {
world(things: [String]): String
}`
astDoc := parse(t, body)
expected := ast.NewDocument(&ast.Document{
Loc: loc(1, 49),
Definitions: []ast.Node{
ast.NewObjectTypeDefinition(&ast.ObjectTypeDefinition{
Loc: loc(1, 49),
Name: ast.NewName(&ast.Name{
Value: "Hello",
Loc: loc(6, 11),
}),
Interfaces: []*ast.NamedType{},
Fields: []*ast.FieldDefinition{
ast.NewFieldDefinition(&ast.FieldDefinition{
Loc: loc(16, 47),
Name: ast.NewName(&ast.Name{
Value: "world",
Loc: loc(16, 21),
}),
Arguments: []*ast.InputValueDefinition{
ast.NewInputValueDefinition(&ast.InputValueDefinition{
Loc: loc(22, 38),
Name: ast.NewName(&ast.Name{
Value: "things",
Loc: loc(22, 28),
}),
Type: ast.NewListType(&ast.ListType{
Loc: loc(30, 38),
Type: ast.NewNamedType(&ast.NamedType{
Loc: loc(31, 37),
Name: ast.NewName(&ast.Name{
Value: "String",
Loc: loc(31, 37),
}),
}),
}),
DefaultValue: nil,
}),
},
Type: ast.NewNamedType(&ast.NamedType{
Loc: loc(41, 47),
Name: ast.NewName(&ast.Name{
Value: "String",
Loc: loc(41, 47),
}),
}),
}),
},
}),
},
})
if !reflect.DeepEqual(astDoc, expected) {
t.Fatalf("unexpected document, expected: %v, got: %v", expected, astDoc)
}
}
func TestSchemaParser_SimpleFieldWithArgWithDefaultValue(t *testing.T) {
body := `
type Hello {
world(flag: Boolean = true): String
}`
astDoc := parse(t, body)
expected := ast.NewDocument(&ast.Document{
Loc: loc(1, 53),
Definitions: []ast.Node{
ast.NewObjectTypeDefinition(&ast.ObjectTypeDefinition{
Loc: loc(1, 53),
Name: ast.NewName(&ast.Name{
Value: "Hello",
Loc: loc(6, 11),
}),
Interfaces: []*ast.NamedType{},
Fields: []*ast.FieldDefinition{
ast.NewFieldDefinition(&ast.FieldDefinition{
Loc: loc(16, 51),
Name: ast.NewName(&ast.Name{
Value: "world",
Loc: loc(16, 21),
}),
Arguments: []*ast.InputValueDefinition{
ast.NewInputValueDefinition(&ast.InputValueDefinition{
Loc: loc(22, 42),
Name: ast.NewName(&ast.Name{
Value: "flag",
Loc: loc(22, 26),
}),
Type: ast.NewNamedType(&ast.NamedType{
Loc: loc(28, 35),
Name: ast.NewName(&ast.Name{
Value: "Boolean",
Loc: loc(28, 35),
}),
}),
DefaultValue: ast.NewBooleanValue(&ast.BooleanValue{
Value: true,
Loc: loc(38, 42),
}),
}),
},
Type: ast.NewNamedType(&ast.NamedType{
Loc: loc(45, 51),
Name: ast.NewName(&ast.Name{
Value: "String",
Loc: loc(45, 51),
}),
}),
}),
},
}),
},
})
if !reflect.DeepEqual(astDoc, expected) {
t.Fatalf("unexpected document, expected: %v, got: %v", expected, astDoc)
}
}
func TestAcceptsOptionToNotIncludeSource(t *testing.T) {
opts := ParseOptions{
NoSource: true,
}
params := ParseParams{
Source: "{ field }",
Options: opts,
}
document, err := Parse(params)
if err != nil {
t.Fatalf("unexpected error: %v", err)
}
oDef := ast.OperationDefinition{
Kind: "OperationDefinition",
Loc: &ast.Location{
Start: 0, End: 9,
},
Operation: "query",
Directives: []*ast.Directive{},
SelectionSet: &ast.SelectionSet{
Kind: "SelectionSet",
Loc: &ast.Location{
Start: 0, End: 9,
},
Selections: []ast.Selection{
&ast.Field{
Kind: "Field",
Loc: &ast.Location{
Start: 2, End: 7,
},
Name: &ast.Name{
Kind: "Name",
Loc: &ast.Location{
Start: 2, End: 7,
},
Value: "field",
},
Arguments: []*ast.Argument{},
Directives: []*ast.Directive{},
},
},
},
}
expectedDocument := ast.NewDocument(&ast.Document{
Loc: &ast.Location{
Start: 0, End: 9,
},
Definitions: []ast.Node{&oDef},
})
if !reflect.DeepEqual(document, expectedDocument) {
t.Fatalf("unexpected document, expected: %v, got: %v", expectedDocument, document)
}
}
func TestSchemaParser_SimpleNonNullType(t *testing.T) {
body := `
type Hello {
world: String!
}`
astDoc := parse(t, body)
expected := ast.NewDocument(&ast.Document{
Loc: loc(1, 32),
Definitions: []ast.Node{
ast.NewObjectTypeDefinition(&ast.ObjectTypeDefinition{
Loc: loc(1, 32),
Name: ast.NewName(&ast.Name{
Value: "Hello",
Loc: loc(6, 11),
}),
Interfaces: []*ast.NamedType{},
Fields: []*ast.FieldDefinition{
ast.NewFieldDefinition(&ast.FieldDefinition{
Loc: loc(16, 30),
Name: ast.NewName(&ast.Name{
Value: "world",
Loc: loc(16, 21),
}),
Arguments: []*ast.InputValueDefinition{},
Type: ast.NewNonNullType(&ast.NonNullType{
Kind: "NonNullType",
Loc: loc(23, 30),
Type: ast.NewNamedType(&ast.NamedType{
Loc: loc(23, 29),
Name: ast.NewName(&ast.Name{
Value: "String",
Loc: loc(23, 29),
}),
}),
}),
}),
},
}),
},
})
if !reflect.DeepEqual(astDoc, expected) {
t.Fatalf("unexpected document, expected: %v, got: %v", expected, astDoc)
}
}
func TestSchemaParser_SimpleExtension(t *testing.T) {
body := `
extend type Hello {
world: String
}`
astDoc := parse(t, body)
expected := ast.NewDocument(&ast.Document{
Loc: loc(1, 38),
Definitions: []ast.Node{
ast.NewTypeExtensionDefinition(&ast.TypeExtensionDefinition{
Loc: loc(1, 38),
Definition: ast.NewObjectTypeDefinition(&ast.ObjectTypeDefinition{
Loc: loc(8, 38),
Name: ast.NewName(&ast.Name{
Value: "Hello",
Loc: loc(13, 18),
}),
Interfaces: []*ast.NamedType{},
Fields: []*ast.FieldDefinition{
ast.NewFieldDefinition(&ast.FieldDefinition{
Loc: loc(23, 36),
Name: ast.NewName(&ast.Name{
Value: "world",
Loc: loc(23, 28),
}),
Arguments: []*ast.InputValueDefinition{},
Type: ast.NewNamedType(&ast.NamedType{
Loc: loc(30, 36),
Name: ast.NewName(&ast.Name{
Value: "String",
Loc: loc(30, 36),
}),
}),
}),
},
}),
}),
},
})
if !reflect.DeepEqual(astDoc, expected) {
t.Fatalf("unexpected document, expected: %v, got: %v", expected, astDoc)
}
}
func TestSchemaParser_Scalar(t *testing.T) {
body := `scalar Hello`
astDoc := parse(t, body)
expected := ast.NewDocument(&ast.Document{
Loc: loc(0, 12),
Definitions: []ast.Node{
ast.NewScalarTypeDefinition(&ast.ScalarTypeDefinition{
Loc: loc(0, 12),
Name: ast.NewName(&ast.Name{
Value: "Hello",
Loc: loc(7, 12),
}),
}),
},
})
if !reflect.DeepEqual(astDoc, expected) {
t.Fatalf("unexpected document, expected: %v, got: %v", expected, astDoc)
}
}
func TestSchemaParser_SimpleInputObject(t *testing.T) {
body := `
input Hello {
world: String
}`
astDoc := parse(t, body)
expected := ast.NewDocument(&ast.Document{
Loc: loc(1, 32),
Definitions: []ast.Node{
ast.NewInputObjectTypeDefinition(&ast.InputObjectTypeDefinition{
Loc: loc(1, 32),
Name: ast.NewName(&ast.Name{
Value: "Hello",
Loc: loc(7, 12),
}),
Fields: []*ast.InputValueDefinition{
ast.NewInputValueDefinition(&ast.InputValueDefinition{
Loc: loc(17, 30),
Name: ast.NewName(&ast.Name{
Value: "world",
Loc: loc(17, 22),
}),
Type: ast.NewNamedType(&ast.NamedType{
Loc: loc(24, 30),
Name: ast.NewName(&ast.Name{
Value: "String",
Loc: loc(24, 30),
}),
}),
DefaultValue: nil,
}),
},
}),
},
})
if !reflect.DeepEqual(astDoc, expected) {
t.Fatalf("unexpected document, expected: %v, got: %v", expected, astDoc)
}
}
func TestSchemaParser_SimpleInterface(t *testing.T) {
body := `
interface Hello {
world: String
}`
astDoc := parse(t, body)
expected := ast.NewDocument(&ast.Document{
Loc: loc(1, 36),
Definitions: []ast.Node{
ast.NewInterfaceTypeDefinition(&ast.InterfaceTypeDefinition{
Loc: loc(1, 36),
Name: ast.NewName(&ast.Name{
Value: "Hello",
Loc: loc(11, 16),
}),
Fields: []*ast.FieldDefinition{
ast.NewFieldDefinition(&ast.FieldDefinition{
Loc: loc(21, 34),
Name: ast.NewName(&ast.Name{
Value: "world",
Loc: loc(21, 26),
}),
Arguments: []*ast.InputValueDefinition{},
Type: ast.NewNamedType(&ast.NamedType{
Loc: loc(28, 34),
Name: ast.NewName(&ast.Name{
Value: "String",
Loc: loc(28, 34),
}),
}),
}),
},
}),
},
})
if !reflect.DeepEqual(astDoc, expected) {
t.Fatalf("unexpected document, expected: %v, got: %v", expected, astDoc)
}
}
func parseDocument(parser *Parser) (*ast.Document, error) {
start := parser.Token.Start
var nodes []ast.Node
for {
if skip(parser, lexer.TokenKind[lexer.EOF]) {
break
}
if peek(parser, lexer.TokenKind[lexer.BRACE_L]) {
node, err := parseOperationDefinition(parser)
if err != nil {
return nil, err
}
nodes = append(nodes, node)
} else if peek(parser, lexer.TokenKind[lexer.NAME]) {
switch parser.Token.Value {
case "query":
fallthrough
case "mutation":
fallthrough
case "subscription": // Note: subscription is an experimental non-spec addition.
node, err := parseOperationDefinition(parser)
if err != nil {
return nil, err
}
nodes = append(nodes, node)
case "fragment":
node, err := parseFragmentDefinition(parser)
if err != nil {
return nil, err
}
nodes = append(nodes, node)
case "type":
node, err := parseObjectTypeDefinition(parser)
if err != nil {
return nil, err
}
nodes = append(nodes, node)
case "interface":
node, err := parseInterfaceTypeDefinition(parser)
if err != nil {
return nil, err
}
nodes = append(nodes, node)
case "union":
node, err := parseUnionTypeDefinition(parser)
if err != nil {
return nil, err
}
nodes = append(nodes, node)
case "scalar":
node, err := parseScalarTypeDefinition(parser)
if err != nil {
return nil, err
}
nodes = append(nodes, node)
case "enum":
node, err := parseEnumTypeDefinition(parser)
if err != nil {
return nil, err
}
nodes = append(nodes, node)
case "input":
node, err := parseInputObjectTypeDefinition(parser)
if err != nil {
return nil, err
}
nodes = append(nodes, node)
case "extend":
node, err := parseTypeExtensionDefinition(parser)
if err != nil {
return nil, err
}
nodes = append(nodes, node)
default:
if err := unexpected(parser, lexer.Token{}); err != nil {
return nil, err
}
}
} else {
if err := unexpected(parser, lexer.Token{}); err != nil {
return nil, err
}
}
}
return ast.NewDocument(&ast.Document{
Loc: loc(parser, start),
Definitions: nodes,
}), nil
}
func TestParseCreatesAst(t *testing.T) {
body := `{
node(id: 4) {
id,
name
}
}
`
source := source.NewSource(&source.Source{Body: 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)
}
}
func TestSchemaParser_SimpleFieldWithTwoArg(t *testing.T) {
body := `
type Hello {
world(argOne: Boolean, argTwo: Int): String
}`
astDoc := parse(t, body)
expected := ast.NewDocument(&ast.Document{
Loc: loc(1, 61),
Definitions: []ast.Node{
ast.NewObjectTypeDefinition(&ast.ObjectTypeDefinition{
Loc: loc(1, 61),
Name: ast.NewName(&ast.Name{
Value: "Hello",
Loc: loc(6, 11),
}),
Interfaces: []*ast.NamedType{},
Fields: []*ast.FieldDefinition{
ast.NewFieldDefinition(&ast.FieldDefinition{
Loc: loc(16, 59),
Name: ast.NewName(&ast.Name{
Value: "world",
Loc: loc(16, 21),
}),
Arguments: []*ast.InputValueDefinition{
ast.NewInputValueDefinition(&ast.InputValueDefinition{
Loc: loc(22, 37),
Name: ast.NewName(&ast.Name{
Value: "argOne",
Loc: loc(22, 28),
}),
Type: ast.NewNamedType(&ast.NamedType{
Loc: loc(30, 37),
Name: ast.NewName(&ast.Name{
Value: "Boolean",
Loc: loc(30, 37),
}),
}),
DefaultValue: nil,
}),
ast.NewInputValueDefinition(&ast.InputValueDefinition{
Loc: loc(39, 50),
Name: ast.NewName(&ast.Name{
Value: "argTwo",
Loc: loc(39, 45),
}),
Type: ast.NewNamedType(&ast.NamedType{
Loc: loc(47, 50),
Name: ast.NewName(&ast.Name{
Value: "Int",
Loc: loc(47, 50),
}),
}),
DefaultValue: nil,
}),
},
Type: ast.NewNamedType(&ast.NamedType{
Loc: loc(53, 59),
Name: ast.NewName(&ast.Name{
Value: "String",
Loc: loc(53, 59),
}),
}),
}),
},
}),
},
})
if !reflect.DeepEqual(astDoc, expected) {
t.Fatalf("unexpected document, expected: %v, got: %v", expected, astDoc)
}
}