--- /dev/null
+// Copyright 2018 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.
+
+/*
+Package packagestest creates temporary projects on disk for testing go tools on.
+
+By changing the exporter used, you can create projects for multiple build
+systems from the same description, and run the same tests on them in many
+cases.
+
+Example
+
+As an example of packagestest use, consider the following test that runs
+the 'go list' command on the specified modules:
+
+ // TestGoList exercises the 'go list' command in module mode and in GOPATH mode.
+ func TestGoList(t *testing.T) { packagestest.TestAll(t, testGoList) }
+ func testGoList(t *testing.T, x packagestest.Exporter) {
+ e := packagestest.Export(t, x, []packagestest.Module{
+ {
+ Name: "gopher.example/repoa",
+ Files: map[string]interface{}{
+ "a/a.go": "package a",
+ },
+ },
+ {
+ Name: "gopher.example/repob",
+ Files: map[string]interface{}{
+ "b/b.go": "package b",
+ },
+ },
+ })
+ defer e.Cleanup()
+
+ cmd := exec.Command("go", "list", "gopher.example/...")
+ cmd.Dir = e.Config.Dir
+ cmd.Env = e.Config.Env
+ out, err := cmd.Output()
+ if err != nil {
+ t.Fatal(err)
+ }
+ t.Logf("'go list gopher.example/...' with %s mode layout:\n%s", x.Name(), out)
+ }
+
+TestGoList uses TestAll to exercise the 'go list' command with all
+exporters known to packagestest. Currently, packagestest includes
+exporters that produce module mode layouts and GOPATH mode layouts.
+Running the test with verbose output will print:
+
+ === RUN TestGoList
+ === RUN TestGoList/GOPATH
+ === RUN TestGoList/Modules
+ --- PASS: TestGoList (0.21s)
+ --- PASS: TestGoList/GOPATH (0.03s)
+ main_test.go:36: 'go list gopher.example/...' with GOPATH mode layout:
+ gopher.example/repoa/a
+ gopher.example/repob/b
+ --- PASS: TestGoList/Modules (0.18s)
+ main_test.go:36: 'go list gopher.example/...' with Modules mode layout:
+ gopher.example/repoa/a
+ gopher.example/repob/b
+
+*/
+package packagestest
+
+import (
+ "flag"
+ "fmt"
+ "go/token"
+ "io/ioutil"
+ "log"
+ "os"
+ "path/filepath"
+ "strings"
+ "testing"
+
+ "golang.org/x/tools/go/expect"
+ "golang.org/x/tools/go/packages"
+ "golang.org/x/tools/internal/span"
+ "golang.org/x/tools/internal/testenv"
+)
+
+var (
+ skipCleanup = flag.Bool("skip-cleanup", false, "Do not delete the temporary export folders") // for debugging
+)
+
+// Module is a representation of a go module.
+type Module struct {
+ // Name is the base name of the module as it would be in the go.mod file.
+ Name string
+ // Files is the set of source files for all packages that make up the module.
+ // The keys are the file fragment that follows the module name, the value can
+ // be a string or byte slice, in which case it is the contents of the
+ // file, otherwise it must be a Writer function.
+ Files map[string]interface{}
+
+ // Overlay is the set of source file overlays for the module.
+ // The keys are the file fragment as in the Files configuration.
+ // The values are the in memory overlay content for the file.
+ Overlay map[string][]byte
+}
+
+// A Writer is a function that writes out a test file.
+// It is provided the name of the file to write, and may return an error if it
+// cannot write the file.
+// These are used as the content of the Files map in a Module.
+type Writer func(filename string) error
+
+// Exported is returned by the Export function to report the structure that was produced on disk.
+type Exported struct {
+ // Config is a correctly configured packages.Config ready to be passed to packages.Load.
+ // Exactly what it will contain varies depending on the Exporter being used.
+ Config *packages.Config
+
+ // Modules is the module description that was used to produce this exported data set.
+ Modules []Module
+
+ ExpectFileSet *token.FileSet // The file set used when parsing expectations
+
+ Exporter Exporter // the exporter used
+ temp string // the temporary directory that was exported to
+ primary string // the first non GOROOT module that was exported
+ written map[string]map[string]string // the full set of exported files
+ notes []*expect.Note // The list of expectations extracted from go source files
+ markers map[string]span.Range // The set of markers extracted from go source files
+}
+
+// Exporter implementations are responsible for converting from the generic description of some
+// test data to a driver specific file layout.
+type Exporter interface {
+ // Name reports the name of the exporter, used in logging and sub-test generation.
+ Name() string
+ // Filename reports the system filename for test data source file.
+ // It is given the base directory, the module the file is part of and the filename fragment to
+ // work from.
+ Filename(exported *Exported, module, fragment string) string
+ // Finalize is called once all files have been written to write any extra data needed and modify
+ // the Config to match. It is handed the full list of modules that were encountered while writing
+ // files.
+ Finalize(exported *Exported) error
+}
+
+// All is the list of known exporters.
+// This is used by TestAll to run tests with all the exporters.
+var All []Exporter
+
+// TestAll invokes the testing function once for each exporter registered in
+// the All global.
+// Each exporter will be run as a sub-test named after the exporter being used.
+func TestAll(t *testing.T, f func(*testing.T, Exporter)) {
+ t.Helper()
+ for _, e := range All {
+ t.Run(e.Name(), func(t *testing.T) {
+ t.Helper()
+ f(t, e)
+ })
+ }
+}
+
+// BenchmarkAll invokes the testing function once for each exporter registered in
+// the All global.
+// Each exporter will be run as a sub-test named after the exporter being used.
+func BenchmarkAll(b *testing.B, f func(*testing.B, Exporter)) {
+ b.Helper()
+ for _, e := range All {
+ b.Run(e.Name(), func(b *testing.B) {
+ b.Helper()
+ f(b, e)
+ })
+ }
+}
+
+// Export is called to write out a test directory from within a test function.
+// It takes the exporter and the build system agnostic module descriptions, and
+// uses them to build a temporary directory.
+// It returns an Exported with the results of the export.
+// The Exported.Config is prepared for loading from the exported data.
+// You must invoke Exported.Cleanup on the returned value to clean up.
+// The file deletion in the cleanup can be skipped by setting the skip-cleanup
+// flag when invoking the test, allowing the temporary directory to be left for
+// debugging tests.
+func Export(t testing.TB, exporter Exporter, modules []Module) *Exported {
+ t.Helper()
+ if exporter == Modules {
+ testenv.NeedsTool(t, "go")
+ }
+
+ dirname := strings.Replace(t.Name(), "/", "_", -1)
+ dirname = strings.Replace(dirname, "#", "_", -1) // duplicate subtests get a #NNN suffix.
+ temp, err := ioutil.TempDir("", dirname)
+ if err != nil {
+ t.Fatal(err)
+ }
+ exported := &Exported{
+ Config: &packages.Config{
+ Dir: temp,
+ Env: append(os.Environ(), "GOPACKAGESDRIVER=off", "GOROOT="), // Clear GOROOT to work around #32849.
+ Overlay: make(map[string][]byte),
+ Tests: true,
+ Mode: packages.LoadImports,
+ },
+ Modules: modules,
+ Exporter: exporter,
+ temp: temp,
+ primary: modules[0].Name,
+ written: map[string]map[string]string{},
+ ExpectFileSet: token.NewFileSet(),
+ }
+ defer func() {
+ if t.Failed() || t.Skipped() {
+ exported.Cleanup()
+ }
+ }()
+ for _, module := range modules {
+ for fragment, value := range module.Files {
+ fullpath := exporter.Filename(exported, module.Name, filepath.FromSlash(fragment))
+ written, ok := exported.written[module.Name]
+ if !ok {
+ written = map[string]string{}
+ exported.written[module.Name] = written
+ }
+ written[fragment] = fullpath
+ if err := os.MkdirAll(filepath.Dir(fullpath), 0755); err != nil {
+ t.Fatal(err)
+ }
+ switch value := value.(type) {
+ case Writer:
+ if err := value(fullpath); err != nil {
+ t.Fatal(err)
+ }
+ case string:
+ if err := ioutil.WriteFile(fullpath, []byte(value), 0644); err != nil {
+ t.Fatal(err)
+ }
+ default:
+ t.Fatalf("Invalid type %T in files, must be string or Writer", value)
+ }
+ }
+ for fragment, value := range module.Overlay {
+ fullpath := exporter.Filename(exported, module.Name, filepath.FromSlash(fragment))
+ exported.Config.Overlay[fullpath] = value
+ }
+ }
+ if err := exporter.Finalize(exported); err != nil {
+ t.Fatal(err)
+ }
+ testenv.NeedsGoPackagesEnv(t, exported.Config.Env)
+ return exported
+}
+
+// Script returns a Writer that writes out contents to the file and sets the
+// executable bit on the created file.
+// It is intended for source files that are shell scripts.
+func Script(contents string) Writer {
+ return func(filename string) error {
+ return ioutil.WriteFile(filename, []byte(contents), 0755)
+ }
+}
+
+// Link returns a Writer that creates a hard link from the specified source to
+// the required file.
+// This is used to link testdata files into the generated testing tree.
+func Link(source string) Writer {
+ return func(filename string) error {
+ return os.Link(source, filename)
+ }
+}
+
+// Symlink returns a Writer that creates a symlink from the specified source to the
+// required file.
+// This is used to link testdata files into the generated testing tree.
+func Symlink(source string) Writer {
+ if !strings.HasPrefix(source, ".") {
+ if abspath, err := filepath.Abs(source); err == nil {
+ if _, err := os.Stat(source); !os.IsNotExist(err) {
+ source = abspath
+ }
+ }
+ }
+ return func(filename string) error {
+ return os.Symlink(source, filename)
+ }
+}
+
+// Copy returns a Writer that copies a file from the specified source to the
+// required file.
+// This is used to copy testdata files into the generated testing tree.
+func Copy(source string) Writer {
+ return func(filename string) error {
+ stat, err := os.Stat(source)
+ if err != nil {
+ return err
+ }
+ if !stat.Mode().IsRegular() {
+ // cannot copy non-regular files (e.g., directories,
+ // symlinks, devices, etc.)
+ return fmt.Errorf("cannot copy non regular file %s", source)
+ }
+ contents, err := ioutil.ReadFile(source)
+ if err != nil {
+ return err
+ }
+ return ioutil.WriteFile(filename, contents, stat.Mode())
+ }
+}
+
+// GroupFilesByModules attempts to map directories to the modules within each directory.
+// This function assumes that the folder is structured in the following way:
+// - dir
+// - primarymod
+// - .go files
+// - packages
+// - go.mod (optional)
+// - modules
+// - repoa
+// - mod1
+// - .go files
+// - packages
+// - go.mod (optional)
+// It scans the directory tree anchored at root and adds a Copy writer to the
+// map for every file found.
+// This is to enable the common case in tests where you have a full copy of the
+// package in your testdata.
+func GroupFilesByModules(root string) ([]Module, error) {
+ root = filepath.FromSlash(root)
+ primarymodPath := filepath.Join(root, "primarymod")
+
+ _, err := os.Stat(primarymodPath)
+ if os.IsNotExist(err) {
+ return nil, fmt.Errorf("could not find primarymod folder within %s", root)
+ }
+
+ primarymod := &Module{
+ Name: root,
+ Files: make(map[string]interface{}),
+ Overlay: make(map[string][]byte),
+ }
+ mods := map[string]*Module{
+ root: primarymod,
+ }
+ modules := []Module{*primarymod}
+
+ if err := filepath.Walk(primarymodPath, func(path string, info os.FileInfo, err error) error {
+ if err != nil {
+ return err
+ }
+ if info.IsDir() {
+ return nil
+ }
+ fragment, err := filepath.Rel(primarymodPath, path)
+ if err != nil {
+ return err
+ }
+ primarymod.Files[filepath.ToSlash(fragment)] = Copy(path)
+ return nil
+ }); err != nil {
+ return nil, err
+ }
+
+ modulesPath := filepath.Join(root, "modules")
+ if _, err := os.Stat(modulesPath); os.IsNotExist(err) {
+ return modules, nil
+ }
+
+ var currentRepo, currentModule string
+ updateCurrentModule := func(dir string) {
+ if dir == currentModule {
+ return
+ }
+ // Handle the case where we step into a nested directory that is a module
+ // and then step out into the parent which is also a module.
+ // Example:
+ // - repoa
+ // - moda
+ // - go.mod
+ // - v2
+ // - go.mod
+ // - what.go
+ // - modb
+ for dir != root {
+ if mods[dir] != nil {
+ currentModule = dir
+ return
+ }
+ dir = filepath.Dir(dir)
+ }
+ }
+
+ if err := filepath.Walk(modulesPath, func(path string, info os.FileInfo, err error) error {
+ if err != nil {
+ return err
+ }
+ enclosingDir := filepath.Dir(path)
+ // If the path is not a directory, then we want to add the path to
+ // the files map of the currentModule.
+ if !info.IsDir() {
+ updateCurrentModule(enclosingDir)
+ fragment, err := filepath.Rel(currentModule, path)
+ if err != nil {
+ return err
+ }
+ mods[currentModule].Files[filepath.ToSlash(fragment)] = Copy(path)
+ return nil
+ }
+ // If the path is a directory and it's enclosing folder is equal to
+ // the modules folder, then the path is a new repo.
+ if enclosingDir == modulesPath {
+ currentRepo = path
+ return nil
+ }
+ // If the path is a directory and it's enclosing folder is not the same
+ // as the current repo and it is not of the form `v1`,`v2`,...
+ // then the path is a folder/package of the current module.
+ if enclosingDir != currentRepo && !versionSuffixRE.MatchString(filepath.Base(path)) {
+ return nil
+ }
+ // If the path is a directory and it's enclosing folder is the current repo
+ // then the path is a new module.
+ module, err := filepath.Rel(modulesPath, path)
+ if err != nil {
+ return err
+ }
+ mods[path] = &Module{
+ Name: filepath.ToSlash(module),
+ Files: make(map[string]interface{}),
+ Overlay: make(map[string][]byte),
+ }
+ currentModule = path
+ modules = append(modules, *mods[path])
+ return nil
+ }); err != nil {
+ return nil, err
+ }
+ return modules, nil
+}
+
+// MustCopyFileTree returns a file set for a module based on a real directory tree.
+// It scans the directory tree anchored at root and adds a Copy writer to the
+// map for every file found.
+// This is to enable the common case in tests where you have a full copy of the
+// package in your testdata.
+// This will panic if there is any kind of error trying to walk the file tree.
+func MustCopyFileTree(root string) map[string]interface{} {
+ result := map[string]interface{}{}
+ if err := filepath.Walk(filepath.FromSlash(root), func(path string, info os.FileInfo, err error) error {
+ if err != nil {
+ return err
+ }
+ if info.IsDir() {
+ return nil
+ }
+ fragment, err := filepath.Rel(root, path)
+ if err != nil {
+ return err
+ }
+ result[filepath.ToSlash(fragment)] = Copy(path)
+ return nil
+ }); err != nil {
+ log.Panic(fmt.Sprintf("MustCopyFileTree failed: %v", err))
+ }
+ return result
+}
+
+// Cleanup removes the temporary directory (unless the --skip-cleanup flag was set)
+// It is safe to call cleanup multiple times.
+func (e *Exported) Cleanup() {
+ if e.temp == "" {
+ return
+ }
+ if *skipCleanup {
+ log.Printf("Skipping cleanup of temp dir: %s", e.temp)
+ return
+ }
+ // Make everything read-write so that the Module exporter's module cache can be deleted.
+ filepath.Walk(e.temp, func(path string, info os.FileInfo, err error) error {
+ if err != nil {
+ return nil
+ }
+ if info.IsDir() {
+ os.Chmod(path, 0777)
+ }
+ return nil
+ })
+ os.RemoveAll(e.temp) // ignore errors
+ e.temp = ""
+}
+
+// Temp returns the temporary directory that was generated.
+func (e *Exported) Temp() string {
+ return e.temp
+}
+
+// File returns the full path for the given module and file fragment.
+func (e *Exported) File(module, fragment string) string {
+ if m := e.written[module]; m != nil {
+ return m[fragment]
+ }
+ return ""
+}
+
+// FileContents returns the contents of the specified file.
+// It will use the overlay if the file is present, otherwise it will read it
+// from disk.
+func (e *Exported) FileContents(filename string) ([]byte, error) {
+ if content, found := e.Config.Overlay[filename]; found {
+ return content, nil
+ }
+ content, err := ioutil.ReadFile(filename)
+ if err != nil {
+ return nil, err
+ }
+ return content, nil
+}
projects / dotfiles / .git / blobdiff