| // Copyright 2021 The Go Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style |
| // license that can be found in the LICENSE file. |
| |
| //go:build go1.17 && !windows |
| // +build go1.17,!windows |
| |
| package main |
| |
| import ( |
| "bufio" |
| "bytes" |
| "context" |
| "io/fs" |
| "os" |
| "os/exec" |
| "regexp" |
| "strings" |
| "testing" |
| |
| "golang.org/x/mod/modfile" |
| "golang.org/x/vuln/internal/testenv" |
| "golang.org/x/vuln/scan" |
| "mvdan.cc/unparam/check" |
| ) |
| |
| // excluded contains the set of modules that x/vuln should not depend on. |
| var excluded = map[string]bool{ |
| "golang.org/x/exp": true, |
| } |
| |
| var goHeader = regexp.MustCompile(`^// Copyright 20\d\d The Go Authors\. All rights reserved\. |
| // Use of this source code is governed by a BSD-style |
| // license that can be found in the LICENSE file\.`) |
| |
| func TestBashChecks(t *testing.T) { |
| skipIfShort(t) |
| bash, err := exec.LookPath("bash") |
| if err != nil { |
| t.Skipf("skipping: %v", err) |
| } |
| |
| var cmd *exec.Cmd |
| if os.Getenv("GO_BUILDER_NAME") != "" { |
| cmd = exec.Command(bash, "./checks.bash", "trybots") |
| } else { |
| cmd = exec.Command(bash, "./checks.bash") |
| } |
| cmd.Stdout = os.Stdout |
| cmd.Stderr = os.Stderr |
| if err := cmd.Run(); err != nil { |
| t.Fatal(err) |
| } |
| } |
| |
| func TestDependencies(t *testing.T) { |
| dat, err := os.ReadFile("go.mod") |
| if err != nil { |
| t.Fatal(err) |
| } |
| f, err := modfile.Parse("go.mod", dat, nil) |
| if err != nil { |
| t.Fatalf("modfile.Parse: %v", err) |
| } |
| for _, r := range f.Require { |
| // This is used by staticcheck. |
| if strings.HasPrefix(r.Mod.Path, "golang.org/x/exp/typeparams") { |
| continue |
| } |
| for ex := range excluded { |
| if strings.HasPrefix(r.Mod.Path, ex) { |
| t.Errorf("go.mod contains %q as a dependency, which should not happen", r.Mod.Path) |
| } |
| } |
| } |
| } |
| |
| func TestGovulncheck(t *testing.T) { |
| skipIfShort(t) |
| testenv.NeedsGoBuild(t) |
| |
| var o string |
| out := bytes.NewBufferString(o) |
| ctx := context.Background() |
| |
| cmd := scan.Command(ctx, "./...") |
| cmd.Stdout = out |
| cmd.Stderr = out |
| err := cmd.Start() |
| if err == nil { |
| err = cmd.Wait() |
| } |
| |
| t.Logf("govulncheck finished with std out/err:\n%s", out.String()) |
| switch err := err.(type) { |
| case nil: |
| t.Log("govulncheck: no vulnerabilities detected") |
| case interface{ ExitCode() int }: |
| t.Errorf("govulncheck: unexpected exit code %d and error %v", err.ExitCode(), err) |
| default: |
| t.Errorf("govulncheck: abruptly failed with error %v", err) |
| } |
| } |
| |
| func TestStaticCheck(t *testing.T) { |
| skipIfShort(t) |
| rungo(t, "run", "honnef.co/go/tools/cmd/staticcheck@v0.4.3", "./...") |
| } |
| |
| func TestUnparam(t *testing.T) { |
| testenv.NeedsGoBuild(t) |
| warns, err := check.UnusedParams(false, false, false, "./...") |
| if err != nil { |
| t.Fatalf("check.UnusedParams: %v", err) |
| } |
| for _, warn := range warns { |
| t.Errorf(warn) |
| } |
| } |
| |
| func TestVet(t *testing.T) { |
| rungo(t, "vet", "-all", "./...") |
| } |
| |
| func TestMisspell(t *testing.T) { |
| skipIfShort(t) |
| rungo(t, "run", "github.com/client9/misspell/cmd/misspell@v0.3.4", "-error", ".") |
| } |
| |
| func TestHeaders(t *testing.T) { |
| sfs := os.DirFS(".") |
| fs.WalkDir(sfs, ".", func(path string, d fs.DirEntry, _ error) error { |
| if d.IsDir() { |
| if d.Name() == "testdata" { |
| return fs.SkipDir |
| } |
| return nil |
| } |
| if !strings.HasSuffix(path, ".go") { |
| return nil |
| } |
| f, err := sfs.Open(path) |
| if err != nil { |
| return err |
| } |
| defer f.Close() |
| if !goHeader.MatchReader(bufio.NewReader(f)) { |
| t.Errorf("%v: incorrect go header", path) |
| } |
| return nil |
| }) |
| } |
| |
| func rungo(t *testing.T, args ...string) { |
| t.Helper() |
| testenv.NeedsGoBuild(t) |
| |
| cmd := exec.Command("go", args...) |
| if output, err := cmd.CombinedOutput(); err != nil { |
| t.Log("\n" + string(output)) |
| t.Error("command had non zero exit code") |
| } |
| } |
| |
| func skipIfShort(t *testing.T) { |
| if testing.Short() { |
| t.Skipf("skipping: short mode") |
| } |
| } |