aboutsummaryrefslogtreecommitdiff
path: root/integration_test.go
diff options
context:
space:
mode:
Diffstat (limited to 'integration_test.go')
-rw-r--r--integration_test.go494
1 files changed, 0 insertions, 494 deletions
diff --git a/integration_test.go b/integration_test.go
deleted file mode 100644
index 8a4f7af7..00000000
--- a/integration_test.go
+++ /dev/null
@@ -1,494 +0,0 @@
-// Copyright 2019 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 ignore
-// +build ignore
-
-package main
-
-import (
- "archive/tar"
- "archive/zip"
- "bytes"
- "compress/gzip"
- "crypto/sha256"
- "flag"
- "fmt"
- "io"
- "io/ioutil"
- "net/http"
- "os"
- "os/exec"
- "path/filepath"
- "regexp"
- "runtime"
- "strings"
- "sync"
- "testing"
- "time"
-
- "google.golang.org/protobuf/internal/version"
-)
-
-var (
- regenerate = flag.Bool("regenerate", false, "regenerate files")
- buildRelease = flag.Bool("buildRelease", false, "build release binaries")
-
- protobufVersion = "3.15.3"
- protobufSHA256 = "" // ignored if protobufVersion is a git hash
-
- golangVersions = []string{"1.11.13", "1.12.17", "1.13.15", "1.14.15", "1.15.15", "1.16.10", "1.17.3"}
- golangLatest = golangVersions[len(golangVersions)-1]
-
- staticcheckVersion = "2020.1.4"
- staticcheckSHA256s = map[string]string{
- "darwin/amd64": "5706d101426c025e8f165309e0cb2932e54809eb035ff23ebe19df0f810699d8",
- "linux/386": "e4dbf94e940678ae7108f0d22c7c2992339bc10a8fb384e7e734b1531a429a1c",
- "linux/amd64": "09d2c2002236296de2c757df111fe3ae858b89f9e183f645ad01f8135c83c519",
- }
-
- // purgeTimeout determines the maximum age of unused sub-directories.
- purgeTimeout = 30 * 24 * time.Hour // 1 month
-
- // Variables initialized by mustInitDeps.
- goPath string
- modulePath string
- protobufPath string
-)
-
-func Test(t *testing.T) {
- mustInitDeps(t)
- mustHandleFlags(t)
-
- // Report dirt in the working tree quickly, rather than after
- // going through all the presubmits.
- //
- // Fail the test late, so we can test uncommitted changes with -failfast.
- gitDiff := mustRunCommand(t, "git", "diff", "HEAD")
- if strings.TrimSpace(gitDiff) != "" {
- fmt.Printf("WARNING: working tree contains uncommitted changes:\n%v\n", gitDiff)
- }
- gitUntracked := mustRunCommand(t, "git", "ls-files", "--others", "--exclude-standard")
- if strings.TrimSpace(gitUntracked) != "" {
- fmt.Printf("WARNING: working tree contains untracked files:\n%v\n", gitUntracked)
- }
-
- // Do the relatively fast checks up-front.
- t.Run("GeneratedGoFiles", func(t *testing.T) {
- diff := mustRunCommand(t, "go", "run", "-tags", "protolegacy", "./internal/cmd/generate-types")
- if strings.TrimSpace(diff) != "" {
- t.Fatalf("stale generated files:\n%v", diff)
- }
- diff = mustRunCommand(t, "go", "run", "-tags", "protolegacy", "./internal/cmd/generate-protos")
- if strings.TrimSpace(diff) != "" {
- t.Fatalf("stale generated files:\n%v", diff)
- }
- })
- t.Run("FormattedGoFiles", func(t *testing.T) {
- files := strings.Split(strings.TrimSpace(mustRunCommand(t, "git", "ls-files", "*.go")), "\n")
- diff := mustRunCommand(t, append([]string{"gofmt", "-d"}, files...)...)
- if strings.TrimSpace(diff) != "" {
- t.Fatalf("unformatted source files:\n%v", diff)
- }
- })
- t.Run("CopyrightHeaders", func(t *testing.T) {
- files := strings.Split(strings.TrimSpace(mustRunCommand(t, "git", "ls-files", "*.go", "*.proto")), "\n")
- mustHaveCopyrightHeader(t, files)
- })
-
- var wg sync.WaitGroup
- sema := make(chan bool, (runtime.NumCPU()+1)/2)
- for i := range golangVersions {
- goVersion := golangVersions[i]
- goLabel := "Go" + goVersion
- runGo := func(label string, cmd command, args ...string) {
- wg.Add(1)
- sema <- true
- go func() {
- defer wg.Done()
- defer func() { <-sema }()
- t.Run(goLabel+"/"+label, func(t *testing.T) {
- args[0] += goVersion
- cmd.mustRun(t, args...)
- })
- }()
- }
-
- workDir := filepath.Join(goPath, "src", modulePath)
- runGo("Normal", command{Dir: workDir}, "go", "test", "-race", "./...")
- runGo("PureGo", command{Dir: workDir}, "go", "test", "-race", "-tags", "purego", "./...")
- runGo("Reflect", command{Dir: workDir}, "go", "test", "-race", "-tags", "protoreflect", "./...")
- if goVersion == golangLatest {
- runGo("ProtoLegacy", command{Dir: workDir}, "go", "test", "-race", "-tags", "protolegacy", "./...")
- runGo("ProtocGenGo", command{Dir: "cmd/protoc-gen-go/testdata"}, "go", "test")
- runGo("Conformance", command{Dir: "internal/conformance"}, "go", "test", "-execute")
-
- // Only run the 32-bit compatability tests for Linux;
- // avoid Darwin since 10.15 dropped support i386 code execution.
- if runtime.GOOS == "linux" {
- runGo("Arch32Bit", command{Dir: workDir, Env: append(os.Environ(), "GOARCH=386")}, "go", "test", "./...")
- }
- }
- }
- wg.Wait()
-
- t.Run("GoStaticCheck", func(t *testing.T) {
- checks := []string{
- "all", // start with all checks enabled
- "-SA1019", // disable deprecated usage check
- "-S*", // disable code simplication checks
- "-ST*", // disable coding style checks
- "-U*", // disable unused declaration checks
- }
- out := mustRunCommand(t, "staticcheck", "-checks="+strings.Join(checks, ","), "-fail=none", "./...")
-
- // Filter out findings from certain paths.
- var findings []string
- for _, finding := range strings.Split(strings.TrimSpace(out), "\n") {
- switch {
- case strings.HasPrefix(finding, "internal/testprotos/legacy/"):
- default:
- findings = append(findings, finding)
- }
- }
- if len(findings) > 0 {
- t.Fatalf("staticcheck findings:\n%v", strings.Join(findings, "\n"))
- }
- })
- t.Run("CommittedGitChanges", func(t *testing.T) {
- if strings.TrimSpace(gitDiff) != "" {
- t.Fatalf("uncommitted changes")
- }
- })
- t.Run("TrackedGitFiles", func(t *testing.T) {
- if strings.TrimSpace(gitUntracked) != "" {
- t.Fatalf("untracked files")
- }
- })
-}
-
-func mustInitDeps(t *testing.T) {
- check := func(err error) {
- t.Helper()
- if err != nil {
- t.Fatal(err)
- }
- }
-
- // Determine the directory to place the test directory.
- repoRoot, err := os.Getwd()
- check(err)
- testDir := filepath.Join(repoRoot, ".cache")
- check(os.MkdirAll(testDir, 0775))
-
- // Delete the current directory if non-empty,
- // which only occurs if a dependency failed to initialize properly.
- var workingDir string
- finishedDirs := map[string]bool{}
- defer func() {
- if workingDir != "" {
- os.RemoveAll(workingDir) // best-effort
- }
- }()
- startWork := func(name string) string {
- workingDir = filepath.Join(testDir, name)
- return workingDir
- }
- finishWork := func() {
- finishedDirs[workingDir] = true
- workingDir = ""
- }
-
- // Delete other sub-directories that are no longer relevant.
- defer func() {
- now := time.Now()
- fis, _ := ioutil.ReadDir(testDir)
- for _, fi := range fis {
- dir := filepath.Join(testDir, fi.Name())
- if finishedDirs[dir] {
- os.Chtimes(dir, now, now) // best-effort
- continue
- }
- if now.Sub(fi.ModTime()) < purgeTimeout {
- continue
- }
- fmt.Printf("delete %v\n", fi.Name())
- os.RemoveAll(dir) // best-effort
- }
- }()
-
- // The bin directory contains symlinks to each tool by version.
- // It is safe to delete this directory and run the test script from scratch.
- binPath := startWork("bin")
- check(os.RemoveAll(binPath))
- check(os.Mkdir(binPath, 0775))
- check(os.Setenv("PATH", binPath+":"+os.Getenv("PATH")))
- registerBinary := func(name, path string) {
- check(os.Symlink(path, filepath.Join(binPath, name)))
- }
- finishWork()
-
- // Download and build the protobuf toolchain.
- // We avoid downloading the pre-compiled binaries since they do not contain
- // the conformance test runner.
- protobufPath = startWork("protobuf-" + protobufVersion)
- if _, err := os.Stat(protobufPath); err != nil {
- fmt.Printf("download %v\n", filepath.Base(protobufPath))
- if isCommit := strings.Trim(protobufVersion, "0123456789abcdef") == ""; isCommit {
- command{Dir: testDir}.mustRun(t, "git", "clone", "https://github.com/protocolbuffers/protobuf", "protobuf-"+protobufVersion)
- command{Dir: protobufPath}.mustRun(t, "git", "checkout", protobufVersion)
- } else {
- url := fmt.Sprintf("https://github.com/google/protobuf/releases/download/v%v/protobuf-all-%v.tar.gz", protobufVersion, protobufVersion)
- downloadArchive(check, protobufPath, url, "protobuf-"+protobufVersion, protobufSHA256)
- }
-
- fmt.Printf("build %v\n", filepath.Base(protobufPath))
- command{Dir: protobufPath}.mustRun(t, "./autogen.sh")
- command{Dir: protobufPath}.mustRun(t, "./configure")
- command{Dir: protobufPath}.mustRun(t, "make")
- command{Dir: filepath.Join(protobufPath, "conformance")}.mustRun(t, "make")
- }
- check(os.Setenv("PROTOBUF_ROOT", protobufPath)) // for generate-protos
- registerBinary("conform-test-runner", filepath.Join(protobufPath, "conformance", "conformance-test-runner"))
- registerBinary("protoc", filepath.Join(protobufPath, "src", "protoc"))
- finishWork()
-
- // Download each Go toolchain version.
- for _, v := range golangVersions {
- goDir := startWork("go" + v)
- if _, err := os.Stat(goDir); err != nil {
- fmt.Printf("download %v\n", filepath.Base(goDir))
- url := fmt.Sprintf("https://dl.google.com/go/go%v.%v-%v.tar.gz", v, runtime.GOOS, runtime.GOARCH)
- downloadArchive(check, goDir, url, "go", "") // skip SHA256 check as we fetch over https from a trusted domain
- }
- registerBinary("go"+v, filepath.Join(goDir, "bin", "go"))
- finishWork()
- }
- registerBinary("go", filepath.Join(testDir, "go"+golangLatest, "bin", "go"))
- registerBinary("gofmt", filepath.Join(testDir, "go"+golangLatest, "bin", "gofmt"))
-
- // Download the staticcheck tool.
- checkDir := startWork("staticcheck-" + staticcheckVersion)
- if _, err := os.Stat(checkDir); err != nil {
- fmt.Printf("download %v\n", filepath.Base(checkDir))
- url := fmt.Sprintf("https://github.com/dominikh/go-tools/releases/download/%v/staticcheck_%v_%v.tar.gz", staticcheckVersion, runtime.GOOS, runtime.GOARCH)
- downloadArchive(check, checkDir, url, "staticcheck", staticcheckSHA256s[runtime.GOOS+"/"+runtime.GOARCH])
- }
- registerBinary("staticcheck", filepath.Join(checkDir, "staticcheck"))
- finishWork()
-
- // GitHub actions sets GOROOT, which confuses invocations of the Go toolchain.
- // Explicitly clear GOROOT, so each toolchain uses their default GOROOT.
- check(os.Unsetenv("GOROOT"))
-
- // Set a cache directory outside the test directory.
- check(os.Setenv("GOCACHE", filepath.Join(repoRoot, ".gocache")))
-
- // Setup GOPATH for pre-module support (i.e., go1.10 and earlier).
- goPath = startWork("gopath")
- modulePath = strings.TrimSpace(command{Dir: testDir}.mustRun(t, "go", "list", "-m", "-f", "{{.Path}}"))
- check(os.RemoveAll(filepath.Join(goPath, "src")))
- check(os.MkdirAll(filepath.Join(goPath, "src", filepath.Dir(modulePath)), 0775))
- check(os.Symlink(repoRoot, filepath.Join(goPath, "src", modulePath)))
- command{Dir: repoRoot}.mustRun(t, "go", "mod", "tidy")
- command{Dir: repoRoot}.mustRun(t, "go", "mod", "vendor")
- check(os.Setenv("GOPATH", goPath))
- finishWork()
-}
-
-func downloadFile(check func(error), dstPath, srcURL string) {
- resp, err := http.Get(srcURL)
- check(err)
- defer resp.Body.Close()
-
- check(os.MkdirAll(filepath.Dir(dstPath), 0775))
- f, err := os.Create(dstPath)
- check(err)
-
- _, err = io.Copy(f, resp.Body)
- check(err)
-}
-
-func downloadArchive(check func(error), dstPath, srcURL, skipPrefix, wantSHA256 string) {
- check(os.RemoveAll(dstPath))
-
- resp, err := http.Get(srcURL)
- check(err)
- defer resp.Body.Close()
-
- var r io.Reader = resp.Body
- if wantSHA256 != "" {
- b, err := ioutil.ReadAll(resp.Body)
- check(err)
- r = bytes.NewReader(b)
-
- if gotSHA256 := fmt.Sprintf("%x", sha256.Sum256(b)); gotSHA256 != wantSHA256 {
- check(fmt.Errorf("checksum validation error:\ngot %v\nwant %v", gotSHA256, wantSHA256))
- }
- }
-
- zr, err := gzip.NewReader(r)
- check(err)
-
- tr := tar.NewReader(zr)
- for {
- h, err := tr.Next()
- if err == io.EOF {
- return
- }
- check(err)
-
- // Skip directories or files outside the prefix directory.
- if len(skipPrefix) > 0 {
- if !strings.HasPrefix(h.Name, skipPrefix) {
- continue
- }
- if len(h.Name) > len(skipPrefix) && h.Name[len(skipPrefix)] != '/' {
- continue
- }
- }
-
- path := strings.TrimPrefix(strings.TrimPrefix(h.Name, skipPrefix), "/")
- path = filepath.Join(dstPath, filepath.FromSlash(path))
- mode := os.FileMode(h.Mode & 0777)
- switch h.Typeflag {
- case tar.TypeReg:
- b, err := ioutil.ReadAll(tr)
- check(err)
- check(ioutil.WriteFile(path, b, mode))
- case tar.TypeDir:
- check(os.Mkdir(path, mode))
- }
- }
-}
-
-func mustHandleFlags(t *testing.T) {
- if *regenerate {
- t.Run("Generate", func(t *testing.T) {
- fmt.Print(mustRunCommand(t, "go", "run", "-tags", "protolegacy", "./internal/cmd/generate-types", "-execute"))
- fmt.Print(mustRunCommand(t, "go", "run", "-tags", "protolegacy", "./internal/cmd/generate-protos", "-execute"))
- files := strings.Split(strings.TrimSpace(mustRunCommand(t, "git", "ls-files", "*.go")), "\n")
- mustRunCommand(t, append([]string{"gofmt", "-w"}, files...)...)
- })
- }
- if *buildRelease {
- t.Run("BuildRelease", func(t *testing.T) {
- v := version.String()
- for _, goos := range []string{"linux", "darwin", "windows"} {
- for _, goarch := range []string{"386", "amd64"} {
- // Avoid Darwin since 10.15 dropped support for i386.
- if goos == "darwin" && goarch == "386" {
- continue
- }
-
- binPath := filepath.Join("bin", fmt.Sprintf("protoc-gen-go.%v.%v.%v", v, goos, goarch))
-
- // Build the binary.
- cmd := command{Env: append(os.Environ(), "GOOS="+goos, "GOARCH="+goarch)}
- cmd.mustRun(t, "go", "build", "-trimpath", "-ldflags", "-s -w -buildid=", "-o", binPath, "./cmd/protoc-gen-go")
-
- // Archive and compress the binary.
- in, err := ioutil.ReadFile(binPath)
- if err != nil {
- t.Fatal(err)
- }
- out := new(bytes.Buffer)
- suffix := ""
- comment := fmt.Sprintf("protoc-gen-go VERSION=%v GOOS=%v GOARCH=%v", v, goos, goarch)
- switch goos {
- case "windows":
- suffix = ".zip"
- zw := zip.NewWriter(out)
- zw.SetComment(comment)
- fw, _ := zw.Create("protoc-gen-go.exe")
- fw.Write(in)
- zw.Close()
- default:
- suffix = ".tar.gz"
- gz, _ := gzip.NewWriterLevel(out, gzip.BestCompression)
- gz.Comment = comment
- tw := tar.NewWriter(gz)
- tw.WriteHeader(&tar.Header{
- Name: "protoc-gen-go",
- Mode: int64(0775),
- Size: int64(len(in)),
- })
- tw.Write(in)
- tw.Close()
- gz.Close()
- }
- if err := ioutil.WriteFile(binPath+suffix, out.Bytes(), 0664); err != nil {
- t.Fatal(err)
- }
- }
- }
- })
- }
- if *regenerate || *buildRelease {
- t.SkipNow()
- }
-}
-
-var copyrightRegex = []*regexp.Regexp{
- regexp.MustCompile(`^// Copyright \d\d\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\.
-`),
- // Generated .pb.go files from main protobuf repo.
- regexp.MustCompile(`^// Protocol Buffers - Google's data interchange format
-// Copyright \d\d\d\d Google Inc\. All rights reserved\.
-`),
-}
-
-func mustHaveCopyrightHeader(t *testing.T, files []string) {
- var bad []string
-File:
- for _, file := range files {
- b, err := ioutil.ReadFile(file)
- if err != nil {
- t.Fatal(err)
- }
- for _, re := range copyrightRegex {
- if loc := re.FindIndex(b); loc != nil && loc[0] == 0 {
- continue File
- }
- }
- bad = append(bad, file)
- }
- if len(bad) > 0 {
- t.Fatalf("files with missing/bad copyright headers:\n %v", strings.Join(bad, "\n "))
- }
-}
-
-type command struct {
- Dir string
- Env []string
-}
-
-func (c command) mustRun(t *testing.T, args ...string) string {
- t.Helper()
- stdout := new(bytes.Buffer)
- stderr := new(bytes.Buffer)
- cmd := exec.Command(args[0], args[1:]...)
- cmd.Dir = "."
- if c.Dir != "" {
- cmd.Dir = c.Dir
- }
- cmd.Env = os.Environ()
- if c.Env != nil {
- cmd.Env = c.Env
- }
- cmd.Env = append(cmd.Env, "PWD="+cmd.Dir)
- cmd.Stdout = stdout
- cmd.Stderr = stderr
- if err := cmd.Run(); err != nil {
- t.Fatalf("executing (%v): %v\n%s%s", strings.Join(args, " "), err, stdout.String(), stderr.String())
- }
- return stdout.String()
-}
-
-func mustRunCommand(t *testing.T, args ...string) string {
- t.Helper()
- return command{}.mustRun(t, args...)
-}
generated by cgit v1.2.3 (git 2.25.1) at 2024-06-12 20:46:28 +0000