From 6f63ac8d06042bcf92acd6de61ee717dcd8bad16 Mon Sep 17 00:00:00 2001 From: gedi Date: Tue, 20 Feb 2018 22:28:57 +0200 Subject: [PATCH] adapt to new compiler and linker in go tool chain --- .travis.yml | 6 +- builder.go | 2 + builder_go110.go | 331 +++++++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 338 insertions(+), 1 deletion(-) create mode 100644 builder_go110.go diff --git a/.travis.yml b/.travis.yml index 63bc304..e8904ac 100644 --- a/.travis.yml +++ b/.travis.yml @@ -5,14 +5,18 @@ go: - 1.7.x - 1.8.x - 1.9.x + - 1.10.x go_import_path: github.com/DATA-DOG/godog install: go install github.com/DATA-DOG/godog/cmd/godog script: - - go vet ./... + - go vet github.com/DATA-DOG/godog + - go vet github.com/DATA-DOG/godog/gherkin + - go vet github.com/DATA-DOG/godog/colors - test -z "$(go fmt ./...)" # fail if not formatted properly + - godog -f progress - go test -v -race -coverprofile=coverage.txt -covermode=atomic after_success: diff --git a/builder.go b/builder.go index 0089418..d27d25f 100644 --- a/builder.go +++ b/builder.go @@ -1,3 +1,5 @@ +// +build !go1.10 + package godog import ( diff --git a/builder_go110.go b/builder_go110.go new file mode 100644 index 0000000..5857c7c --- /dev/null +++ b/builder_go110.go @@ -0,0 +1,331 @@ +// +build go1.10 + +package godog + +import ( + "bytes" + "fmt" + "go/build" + "go/parser" + "go/token" + "io/ioutil" + "os" + "os/exec" + "path" + "path/filepath" + "strings" + "text/template" + "time" + "unicode" +) + +var tooldir = findToolDir() +var compiler = filepath.Join(tooldir, "compile") +var linker = filepath.Join(tooldir, "link") +var gopaths = filepath.SplitList(build.Default.GOPATH) +var goarch = build.Default.GOARCH +var goos = build.Default.GOOS + +var godogImportPath = "github.com/DATA-DOG/godog" +var runnerTemplate = template.Must(template.New("testmain").Parse(`package main + +import ( + "github.com/DATA-DOG/godog" + {{if .Contexts}}_test "{{.ImportPath}}"{{end}} + "os" +) + +func main() { + status := godog.Run("{{ .Name }}", func (suite *godog.Suite) { + os.Setenv("GODOG_TESTED_PACKAGE", "{{.ImportPath}}") + {{range .Contexts}} + _test.{{ . }}(suite) + {{end}} + }) + os.Exit(status) +}`)) + +// Build creates a test package like go test command at given target path. +// If there are no go files in tested directory, then +// it simply builds a godog executable to scan features. +// +// If there are go test files, it first builds a test +// package with standard go test command. +// +// Finally it generates godog suite executable which +// registers exported godog contexts from the test files +// of tested package. +// +// Returns the path to generated executable +func Build(bin string) error { + abs, err := filepath.Abs(".") + if err != nil { + return err + } + + // we allow package to be nil, if godog is run only when + // there is a feature file in empty directory + pkg := importPackage(abs) + src, anyContexts, err := buildTestMain(pkg) + if err != nil { + return err + } + + workdir := fmt.Sprintf(filepath.Join("%s", "godog-%d"), os.TempDir(), time.Now().UnixNano()) + testdir := workdir + + // if none of test files exist, or there are no contexts found + // we will skip test package compilation, since it is useless + if anyContexts { + // first of all compile test package dependencies + // that will save us many compilations for dependencies + // go does it better + out, err := exec.Command("go", "test", "-i").CombinedOutput() + if err != nil { + return fmt.Errorf("failed to compile package: %s, reason: %v, output: %s", pkg.Name, err, string(out)) + } + + // builds and compile the tested package. + // generated test executable will be removed + // since we do not need it for godog suite. + // we also print back the temp WORK directory + // go has built. We will reuse it for our suite workdir. + out, err = exec.Command("go", "test", "-c", "-work", "-o", "/dev/null").CombinedOutput() + if err != nil { + return fmt.Errorf("failed to compile tested package: %s, reason: %v, output: %s", pkg.Name, err, string(out)) + } + + // extract go-build temporary directory as our workdir + workdir = strings.TrimSpace(string(out)) + if !strings.HasPrefix(workdir, "WORK=") { + return fmt.Errorf("expected WORK dir path, but got: %s", workdir) + } + workdir = strings.Replace(workdir, "WORK=", "", 1) + testdir = filepath.Join(workdir, "b001") + } else { + // still need to create temporary workdir + if err = os.MkdirAll(testdir, 0755); err != nil { + return err + } + } + defer os.RemoveAll(workdir) + + // replace _testmain.go file with our own + testmain := filepath.Join(testdir, "_testmain.go") + err = ioutil.WriteFile(testmain, src, 0644) + if err != nil { + return err + } + + // godog library may not be imported in tested package + // but we need it for our testmain package. + // So we look it up in available source paths + // including vendor directory, supported since 1.5. + try := maybeVendorPaths(abs) + for _, d := range build.Default.SrcDirs() { + try = append(try, filepath.Join(d, godogImportPath)) + } + godogPkg, err := locatePackage(try) + if err != nil { + return err + } + + // make sure godog package archive is installed, gherkin + // will be installed as dependency of godog + cmd := exec.Command("go", "install", godogPkg.ImportPath) + cmd.Env = os.Environ() + out, err := cmd.CombinedOutput() + if err != nil { + return fmt.Errorf("failed to install godog package: %s, reason: %v", string(out), err) + } + + // collect all possible package dirs, will be + // used for includes and linker + pkgDirs := []string{workdir, testdir} + for _, gopath := range gopaths { + pkgDirs = append(pkgDirs, filepath.Join(gopath, "pkg", goos+"_"+goarch)) + } + pkgDirs = uniqStringList(pkgDirs) + + // compile godog testmain package archive + // we do not depend on CGO so a lot of checks are not necessary + testMainPkgOut := filepath.Join(testdir, "main.a") + args := []string{ + "-o", testMainPkgOut, + // "-trimpath", workdir, + "-importcfg", filepath.Join(testdir, "importcfg.link"), + "-p", "main", + "-complete", + } + // if godog library is in vendor directory + // link it with import map + if i := strings.LastIndex(godogPkg.ImportPath, "vendor/"); i != -1 { + args = append(args, "-importmap", godogImportPath+"="+godogPkg.ImportPath) + } + for _, inc := range pkgDirs { + args = append(args, "-I", inc) + } + args = append(args, "-pack", testmain) + cmd = exec.Command(compiler, args...) + cmd.Env = os.Environ() + out, err = cmd.CombinedOutput() + if err != nil { + return fmt.Errorf("failed to compile testmain package: %v - output: %s", err, string(out)) + } + + // link test suite executable + args = []string{ + "-o", bin, + "-importcfg", filepath.Join(testdir, "importcfg.link"), + "-buildmode=exe", + } + for _, link := range pkgDirs { + args = append(args, "-L", link) + } + args = append(args, testMainPkgOut) + cmd = exec.Command(linker, args...) + cmd.Env = os.Environ() + + out, err = cmd.CombinedOutput() + if err != nil { + msg := `failed to link test executable: + reason: %s + command: %s` + return fmt.Errorf(msg, string(out), linker+" '"+strings.Join(args, "' '")+"'") + } + + return nil +} + +func locatePackage(try []string) (*build.Package, error) { + for _, p := range try { + abs, err := filepath.Abs(p) + if err != nil { + continue + } + pkg, err := build.ImportDir(abs, 0) + if err != nil { + continue + } + return pkg, nil + } + return nil, fmt.Errorf("failed to find godog package in any of:\n%s", strings.Join(try, "\n")) +} + +func importPackage(dir string) *build.Package { + pkg, _ := build.ImportDir(dir, 0) + + // normalize import path for local import packages + // taken from go source code + // see: https://github.com/golang/go/blob/go1.7rc5/src/cmd/go/pkg.go#L279 + if pkg != nil && pkg.ImportPath == "." { + pkg.ImportPath = path.Join("_", strings.Map(makeImportValid, filepath.ToSlash(dir))) + } + + return pkg +} + +// from go src +func makeImportValid(r rune) rune { + // Should match Go spec, compilers, and ../../go/parser/parser.go:/isValidImport. + const illegalChars = `!"#$%&'()*,:;<=>?[\]^{|}` + "`\uFFFD" + if !unicode.IsGraphic(r) || unicode.IsSpace(r) || strings.ContainsRune(illegalChars, r) { + return '_' + } + return r +} + +func uniqStringList(strs []string) (unique []string) { + uniq := make(map[string]void, len(strs)) + for _, s := range strs { + if _, ok := uniq[s]; !ok { + uniq[s] = void{} + unique = append(unique, s) + } + } + return +} + +// buildTestMain if given package is valid +// it scans test files for contexts +// and produces a testmain source code. +func buildTestMain(pkg *build.Package) ([]byte, bool, error) { + var contexts []string + var importPath string + name := "main" + if nil != pkg { + ctxs, err := processPackageTestFiles( + pkg.TestGoFiles, + pkg.XTestGoFiles, + ) + if err != nil { + return nil, false, err + } + contexts = ctxs + importPath = pkg.ImportPath + name = pkg.Name + } + + data := struct { + Name string + Contexts []string + ImportPath string + }{name, contexts, importPath} + + var buf bytes.Buffer + if err := runnerTemplate.Execute(&buf, data); err != nil { + return nil, len(contexts) > 0, err + } + return buf.Bytes(), len(contexts) > 0, nil +} + +// maybeVendorPaths determines possible vendor paths +// which goes levels down from given directory +// until it reaches GOPATH source dir +func maybeVendorPaths(dir string) (paths []string) { + for _, gopath := range gopaths { + gopath = filepath.Join(gopath, "src") + for strings.HasPrefix(dir, gopath) && dir != gopath { + paths = append(paths, filepath.Join(dir, "vendor", godogImportPath)) + dir = filepath.Dir(dir) + } + } + return +} + +// processPackageTestFiles runs through ast of each test +// file pack and looks for godog suite contexts to register +// on run +func processPackageTestFiles(packs ...[]string) ([]string, error) { + var ctxs []string + fset := token.NewFileSet() + for _, pack := range packs { + for _, testFile := range pack { + node, err := parser.ParseFile(fset, testFile, nil, 0) + if err != nil { + return ctxs, err + } + + ctxs = append(ctxs, astContexts(node)...) + } + } + var failed []string + for _, ctx := range ctxs { + runes := []rune(ctx) + if unicode.IsLower(runes[0]) { + expected := append([]rune{unicode.ToUpper(runes[0])}, runes[1:]...) + failed = append(failed, fmt.Sprintf("%s - should be: %s", ctx, string(expected))) + } + } + if len(failed) > 0 { + return ctxs, fmt.Errorf("godog contexts must be exported:\n\t%s", strings.Join(failed, "\n\t")) + } + return ctxs, nil +} + +func findToolDir() string { + if out, err := exec.Command("go", "env", "GOTOOLDIR").Output(); err != nil { + return filepath.Clean(strings.TrimSpace(string(out))) + } + return filepath.Clean(build.ToolDir) +}