Exemple #1
0
func parseInputValueDef(parser *Parser) (interface{}, error) {
	start := parser.Token.Start
	name, err := parseName(parser)
	if err != nil {
		return nil, err
	}
	_, err = expect(parser, lexer.TokenKind[lexer.COLON])
	if err != nil {
		return nil, err
	}
	ttype, err := parseType(parser)
	if err != nil {
		return nil, err
	}
	var defaultValue ast.Value
	if skip(parser, lexer.TokenKind[lexer.EQUALS]) {
		defaultValue, err = parseConstValue(parser)
		if err != nil {
			return nil, err
		}
	}
	return ast.NewInputValueDefinition(&ast.InputValueDefinition{
		Name:         name,
		Type:         ttype,
		DefaultValue: defaultValue,
		Loc:          loc(parser, start),
	}), nil
}
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 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_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)
	}
}