Refactoring: not to use global rule sets (part 2) (#380)

* Refactor validator to resolve import cycles and add rule-based validation

* Implement LoadQueryWithRules, MustLoadQueryWithRules

* run go fmt and fix golangcilint

* fix test case

* fix golangcilint

* suppress lints

Author: tomoikey

gqlparser.go

@@ -5,9 +5,7 @@ import (
 	"github.com/vektah/gqlparser/v2/gqlerror"
 	"github.com/vektah/gqlparser/v2/parser"
 	"github.com/vektah/gqlparser/v2/validator"
-
-	// Blank import is used to load up the validator rules.
-	_ "github.com/vektah/gqlparser/v2/validator/rules"
+	"github.com/vektah/gqlparser/v2/validator/rules"
 )
 
 func LoadSchema(str ...*ast.Source) (*ast.Schema, error) {
@@ -30,6 +28,7 @@ func MustLoadSchema(str ...*ast.Source) *ast.Schema {
 	return s
 }
 
+// Deprecated: use LoadQueryWithRules instead.
 func LoadQuery(schema *ast.Schema, str string) (*ast.QueryDocument, gqlerror.List) {
 	query, err := parser.ParseQuery(&ast.Source{Input: str})
 	if err != nil {
@@ -47,10 +46,36 @@ func LoadQuery(schema *ast.Schema, str string) (*ast.QueryDocument, gqlerror.Lis
 	return query, nil
 }
 
+func LoadQueryWithRules(schema *ast.Schema, str string, rules *rules.Rules) (*ast.QueryDocument, gqlerror.List) {
+	query, err := parser.ParseQuery(&ast.Source{Input: str})
+	if err != nil {
+		gqlErr, ok := err.(*gqlerror.Error)
+		if ok {
+			return nil, gqlerror.List{gqlErr}
+		}
+		return nil, gqlerror.List{gqlerror.Wrap(err)}
+	}
+	errs := validator.ValidateWithRules(schema, query, rules)
+	if len(errs) > 0 {
+		return nil, errs
+	}
+
+	return query, nil
+}
+
+// Deprecated: use MustLoadQueryWithRules instead.
 func MustLoadQuery(schema *ast.Schema, str string) *ast.QueryDocument {
 	q, err := LoadQuery(schema, str)
 	if err != nil {
 		panic(err)
 	}
 	return q
 }
+
+func MustLoadQueryWithRules(schema *ast.Schema, str string, rules *rules.Rules) *ast.QueryDocument {
+	q, err := LoadQueryWithRules(schema, str, rules)
+	if err != nil {
+		panic(err)
+	}
+	return q
+}

validator/imported_test.go

@@ -59,6 +59,7 @@ func TestValidation(t *testing.T) {
 		}
 
 		runSpec(t, schemas, deviations, path)
+		runSpecWithRules(t, schemas, deviations, path)
 		return nil
 	})
 	require.NoError(t, err)
@@ -97,6 +98,7 @@ func runSpec(t *testing.T, schemas []*ast.Schema, deviations []*Deviation, filen
 				} else {
 					schema = schemas[idx]
 				}
+				//nolint:staticcheck
 				_, errList := gqlparser.LoadQuery(schema, spec.Query)
 				var finalErrors gqlerror.List
 				for _, err := range errList {
@@ -161,6 +163,103 @@ func runSpec(t *testing.T, schemas []*ast.Schema, deviations []*Deviation, filen
 	})
 }
 
+func runSpecWithRules(t *testing.T, schemas []*ast.Schema, deviations []*Deviation, filename string) {
+	ruleName := strings.TrimSuffix(filepath.Base(filename), ".spec.yml")
+
+	var specs []Spec
+	readYaml(filename, &specs)
+	t.Run(ruleName, func(t *testing.T) {
+		for _, spec := range specs {
+			if len(spec.Errors) == 0 {
+				spec.Errors = nil
+			}
+			t.Run(spec.Name, func(t *testing.T) {
+				for _, deviation := range deviations {
+					if deviation.pattern.MatchString(ruleName + "/" + spec.Name) {
+						if deviation.Skip != "" {
+							t.Skip(deviation.Skip)
+						}
+						if deviation.Errors != nil {
+							spec.Errors = deviation.Errors
+						}
+					}
+				}
+
+				// idx := spec.Schema
+				var schema *ast.Schema
+				if idx, err := strconv.Atoi(spec.Schema); err != nil {
+					var gqlErr error
+					schema, gqlErr = gqlparser.LoadSchema(&ast.Source{Input: spec.Schema, Name: spec.Name})
+					if gqlErr != nil {
+						t.Fatal(err)
+					}
+				} else {
+					schema = schemas[idx]
+				}
+				_, errList := gqlparser.LoadQueryWithRules(schema, spec.Query, nil)
+				var finalErrors gqlerror.List
+				for _, err := range errList {
+					// ignore errors from other rules
+					if spec.Rule != "" && err.Rule != spec.Rule {
+						continue
+					}
+					finalErrors = append(finalErrors, err)
+				}
+
+				for i := range spec.Errors {
+					spec.Errors[i].Rule = spec.Rule
+
+					// remove inconsistent use of ;
+					spec.Errors[i].Message = strings.ReplaceAll(spec.Errors[i].Message, "; Did you mean", ". Did you mean")
+				}
+				sort.Slice(spec.Errors, compareErrors(spec.Errors))
+				sort.Slice(finalErrors, compareErrors(finalErrors))
+
+				if len(finalErrors) != len(spec.Errors) {
+					t.Errorf("wrong number of errors returned\ngot:\n%s\nwant:\n%s", finalErrors.Error(), spec.Errors)
+				} else {
+					for i := range spec.Errors {
+						expected := spec.Errors[i]
+						actual := finalErrors[i]
+						if actual.Rule != spec.Rule {
+							continue
+						}
+						var errLocs []string
+						if expected.Message != actual.Message {
+							errLocs = append(errLocs, "message mismatch")
+						}
+						if len(expected.Locations) > 0 && len(actual.Locations) == 0 {
+							errLocs = append(errLocs, "missing location")
+						}
+						if len(expected.Locations) > 0 && len(actual.Locations) > 0 {
+							found := false
+							for _, loc := range expected.Locations {
+								if actual.Locations[0].Line == loc.Line {
+									found = true
+									break
+								}
+							}
+
+							if !found {
+								errLocs = append(errLocs, "line")
+							}
+						}
+
+						if len(errLocs) > 0 {
+							t.Errorf("%s\ngot:  %s\nwant: %s", strings.Join(errLocs, ", "), finalErrors[i].Error(), spec.Errors[i].Error())
+						}
+					}
+				}
+
+				if t.Failed() {
+					t.Logf("name: '%s'", spec.Name)
+					t.Log("\nquery:", spec.Query)
+				}
+			})
+		}
+	})
+}
+
 func compareErrors(errors gqlerror.List) func(i, j int) bool {
 	return func(i, j int) bool {
 		cmp := strings.Compare(errors[i].Message, errors[j].Message)

validator/validator.go

@@ -76,6 +76,7 @@ func ReplaceRule(name string, ruleFunc RuleFunc) {
 	specifiedRules = result
 }
 
+// Deprecated: use ValidateWithRules instead.
 func Validate(schema *Schema, doc *QueryDocument, rules ...Rule) gqlerror.List {
 	if rules == nil {
 		rules = specifiedRules
@@ -108,3 +109,35 @@ func Validate(schema *Schema, doc *QueryDocument, rules ...Rule) gqlerror.List {
 	Walk(schema, doc, observers)
 	return errs
 }
+
+func ValidateWithRules(schema *Schema, doc *QueryDocument, rules *validatorrules.Rules) gqlerror.List {
+	if rules == nil {
+		rules = validatorrules.NewDefaultRules()
+	}
+
+	var errs gqlerror.List
+	if schema == nil {
+		errs = append(errs, gqlerror.Errorf("cannot validate as Schema is nil"))
+	}
+	if doc == nil {
+		errs = append(errs, gqlerror.Errorf("cannot validate as QueryDocument is nil"))
+	}
+	if len(errs) > 0 {
+		return errs
+	}
+	observers := &core.Events{}
+	for name, ruleFunc := range rules.GetInner() {
+		ruleFunc(observers, func(options ...ErrorOption) {
+			err := &gqlerror.Error{
+				Rule: name,
+			}
+			for _, o := range options {
+				o(err)
+			}
+			errs = append(errs, err)
+		})
+	}
+
+	Walk(schema, doc, observers)
+	return errs
+}