Debian Codegraph @

analysis/lint/testutil/util.go

raw
1 package testutil
2
3 import (
4 "crypto/sha256"
5 "go/build"
6 "go/version"
7 "io"
8 "os"
9 "path/filepath"
10 "strings"
11 "testing"
12
13 "honnef.co/go/tools/analysis/lint"
14 "honnef.co/go/tools/config"
15 "honnef.co/go/tools/go/buildid"
16 "honnef.co/go/tools/lintcmd/cache"
17 "honnef.co/go/tools/lintcmd/runner"
18
19 "golang.org/x/tools/go/analysis"
20 "golang.org/x/tools/go/packages"
21 )
22
23 type Test struct {
24 Dir string
25 Version string
26 }
27
28 func computeSalt() ([]byte, error) {
29 p, err := os.Executable()
30 if err != nil {
31 return nil, err
32 }
33
34 if id, err := buildid.ReadFile(p); err == nil {
35 return []byte(id), nil
36 } else {
37 // For some reason we couldn't read the build id from the executable.
38 // Fall back to hashing the entire executable.
39 f, err := os.Open(p)
40 if err != nil {
41 return nil, err
42 }
43 defer f.Close()
44 h := sha256.New()
45 if _, err := io.Copy(h, f); err != nil {
46 return nil, err
47 }
48 return h.Sum(nil), nil
49 }
50 }
51
52 func Run(t *testing.T, a *lint.Analyzer) {
53 dirs, err := filepath.Glob("testdata/*")
54 if err != nil {
55 t.Fatalf("couldn't enumerate test data: %s", err)
56 }
57
58 if len(dirs) == 0 {
59 t.Fatalf("found no tests")
60 }
61
62 c, err := cache.Open(t.TempDir())
63 if err != nil {
64 t.Fatal(err)
65 }
66 salt, err := computeSalt()
67 if err != nil {
68 t.Fatal(err)
69 }
70 c.SetSalt(salt)
71
72 tags := build.Default.ReleaseTags
73 maxVersion := tags[len(tags)-1]
74 for _, dir := range dirs {
75 vers := filepath.Base(dir)
76 t.Run(vers, func(t *testing.T) {
77 if !version.IsValid(vers) {
78 t.Fatalf("%q is not a valid Go version", dir)
79 }
80 if version.Compare(vers, maxVersion) == 1 {
81 t.Skipf("%s is newer than our Go version (%s), skipping", vers, maxVersion)
82 }
83 r, err := runner.New(config.Config{}, c)
84 if err != nil {
85 t.Fatal(err)
86 }
87 r.TestMode = true
88
89 testdata, err := filepath.Abs("testdata")
90 if err != nil {
91 t.Fatal(err)
92 }
93 cfg := &packages.Config{
94 Dir: dir,
95 Tests: true,
96 Env: append(os.Environ(), "GOPROXY=off", "GOFLAGS=-mod=vendor", "GO111MODULE="),
97 Overlay: map[string][]byte{
98 "go.mod": []byte("module example.com\ngo " + strings.TrimPrefix(vers, "go")),
99 },
100 }
101 res, err := r.Run(cfg, []*analysis.Analyzer{a.Analyzer}, []string{"./..."})
102 if err != nil {
103 t.Fatal(err)
104 }
105
106 if len(res) == 0 {
107 t.Fatalf("got no results for %s/...", dir)
108 }
109
110 for _, r := range res {
111 if r.Failed {
112 if len(r.Errors) > 0 {
113 sb := strings.Builder{}
114 for _, err := range r.Errors {
115 sb.WriteString(err.Error())
116 sb.WriteString("\n")
117 }
118 t.Fatalf("failed checking %s:\n%s", r.Package.PkgPath, sb.String())
119 } else {
120 t.Fatalf("failed processing package %s, but got no errors", r.Package.PkgPath)
121 }
122 }
123 data, err := r.Load()
124 if err != nil {
125 t.Fatal(err)
126 }
127 tdata, err := r.LoadTest()
128 if err != nil {
129 t.Fatal(err)
130 }
131
132 relevantDiags := data.Diagnostics
133 var relevantFacts []runner.TestFact
134 for _, fact := range tdata.Facts {
135 if fact.Analyzer != a.Analyzer.Name {
136 continue
137 }
138 relevantFacts = append(relevantFacts, fact)
139 }
140
141 Check(t, testdata, tdata.Files, relevantDiags, relevantFacts)
142 CheckSuggestedFixes(t, relevantDiags)
143 }
144 })
145 }
146 }