From d8a81106031a3ac5d8c1d84aa5b3b8cf94ddeb70 Mon Sep 17 00:00:00 2001 From: Ruona Onobrakpeya Date: Sun, 29 Sep 2024 00:27:46 +0100 Subject: [PATCH 1/7] Extended the `@sqlc-vet-disable` flag to support the skipping of provided rules. This is an update to the original behaviour which had an "all-or-nothing" behaviour, either running all the rules on a query or skipping them all. Specified rules which aren't declared in the sqlc config file get rejected. --- internal/cmd/vet.go | 138 +++++++++++++++++++++---------------- internal/compiler/parse.go | 2 +- internal/metadata/meta.go | 24 ++++++- 3 files changed, 101 insertions(+), 63 deletions(-) diff --git a/internal/cmd/vet.go b/internal/cmd/vet.go index fe3f3b6bdc..0283a64442 100644 --- a/internal/cmd/vet.go +++ b/internal/cmd/vet.go @@ -11,6 +11,7 @@ import ( "os" "path/filepath" "runtime/trace" + "slices" "strings" "time" @@ -538,11 +539,23 @@ func (c *checker) checkSQL(ctx context.Context, s config.SQL) error { req := codeGenRequest(result, combo) cfg := vetConfig(req) for i, query := range req.Queries { - if result.Queries[i].Metadata.Flags[QueryFlagSqlcVetDisable] { - if debug.Active { - log.Printf("Skipping vet rules for query: %s\n", query.Name) + md := result.Queries[i].Metadata + if md.Flags[QueryFlagSqlcVetDisable] { + // If the vet disable flag is specified without any rules listed, all rules are ignored. + if len(md.RuleSkiplist) == 0 { + if debug.Active { + log.Printf("Skipping all vet rules for query: %s\n", query.Name) + } + continue + } + + // Rules which are listed to be disabled but not declared in the config file are rejected. + for r := range md.RuleSkiplist { + if !slices.Contains(s.Rules, r) { + fmt.Fprintf(c.Stderr, "%s: %s: rule-check error: rule %q does not exist in the config file\n", query.Filename, query.Name, r) + errored = true + } } - continue } evalMap := map[string]any{ @@ -551,74 +564,81 @@ func (c *checker) checkSQL(ctx context.Context, s config.SQL) error { } for _, name := range s.Rules { - rule, ok := c.Rules[name] - if !ok { - return fmt.Errorf("type-check error: a rule with the name '%s' does not exist", name) - } - - if rule.NeedsPrepare { - if prep == nil { - fmt.Fprintf(c.Stderr, "%s: %s: %s: error preparing query: database connection required\n", query.Filename, query.Name, name) - errored = true - continue + if _, skip := md.RuleSkiplist[name]; skip { + if debug.Active { + log.Printf("Skipping vet rule %q for query: %s\n", name, query.Name) } - prepName := fmt.Sprintf("sqlc_vet_%d_%d", time.Now().Unix(), i) - if err := prep.Prepare(ctx, prepName, query.Text); err != nil { - fmt.Fprintf(c.Stderr, "%s: %s: %s: error preparing query: %s\n", query.Filename, query.Name, name, err) - errored = true - continue + } else { + rule, ok := c.Rules[name] + if !ok { + return fmt.Errorf("type-check error: a rule with the name '%s' does not exist", name) } - } - // short-circuit for "sqlc/db-prepare" rule which doesn't have a CEL program - if rule.Program == nil { - continue - } - - // Get explain output for this query if we need it - _, pgsqlOK := evalMap["postgresql"] - _, mysqlOK := evalMap["mysql"] - if rule.NeedsExplain && !(pgsqlOK || mysqlOK) { - if expl == nil { - fmt.Fprintf(c.Stderr, "%s: %s: %s: error explaining query: database connection required\n", query.Filename, query.Name, name) - errored = true - continue + if rule.NeedsPrepare { + if prep == nil { + fmt.Fprintf(c.Stderr, "%s: %s: %s: error preparing query: database connection required\n", query.Filename, query.Name, name) + errored = true + continue + } + prepName := fmt.Sprintf("sqlc_vet_%d_%d", time.Now().Unix(), i) + if err := prep.Prepare(ctx, prepName, query.Text); err != nil { + fmt.Fprintf(c.Stderr, "%s: %s: %s: error preparing query: %s\n", query.Filename, query.Name, name, err) + errored = true + continue + } } - engineOutput, err := expl.Explain(ctx, query.Text, query.Params...) - if err != nil { - fmt.Fprintf(c.Stderr, "%s: %s: %s: error explaining query: %s\n", query.Filename, query.Name, name, err) - errored = true + + // short-circuit for "sqlc/db-prepare" rule which doesn't have a CEL program + if rule.Program == nil { continue } - evalMap["postgresql"] = engineOutput.PostgreSQL - evalMap["mysql"] = engineOutput.MySQL - } + // Get explain output for this query if we need it + _, pgsqlOK := evalMap["postgresql"] + _, mysqlOK := evalMap["mysql"] + if rule.NeedsExplain && !(pgsqlOK || mysqlOK) { + if expl == nil { + fmt.Fprintf(c.Stderr, "%s: %s: %s: error explaining query: database connection required\n", query.Filename, query.Name, name) + errored = true + continue + } + engineOutput, err := expl.Explain(ctx, query.Text, query.Params...) + if err != nil { + fmt.Fprintf(c.Stderr, "%s: %s: %s: error explaining query: %s\n", query.Filename, query.Name, name, err) + errored = true + continue + } + + evalMap["postgresql"] = engineOutput.PostgreSQL + evalMap["mysql"] = engineOutput.MySQL + } - if debug.Debug.DumpVetEnv { - fmt.Printf("vars for rule '%s' evaluating against query '%s':\n", name, query.Name) - debug.DumpAsJSON(evalMap) - } + if debug.Debug.DumpVetEnv { + fmt.Printf("vars for rule '%s' evaluating against query '%s':\n", name, query.Name) + debug.DumpAsJSON(evalMap) + } - out, _, err := (*rule.Program).Eval(evalMap) - if err != nil { - return err - } - tripped, ok := out.Value().(bool) - if !ok { - return fmt.Errorf("expression returned non-bool value: %v", out.Value()) - } - if tripped { - // TODO: Get line numbers in the output - if rule.Message == "" { - fmt.Fprintf(c.Stderr, "%s: %s: %s\n", query.Filename, query.Name, name) - } else { - fmt.Fprintf(c.Stderr, "%s: %s: %s: %s\n", query.Filename, query.Name, name, rule.Message) + out, _, err := (*rule.Program).Eval(evalMap) + if err != nil { + return err + } + tripped, ok := out.Value().(bool) + if !ok { + return fmt.Errorf("expression returned non-bool value: %v", out.Value()) + } + if tripped { + // TODO: Get line numbers in the output + if rule.Message == "" { + fmt.Fprintf(c.Stderr, "%s: %s: %s\n", query.Filename, query.Name, name) + } else { + fmt.Fprintf(c.Stderr, "%s: %s: %s: %s\n", query.Filename, query.Name, name, rule.Message) + } + errored = true } - errored = true } } } + if errored { return ErrFailedChecks } diff --git a/internal/compiler/parse.go b/internal/compiler/parse.go index 022d23ea22..7ec029bfeb 100644 --- a/internal/compiler/parse.go +++ b/internal/compiler/parse.go @@ -65,7 +65,7 @@ func (c *Compiler) parseQuery(stmt ast.Node, src string, o opts.Parser) (*Query, return nil, err } - md.Params, md.Flags, err = metadata.ParseParamsAndFlags(cleanedComments) + md.Params, md.Flags, md.RuleSkiplist, err = metadata.ParseParamsAndFlags(cleanedComments) if err != nil { return nil, err } diff --git a/internal/metadata/meta.go b/internal/metadata/meta.go index 97ff36dbd2..6302c2b4be 100644 --- a/internal/metadata/meta.go +++ b/internal/metadata/meta.go @@ -18,6 +18,10 @@ type Metadata struct { Params map[string]string Flags map[string]bool + // RuleSkiplist contains the names of rules to disable vetting for. + // If the map is empty, but the disable vet flag is specified, then all rules are ignored. + RuleSkiplist map[string]struct{} + Filename string } @@ -113,9 +117,10 @@ func ParseQueryNameAndType(t string, commentStyle CommentSyntax) (string, string return "", "", nil } -func ParseParamsAndFlags(comments []string) (map[string]string, map[string]bool, error) { +func ParseParamsAndFlags(comments []string) (map[string]string, map[string]bool, map[string]struct{}, error) { params := make(map[string]string) flags := make(map[string]bool) + ruleSkiplist := make(map[string]struct{}) for _, line := range comments { s := bufio.NewScanner(strings.NewReader(line)) @@ -138,14 +143,27 @@ func ParseParamsAndFlags(comments []string) (map[string]string, map[string]bool, rest = append(rest, paramToken) } params[name] = strings.Join(rest, " ") + + case "@sqlc-vet-disable": + flags[token] = true + + // Vet rules can all be disabled in the same line or split across lines .i.e. + // /* @sqlc-vet-disable sqlc/db-prepare delete-without-where */ + // is equivalent to: + // /* @sqlc-vet-disable sqlc/db-prepare */ + // /* @sqlc-vet-disable delete-without-where */ + for s.Scan() { + ruleSkiplist[s.Text()] = struct{}{} + } + default: flags[token] = true } if s.Err() != nil { - return params, flags, s.Err() + return params, flags, ruleSkiplist, s.Err() } } - return params, flags, nil + return params, flags, ruleSkiplist, nil } From 28e7e4be6567f340bd1dbb471a42e0c5c29dd51f Mon Sep 17 00:00:00 2001 From: Ruona Onobrakpeya Date: Sun, 29 Sep 2024 00:37:34 +0100 Subject: [PATCH 2/7] Updated tests to cover new vet disabling behaviour. --- .../endtoend/testdata/vet_disable/query.sql | 27 +++++++++- .../endtoend/testdata/vet_disable/sqlc.yaml | 6 +++ .../endtoend/testdata/vet_disable/stderr.txt | 6 ++- internal/metadata/meta_test.go | 49 +++++++++++++++++-- 4 files changed, 82 insertions(+), 6 deletions(-) diff --git a/internal/endtoend/testdata/vet_disable/query.sql b/internal/endtoend/testdata/vet_disable/query.sql index c1eb8d2219..50052de26b 100644 --- a/internal/endtoend/testdata/vet_disable/query.sql +++ b/internal/endtoend/testdata/vet_disable/query.sql @@ -1,6 +1,29 @@ --- name: SkipVet :exec +-- name: RunVetAll :exec +SELECT true; + +-- name: SkipVetAll :exec -- @sqlc-vet-disable SELECT true; --- name: RunVet :exec +-- name: SkipVetSingleLine :exec +-- @sqlc-vet-disable always-fail no-exec +SELECT true; + +-- name: SkipVetMultiLine :exec +-- @sqlc-vet-disable always-fail +-- @sqlc-vet-disable no-exec +SELECT true; + +-- name: SkipVet_always_fail :exec +-- @sqlc-vet-disable always-fail +SELECT true; + +-- name: SkipVet_no_exec :exec +-- @sqlc-vet-disable no-exec +SELECT true; + +-- name: SkipVetInvalidRule :exec +-- @sqlc-vet-disable always-fail +-- @sqlc-vet-disable block-delete +-- @sqlc-vet-disable no-exec SELECT true; \ No newline at end of file diff --git a/internal/endtoend/testdata/vet_disable/sqlc.yaml b/internal/endtoend/testdata/vet_disable/sqlc.yaml index ff7c1b5200..1e53bd7f2f 100644 --- a/internal/endtoend/testdata/vet_disable/sqlc.yaml +++ b/internal/endtoend/testdata/vet_disable/sqlc.yaml @@ -9,7 +9,13 @@ sql: out: "db" rules: - always-fail + - no-exec rules: - name: always-fail message: "Fail" rule: "true" + + - name: no-exec + message: "don't use exec" + rule: | + query.cmd == "exec" diff --git a/internal/endtoend/testdata/vet_disable/stderr.txt b/internal/endtoend/testdata/vet_disable/stderr.txt index 9acbb8b34b..3d9a6169f8 100644 --- a/internal/endtoend/testdata/vet_disable/stderr.txt +++ b/internal/endtoend/testdata/vet_disable/stderr.txt @@ -1 +1,5 @@ -query.sql: RunVet: always-fail: Fail +query.sql: RunVetAll: always-fail: Fail +query.sql: RunVetAll: no-exec: don't use exec +query.sql: SkipVet_always_fail: no-exec: don't use exec +query.sql: SkipVet_no_exec: always-fail: Fail +query.sql: SkipVetInvalidRule: rule-check error: rule "block-delete" does not exist in the config file \ No newline at end of file diff --git a/internal/metadata/meta_test.go b/internal/metadata/meta_test.go index 3c2be6d6de..b734befdef 100644 --- a/internal/metadata/meta_test.go +++ b/internal/metadata/meta_test.go @@ -1,6 +1,8 @@ package metadata -import "testing" +import ( + "testing" +) func TestParseQueryNameAndType(t *testing.T) { @@ -77,7 +79,7 @@ func TestParseQueryParams(t *testing.T) { " @param @invalid UUID ", }, } { - params, _, err := ParseParamsAndFlags(comments) + params, _, _, err := ParseParamsAndFlags(comments) if err != nil { t.Errorf("expected comments to parse, got err: %s", err) } @@ -123,7 +125,7 @@ func TestParseQueryFlags(t *testing.T) { " @param @flag-bar UUID", }, } { - _, flags, err := ParseParamsAndFlags(comments) + _, flags, _, err := ParseParamsAndFlags(comments) if err != nil { t.Errorf("expected comments to parse, got err: %s", err) } @@ -137,3 +139,44 @@ func TestParseQueryFlags(t *testing.T) { } } } + +func TestParseQueryRuleBlocklist(t *testing.T) { + for _, comments := range [][]string{ + { + " name: CreateFoo :one", + " @sqlc-vet-disable sqlc/db-prepare delete-without-where ", + }, + { + " name: CreateFoo :one ", + " @sqlc-vet-disable sqlc/db-prepare ", + " @sqlc-vet-disable delete-without-where ", + }, + { + " name: CreateFoo :one", + " @sqlc-vet-disable sqlc/db-prepare ", + " update-without where", + " @sqlc-vet-disable delete-without-where ", + }, + } { + _, flags, ruleBlocklist, err := ParseParamsAndFlags(comments) + if err != nil { + t.Errorf("expected comments to parse, got err: %s", err) + } + + if !flags["@sqlc-vet-disable"] { + t.Errorf("expected @sqlc-vet-disable flag not found") + } + + if _, ok := ruleBlocklist["sqlc/db-prepare"]; !ok { + t.Errorf("expected rule not found in blocklist") + } + + if _, ok := ruleBlocklist["delete-without-where"]; !ok { + t.Errorf("expected rule not found in blocklist") + } + + if _, ok := ruleBlocklist["update-without-where"]; ok { + t.Errorf("unexpected rule found in blocklist") + } + } +} From 5c1546d07a55b6665349496138698d89a79fdf7f Mon Sep 17 00:00:00 2001 From: Ruona Onobrakpeya Date: Sun, 29 Sep 2024 00:42:28 +0100 Subject: [PATCH 3/7] Relocated constants for query flags to a dedicated package to allow for safer reuse. --- internal/cmd/vet.go | 8 +++----- internal/constants/query.go | 12 ++++++++++++ internal/metadata/meta.go | 5 +++-- 3 files changed, 18 insertions(+), 7 deletions(-) create mode 100644 internal/constants/query.go diff --git a/internal/cmd/vet.go b/internal/cmd/vet.go index 0283a64442..8a7f8077db 100644 --- a/internal/cmd/vet.go +++ b/internal/cmd/vet.go @@ -6,6 +6,7 @@ import ( "encoding/json" "errors" "fmt" + "github.com/sqlc-dev/sqlc/internal/constants" "io" "log" "os" @@ -38,9 +39,6 @@ var ErrFailedChecks = errors.New("failed checks") var pjson = protojson.UnmarshalOptions{AllowPartial: true, DiscardUnknown: true} -const RuleDbPrepare = "sqlc/db-prepare" -const QueryFlagSqlcVetDisable = "@sqlc-vet-disable" - func NewCmdVet() *cobra.Command { return &cobra.Command{ Use: "vet", @@ -110,7 +108,7 @@ func Vet(ctx context.Context, dir, filename string, opts *Options) error { } rules := map[string]rule{ - RuleDbPrepare: {NeedsPrepare: true}, + constants.QueryRuleDbPrepare: {NeedsPrepare: true}, } for _, c := range conf.Rules { @@ -540,7 +538,7 @@ func (c *checker) checkSQL(ctx context.Context, s config.SQL) error { cfg := vetConfig(req) for i, query := range req.Queries { md := result.Queries[i].Metadata - if md.Flags[QueryFlagSqlcVetDisable] { + if md.Flags[constants.QueryFlagSqlcVetDisable] { // If the vet disable flag is specified without any rules listed, all rules are ignored. if len(md.RuleSkiplist) == 0 { if debug.Active { diff --git a/internal/constants/query.go b/internal/constants/query.go new file mode 100644 index 0000000000..a572c56c6f --- /dev/null +++ b/internal/constants/query.go @@ -0,0 +1,12 @@ +package constants + +// Flags +const ( + QueryFlagParam = "@param" + QueryFlagSqlcVetDisable = "@sqlc-vet-disable" +) + +// Rules +const ( + QueryRuleDbPrepare = "sqlc/db-prepare" +) diff --git a/internal/metadata/meta.go b/internal/metadata/meta.go index 6302c2b4be..ec76de0c5d 100644 --- a/internal/metadata/meta.go +++ b/internal/metadata/meta.go @@ -3,6 +3,7 @@ package metadata import ( "bufio" "fmt" + "github.com/sqlc-dev/sqlc/internal/constants" "strings" "unicode" @@ -134,7 +135,7 @@ func ParseParamsAndFlags(comments []string) (map[string]string, map[string]bool, } switch token { - case "@param": + case constants.QueryFlagParam: s.Scan() name := s.Text() var rest []string @@ -144,7 +145,7 @@ func ParseParamsAndFlags(comments []string) (map[string]string, map[string]bool, } params[name] = strings.Join(rest, " ") - case "@sqlc-vet-disable": + case constants.QueryFlagSqlcVetDisable: flags[token] = true // Vet rules can all be disabled in the same line or split across lines .i.e. From 5b81b1c3f74aa7594c250fad8a1f53708f9892bb Mon Sep 17 00:00:00 2001 From: Ruona Onobrakpeya Date: Sun, 29 Sep 2024 00:54:46 +0100 Subject: [PATCH 4/7] Renamed the metadata `ParseParamsAndFlags()` function to `ParseCommentFlags()` in order to be more generic as it now returns the rule skip list and could potentially return more data in the future. --- internal/compiler/parse.go | 2 +- internal/metadata/meta.go | 4 +++- internal/metadata/meta_test.go | 6 +++--- 3 files changed, 7 insertions(+), 5 deletions(-) diff --git a/internal/compiler/parse.go b/internal/compiler/parse.go index 7ec029bfeb..681d291122 100644 --- a/internal/compiler/parse.go +++ b/internal/compiler/parse.go @@ -65,7 +65,7 @@ func (c *Compiler) parseQuery(stmt ast.Node, src string, o opts.Parser) (*Query, return nil, err } - md.Params, md.Flags, md.RuleSkiplist, err = metadata.ParseParamsAndFlags(cleanedComments) + md.Params, md.Flags, md.RuleSkiplist, err = metadata.ParseCommentFlags(cleanedComments) if err != nil { return nil, err } diff --git a/internal/metadata/meta.go b/internal/metadata/meta.go index ec76de0c5d..8f63624d2c 100644 --- a/internal/metadata/meta.go +++ b/internal/metadata/meta.go @@ -118,7 +118,9 @@ func ParseQueryNameAndType(t string, commentStyle CommentSyntax) (string, string return "", "", nil } -func ParseParamsAndFlags(comments []string) (map[string]string, map[string]bool, map[string]struct{}, error) { +// ParseCommentFlags processes the comments provided with queries to determine the metadata params, flags and rules to skip. +// All flags in query comments are prefixed with `@`, e.g. @param, @@sqlc-vet-disable. +func ParseCommentFlags(comments []string) (map[string]string, map[string]bool, map[string]struct{}, error) { params := make(map[string]string) flags := make(map[string]bool) ruleSkiplist := make(map[string]struct{}) diff --git a/internal/metadata/meta_test.go b/internal/metadata/meta_test.go index b734befdef..47eb02ada6 100644 --- a/internal/metadata/meta_test.go +++ b/internal/metadata/meta_test.go @@ -79,7 +79,7 @@ func TestParseQueryParams(t *testing.T) { " @param @invalid UUID ", }, } { - params, _, _, err := ParseParamsAndFlags(comments) + params, _, _, err := ParseCommentFlags(comments) if err != nil { t.Errorf("expected comments to parse, got err: %s", err) } @@ -125,7 +125,7 @@ func TestParseQueryFlags(t *testing.T) { " @param @flag-bar UUID", }, } { - _, flags, _, err := ParseParamsAndFlags(comments) + _, flags, _, err := ParseCommentFlags(comments) if err != nil { t.Errorf("expected comments to parse, got err: %s", err) } @@ -158,7 +158,7 @@ func TestParseQueryRuleBlocklist(t *testing.T) { " @sqlc-vet-disable delete-without-where ", }, } { - _, flags, ruleBlocklist, err := ParseParamsAndFlags(comments) + _, flags, ruleBlocklist, err := ParseCommentFlags(comments) if err != nil { t.Errorf("expected comments to parse, got err: %s", err) } From bef3dbac8f8a1a1eb652b11afe2512d808b36dbd Mon Sep 17 00:00:00 2001 From: Ruona Onobrakpeya Date: Sun, 29 Sep 2024 01:04:03 +0100 Subject: [PATCH 5/7] Updated docs to reflect the support of rule names for the vet disable annotation. --- docs/howto/vet.md | 19 ++++++++++++++++++- 1 file changed, 18 insertions(+), 1 deletion(-) diff --git a/docs/howto/vet.md b/docs/howto/vet.md index ff6ff3ceb0..b88a662090 100644 --- a/docs/howto/vet.md +++ b/docs/howto/vet.md @@ -259,7 +259,24 @@ rules: ### Opting-out of lint rules For any query, you can tell `sqlc vet` not to evaluate lint rules using the -`@sqlc-vet-disable` query annotation. +`@sqlc-vet-disable` query annotation. The annotation accepts a list of rules to ignore. + +```sql +/* name: GetAuthor :one */ +/* @sqlc-vet-disable sqlc/db-prepare no-pg */ +SELECT * FROM authors +WHERE id = ? LIMIT 1; +``` +The rules can also be split across lines. +```sql +/* name: GetAuthor :one */ +/* @sqlc-vet-disable sqlc/db-prepare */ +/* @sqlc-vet-disable no-pg */ +SELECT * FROM authors +WHERE id = ? LIMIT 1; +``` + +To skip all rules for a query, you can provide the `@sqlc-vet-disable` annotation without any options. ```sql /* name: GetAuthor :one */ From a82fcb4be960a973019c77f89b2e5ec0e2e62cfe Mon Sep 17 00:00:00 2001 From: Ruona Onobrakpeya Date: Sun, 29 Sep 2024 01:22:22 +0100 Subject: [PATCH 6/7] Slight term change in vet docs. --- docs/howto/vet.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/howto/vet.md b/docs/howto/vet.md index b88a662090..3f6c6a025b 100644 --- a/docs/howto/vet.md +++ b/docs/howto/vet.md @@ -276,7 +276,7 @@ SELECT * FROM authors WHERE id = ? LIMIT 1; ``` -To skip all rules for a query, you can provide the `@sqlc-vet-disable` annotation without any options. +To skip all rules for a query, you can provide the `@sqlc-vet-disable` annotation without any parameters. ```sql /* name: GetAuthor :one */ From 474ee13f12f7a570ac7524e9c01c1e48fb2c0a4d Mon Sep 17 00:00:00 2001 From: Ruona Onobrakpeya Date: Sun, 29 Sep 2024 11:28:25 +0100 Subject: [PATCH 7/7] Renamed test function for query rule skiplist. --- internal/metadata/meta_test.go | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) diff --git a/internal/metadata/meta_test.go b/internal/metadata/meta_test.go index 47eb02ada6..e9ef54586e 100644 --- a/internal/metadata/meta_test.go +++ b/internal/metadata/meta_test.go @@ -140,7 +140,7 @@ func TestParseQueryFlags(t *testing.T) { } } -func TestParseQueryRuleBlocklist(t *testing.T) { +func TestParseQueryRuleSkiplist(t *testing.T) { for _, comments := range [][]string{ { " name: CreateFoo :one", @@ -158,7 +158,7 @@ func TestParseQueryRuleBlocklist(t *testing.T) { " @sqlc-vet-disable delete-without-where ", }, } { - _, flags, ruleBlocklist, err := ParseCommentFlags(comments) + _, flags, ruleSkiplist, err := ParseCommentFlags(comments) if err != nil { t.Errorf("expected comments to parse, got err: %s", err) } @@ -167,16 +167,16 @@ func TestParseQueryRuleBlocklist(t *testing.T) { t.Errorf("expected @sqlc-vet-disable flag not found") } - if _, ok := ruleBlocklist["sqlc/db-prepare"]; !ok { - t.Errorf("expected rule not found in blocklist") + if _, ok := ruleSkiplist["sqlc/db-prepare"]; !ok { + t.Errorf("expected rule not found in skiplist") } - if _, ok := ruleBlocklist["delete-without-where"]; !ok { - t.Errorf("expected rule not found in blocklist") + if _, ok := ruleSkiplist["delete-without-where"]; !ok { + t.Errorf("expected rule not found in skiplist") } - if _, ok := ruleBlocklist["update-without-where"]; ok { - t.Errorf("unexpected rule found in blocklist") + if _, ok := ruleSkiplist["update-without-where"]; ok { + t.Errorf("unexpected rule found in skiplist") } } }