schema.parseUnionDef does not panic on invalid syntax

[ssko1]

Overview

I was writing tests for #444 and noticed that parseUnionDef fails for a specific use case.

Current Behavior

Given the following union definition snippet

Foo = Bar Qux | Quux

And a small test snippet

func TestUnionFailCase(t *testing.T) {
	definition := "Foo = Bar Qux | Quux"

	lex := common.NewLexer(definition, false)
	lex.ConsumeWhitespace()

	func() {
		defer func() {
			if r := recover(); r == nil {
				t.Fatal("Test should panic, but didn't")
			}
		}()
		union := parseUnionDef(lex)
		fmt.Printf("union name: %q\n", union.Name)
		fmt.Printf("union typenames: %v\n", union.TypeNames)
	}()
}

The test produces an output:

=== RUN   TestUnionFailCase
union name: "Foo"
union typenames: [Bar]
    schema_internal_test.go:139: Test should panic, but didn't
--- FAIL: TestUnionFailCase (0.00s)
FAIL

Expected Behavior

parseUnionDef should panic and the test case should pass, but it does not. The syntax in the union definition snippet is invalid.

[pavelnikolov]

@ssko1 Thank you very much for the unit test!

[suessflorian]

Hey, this issue still unowned? Keen to give this a shot.

[pavelnikolov]

Go for it. PRs are welcome.

[suessflorian]

Hey @pavelnikolov - only got a chance to look at this now and after a brief look I believe things are working as expected. I'll provide some sort of proof and then we can get this closed ay 💪

Lets go with the example with a simple schema example;

union Foo = Bar Qux | Quux

schema.parseSchema will switch on the gql keyword union and invoke parseUnionDef

func parseUnionDef(l *common.Lexer) *types.Union {
	union := &types.Union{Loc: l.Location(), Name: l.ConsumeIdent()}

	union.Directives = common.ParseDirectives(l)
	l.ConsumeToken('=')
	union.TypeNames = []string{l.ConsumeIdent()}
	for l.Peek() == '|' {
		l.ConsumeToken('|')
		union.TypeNames = append(union.TypeNames, l.ConsumeIdent())
	}

	return union
}

This function will correctly consume union Foo = Bar leaving Qux | Quux on the Lexer, returned to schema.parseSchema where identifier Qux will re-enter the switch and, as it should, hit the syntax error:

unexpected 'Qux', expecting "schema", "type", "enum", "interface", "union", "input", "scalar" or "directive"

---

Am I right in concluding we should leave this as is? In fact, it's exactly to spec, as GraphQL is kinda newline/whitespace agnostic (so trying to wait until a new line char is reached or such to enrich error message will not work)

[suessflorian]

You can verify this by playing around with the test here for example;

graphql-go/internal/schema/schema_test.go

Line 582 in 446a2dd

name: "Extend union contains type",

Just append to the union type in the test case sdl 👍