added test for subscriptions parse errors

Author: remorses

subscription.go

@@ -54,7 +54,7 @@ func Subscribe(p Params) chan *Result {
 	if err != nil {
 
 		// merge the errors from extensions and the original error from parser
-		return sendOneResultandClose(&Result{
+		return sendOneResultAndClose(&Result{
 			Errors: gqlerrors.FormatErrors(err),
 		})
 	}
@@ -64,7 +64,7 @@ func Subscribe(p Params) chan *Result {
 
 	if !validationResult.IsValid {
 		// run validation finish functions for extensions
-		return sendOneResultandClose(&Result{
+		return sendOneResultAndClose(&Result{
 			Errors: validationResult.Errors,
 		})
 
@@ -79,8 +79,8 @@ func Subscribe(p Params) chan *Result {
 	})
 }
 
-func sendOneResultandClose(res *Result) chan *Result {
-	resultChannel := make(chan *Result)
+func sendOneResultAndClose(res *Result) chan *Result {
+	resultChannel := make(chan *Result, 1) // TODO unbuffered channel does not pass errors, why?
 	resultChannel <- res
 	close(resultChannel)
 	return resultChannel
@@ -113,7 +113,7 @@ func ExecuteSubscription(p ExecuteParams) chan *Result {
 					fmt.Println("strange program path")
 					return
 				}
-				sendOneResultandClose(&Result{
+				sendOneResultAndClose(&Result{
 					Errors: gqlerrors.FormatErrors(e),
 				})
 			}
@@ -132,15 +132,15 @@ func ExecuteSubscription(p ExecuteParams) chan *Result {
 		})
 
 		if err != nil {
-			sendOneResultandClose(&Result{
+			sendOneResultAndClose(&Result{
 				Errors: gqlerrors.FormatErrors(err),
 			})
 			return
 		}
 
 		operationType, err := getOperationRootType(p.Schema, exeContext.Operation)
 		if err != nil {
-			sendOneResultandClose(&Result{
+			sendOneResultAndClose(&Result{
 				Errors: gqlerrors.FormatErrors(err),
 			})
 			return
@@ -163,7 +163,7 @@ func ExecuteSubscription(p ExecuteParams) chan *Result {
 		fieldDef := getFieldDef(p.Schema, operationType, fieldName)
 
 		if fieldDef == nil {
-			sendOneResultandClose(&Result{
+			sendOneResultAndClose(&Result{
 				Errors: gqlerrors.FormatErrors(fmt.Errorf("the subscription field %q is not defined", fieldName)),
 			})
 			return
@@ -172,7 +172,7 @@ func ExecuteSubscription(p ExecuteParams) chan *Result {
 		resolveFn := fieldDef.Subscribe
 
 		if resolveFn == nil {
-			sendOneResultandClose(&Result{
+			sendOneResultAndClose(&Result{
 				Errors: gqlerrors.FormatErrors(fmt.Errorf("the subscription function %q is not defined", fieldName)),
 			})
 			return
@@ -202,14 +202,14 @@ func ExecuteSubscription(p ExecuteParams) chan *Result {
 			Context: p.Context,
 		})
 		if err != nil {
-			sendOneResultandClose(&Result{
+			sendOneResultAndClose(&Result{
 				Errors: gqlerrors.FormatErrors(err),
 			})
 			return
 		}
 
 		if fieldResult == nil {
-			sendOneResultandClose(&Result{
+			sendOneResultAndClose(&Result{
 				Errors: gqlerrors.FormatErrors(fmt.Errorf("no field result")),
 			})
 			return

subscription_test.go

@@ -83,14 +83,35 @@ func TestSchemaSubscribe(t *testing.T) {
 				{Data: `{ "sub_without_resolver": "c" }`},
 			},
 		},
+		{
+			Name: "receive parse error",
+			Schema: makeSubscriptionSchema(t, graphql.ObjectConfig{
+				Name: "Subscription",
+				Fields: graphql.Fields{
+					"sub_without_resolver": &graphql.Field{
+						Type:      graphql.String,
+						Subscribe: makeSubscribeToStringFunction([]string{"a", "b", "c"}),
+					},
+				},
+			}),
+			Query: `
+				subscription onHelloSaid {
+					sub_without_resolver
+					xxx
+				}
+			`,
+			ExpectedResults: []testutil.TestResponse{
+				{Errors: []string{"Cannot query field \"xxx\" on type \"Subscription\"."}},
+			},
+		},
 		{
 			Name: "subscribe with resolver changes output",
 			Schema: makeSubscriptionSchema(t, graphql.ObjectConfig{
 				Name: "Subscription",
 				Fields: graphql.Fields{
 					"sub_with_resolver": &graphql.Field{
 						Type:      graphql.String,
-						Subscribe: makeSubscribeToStringFunction([]string{"a", "b", "c"}),
+						Subscribe: makeSubscribeToStringFunction([]string{"a", "b", "c", "d"}),
 						Resolve: func(p graphql.ResolveParams) (interface{}, error) {
 							return fmt.Sprintf("result=%v", p.Source), nil
 						},
@@ -106,6 +127,7 @@ func TestSchemaSubscribe(t *testing.T) {
 				{Data: `{ "sub_with_resolver": "result=a" }`},
 				{Data: `{ "sub_with_resolver": "result=b" }`},
 				{Data: `{ "sub_with_resolver": "result=c" }`},
+				{Data: `{ "sub_with_resolver": "result=d" }`},
 			},
 		},
 		{

testutil/subscription.go

@@ -9,13 +9,12 @@ import (
 	"testing"
 
 	"github.com/graphql-go/graphql"
-	"github.com/graphql-go/graphql/gqlerrors"
 )
 
 // TestResponse models the expected response
 type TestResponse struct {
 	Data   string
-	Errors []gqlerrors.FormattedError
+	Errors []string
 }
 
 // TestSubscription is a GraphQL test case to be used with RunSubscribe.
@@ -26,7 +25,6 @@ type TestSubscription struct {
 	OperationName   string
 	Variables       map[string]interface{}
 	ExpectedResults []TestResponse
-	ExpectedErr     error
 }
 
 // RunSubscribes runs the given GraphQL subscription test cases as subtests.
@@ -75,15 +73,18 @@ func RunSubscribe(t *testing.T, test *TestSubscription) {
 		}
 		res := results[i]
 
-		checkErrorStrings(t, expected.Errors, res.Errors)
-
-		resData, err := json.MarshalIndent(res.Data, "", "  ")
-		if err != nil {
-			t.Fatal(err)
+		var errs []string
+		for _, err := range res.Errors {
+			errs = append(errs, err.Message)
 		}
+		checkErrorStrings(t, expected.Errors, errs)
+		if expected.Data == "" {
+			continue
+		}
+
 		got, err := json.MarshalIndent(res.Data, "", "  ")
 		if err != nil {
-			t.Fatalf("got: invalid JSON: %s; raw: %s", err, resData)
+			t.Fatalf("got: invalid JSON: %s; raw: %s", err, got)
 		}
 
 		if err != nil {
@@ -102,19 +103,19 @@ func RunSubscribe(t *testing.T, test *TestSubscription) {
 	}
 }
 
-func checkErrorStrings(t *testing.T, expected, actual []gqlerrors.FormattedError) {
+func checkErrorStrings(t *testing.T, expected, actual []string) {
 	expectedCount, actualCount := len(expected), len(actual)
 
 	if expectedCount != actualCount {
-		t.Fatalf("unexpected number of errors: want %d, got %d", expectedCount, actualCount)
+		t.Fatalf("unexpected number of errors: want `%d`, got `%d`", expectedCount, actualCount)
 	}
 
 	if expectedCount > 0 {
 		for i, want := range expected {
 			got := actual[i]
 
-			if got.Error() != want.Error() {
-				t.Fatalf("unexpected error: got %+v, want %+v", got, want)
+			if got != want {
+				t.Fatalf("unexpected error: got `%+v`, want `%+v`", got, want)
 			}
 		}