Task improving test

internal/cmd/root.go

@@ -100,7 +100,7 @@ func cmd() *cobra.Command {
 	generateCmd := generate.Cmd()
 	destroyCmd := destroy.Cmd()
 	versionCmd := version.Cmd()
-	testCmd := test.Cmd()
+	testCmd := test.Cmd
 	devCmd := dev.Cmd()
 	taskCmd := task.Cmd()
 	routesCmd := routes.Cmd()

internal/cmd/test/build_cmd.go

@@ -0,0 +1,112 @@
+package test
+
+import (
+	"os"
+	"os/exec"
+	"strings"
+
+	"github.com/gobuffalo/envy"
+	"github.com/gobuffalo/meta"
+)
+
+var (
+	// if GO_BIN is set, use it, otherwise use "go"
+	goBinary = envy.Get("GO_BIN", "go")
+
+	// testValuedFlags are the flags on the go test command that
+	// receive a value, we use this to determine if the last argument
+	// is a flag or a package path
+	testValuedFlags = strings.Join([]string{
+		`-p`, `-asmflags`, `-buildmode`, `-compiler`, `-gccgoflags`,
+		`-gcflags`, `-installsuffix`, `-mod`, `-modfile`, `-overlay`,
+		`-pkgdir`, `-tags`, `-trimpath`, `-toolexec`, `-o`, `-exec`,
+		`-bench`, `-benchtime`, `-blockprofile`, `-blockprofilerate`,
+		`-count`, `-coverprofile`, `-cpu`, `-cpuprofile`, `-fuzz `,
+		`-fuzzcachedir`, `-fuzzminimizetime`, `-fuzztime`, `-list`,
+		`-memprofile`, `-memprofilerate`, `-mutexprofile`, `-mutexprofilefraction`,
+		`-outputdir`, `-parallel`, `-run`, `-shuffle`, `-testlogfile`,
+		`-timeout`, `-trace`,
+	}, "|")
+)
+
+// buildCmd builds the test command to be passed to the go test command
+// after cutting some of the arguments that are specific to buffalo and adding
+// packages if missing.
+func buildCmd(args []string) (*exec.Cmd, error) {
+	app := meta.New(".")
+
+	ccar := clean(args)
+	cargs := append([]string{
+		"test",
+		// run sequentially
+		"-p", "1",
+		// add build tags
+		"-tags", app.BuildTags("development").String(),
+		//TODO: Should we merge it with passed tags?
+	}, ccar...)
+
+	// if no packages are specified, add the current directory
+	lastIsFlag := len(ccar) > 0 && strings.HasPrefix(args[len(ccar)-1], "-")
+	lastIsFlagValue := len(ccar) >= 2 && strings.Contains(testValuedFlags, ccar[len(ccar)-2])
+	if len(ccar) == 0 || lastIsFlag || lastIsFlagValue {
+		pkgs, err := findPackages()
+		if err != nil {
+			return nil, err
+		}
+
+		cargs = append(cargs, pkgs...)
+	}
+
+	// Add extra args (-testify.m) to the command
+	cargs = append(cargs, extraArgs(args)...)
+
+	cmd := exec.Command(goBinary, cargs...)
+	cmd.Stdin = os.Stdin
+	cmd.Stdout = os.Stdout
+	cmd.Stderr = os.Stderr
+
+	return cmd, nil
+}
+
+// Removes flags that are only used by the Buffalo test command and should not be passed to
+// the Go test command. Those flags are:
+// * --force-migrations
+// * -m
+// * -testify.m
+func clean(args []string) []string {
+	var cleaned []string
+	for ix, v := range args {
+		if v == "--force-migrations" {
+			continue
+		}
+
+		if v == "-m" || (ix > 0 && !strings.HasPrefix(v, "-") && args[ix-1] == "-m") {
+			continue
+		}
+
+		if v == "-testify.m" || (ix > 0 && !strings.HasPrefix(v, "-") && args[ix-1] == "-testify.m") {
+			continue
+		}
+
+		cleaned = append(cleaned, v)
+	}
+
+	return cleaned
+}
+
+// Adds extra flags to the go test command for the testify functionality if the
+// -testify.m or -m flags are passed.
+func extraArgs(args []string) []string {
+	var extra []string
+	for ix, v := range args {
+		if ix >= len(args)-1 || strings.HasPrefix(args[ix+1], "-") {
+			continue
+		}
+
+		if v == "-m" || v == "-testify.m" || v == "-run" {
+			extra = append(extra, "-testify.m", args[ix+1])
+		}
+	}
+
+	return extra
+}

internal/cmd/test/build_cmd_test.go

@@ -0,0 +1,99 @@
+package test
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestBuildCmd(t *testing.T) {
+	tcases := []struct {
+		name     string
+		args     []string
+		want     []string
+		contains string
+	}{
+		{
+			name: "no args",
+			args: []string{},
+			want: []string{"go", "test", "-p", "1", "-tags", "development"},
+		},
+
+		{
+			name: "path specified",
+			args: []string{"./cmd/..."},
+			want: []string{"go", "test", "-p", "1", "-tags", "development", "./cmd/..."},
+		},
+
+		{
+			name: "path specified and flags",
+			args: []string{"--count=1", "./cmd/..."},
+			want: []string{"go", "test", "-p", "1", "-tags", "development", "--count=1", "./cmd/..."},
+		},
+
+		{
+			name: "flags but no path",
+			args: []string{"--count=1", "-v"},
+			want: []string{"go", "test", "-p", "1", "-tags", "development", "--count=1", "-v"},
+		},
+
+		{
+			name: "flags but no path",
+			args: []string{"--count=1", "-v"},
+			want: []string{"go", "test", "-p", "1", "-tags", "development", "--count=1", "-v"},
+		},
+
+		{
+			name: "flags no path with -tags",
+			args: []string{"--count=1", "-tags", "foo,bar"},
+			want: []string{"go", "test", "-p", "1", "-tags", "development", "--count=1", "-tags", "foo,bar"},
+		},
+
+		{
+			name: "force migrations should be removed",
+			args: []string{"--force-migrations", "-tags", "foo,bar"},
+			want: []string{"go", "test", "-p", "1", "-tags", "development", "-tags", "foo,bar"},
+		},
+
+		{
+			name:     "testify.m through -m",
+			args:     []string{"--force-migrations", "-m", "Something"},
+			want:     []string{"go", "test", "-p", "1", "-tags", "development"},
+			contains: "-testify.m Something",
+		},
+
+		{
+			name:     "testify.m through -run",
+			args:     []string{"--force-migrations", "-run", "Something"},
+			want:     []string{"go", "test", "-p", "1", "-tags", "development", "-run", "Something"},
+			contains: "-testify.m Something",
+		},
+
+		{
+			name:     "testify.m should go at the end",
+			args:     []string{"--force-migrations", "-testify.m", "Something"},
+			want:     []string{"go", "test", "-p", "1", "-tags", "development"},
+			contains: "-testify.m Something",
+		},
+	}
+
+	for _, tc := range tcases {
+		t.Run(tc.name, func(t *testing.T) {
+			cmd, err := buildCmd(tc.args)
+			if err != nil {
+				t.Fatal(err)
+			}
+
+			wantcmd := strings.Join(tc.want, " ")
+			resultcmd := strings.Join(cmd.Args, " ")
+
+			prefixMatches := strings.HasPrefix(resultcmd, wantcmd)
+			if !prefixMatches {
+				t.Errorf("prefix `%s` not found in `%s`", wantcmd, resultcmd)
+			}
+
+			if tc.contains != "" && !strings.Contains(resultcmd, tc.contains) {
+				t.Errorf("string `%s` not found in `%s`", tc.contains, resultcmd)
+			}
+		})
+	}
+}

internal/cmd/test/find_packages.go

@@ -0,0 +1,29 @@
+package test
+
+import (
+	"golang.org/x/tools/go/packages"
+)
+
+// findPackages in the current directory using the x/tools/go/packages API
+func findPackages() ([]string, error) {
+	cfg := &packages.Config{
+		Mode: packages.NeedName,
+		Dir:  ".",
+	}
+
+	pkgs, err := packages.Load(cfg, "./...")
+	if err != nil {
+		return []string{}, err
+	}
+
+	if packages.PrintErrors(pkgs) > 0 {
+		return []string{}, err
+	}
+
+	xx := []string{}
+	for _, pkg := range pkgs {
+		xx = append(xx, pkg.ID)
+	}
+
+	return xx, nil
+}

internal/cmd/test/longhelp.txt

@@ -0,0 +1,13 @@
+Runs the Buffalo tests. This command sets the GO_ENV to be `test`
+and sets up the database in preparation for the tests.
+
+    --force-migrations  forces the migrations to run even if the schema.sql is found
+                        in the migrations folder
+
+    -testify.m          Only run tests matching the regular expression
+    -m                  Only run tests matching the regular expression
+
+The value passed to the -run flag is also passed to the -testify.m flag. 
+Any other flag is directly passed to the `go test` command.
+
+

internal/cmd/test/setup_database.go

@@ -0,0 +1,77 @@
+package test
+
+import (
+	"bytes"
+	"fmt"
+	"io"
+	"os"
+	"path/filepath"
+	"strings"
+
+	"github.com/gobuffalo/pop/v6"
+)
+
+func setupDatabase(args []string) error {
+	if _, err := os.Stat("database.yml"); err != nil {
+		return err
+	}
+
+	test, err := pop.Connect("test")
+	if err != nil {
+		return err
+	}
+
+	// drop the test db:
+	if err := test.Dialect.DropDB(); err != nil {
+		// not an error, since the database will be created in the next step anyway
+		fmt.Println("INFO: no test database to drop.")
+	}
+
+	// create the test db:
+	err = test.Dialect.CreateDB()
+	if err != nil {
+		return err
+	}
+
+	forceMigrations := strings.Contains(strings.Join(args, " "), "--force-migrations")
+	if forceMigrations {
+		fm, err := pop.NewFileMigrator("./migrations", test)
+		if err != nil {
+			return err
+		}
+
+		return fm.Up()
+	}
+
+	if schema := findSchema(); schema != nil {
+		return test.Dialect.LoadSchema(schema)
+	}
+
+	return nil
+}
+
+func findSchema() io.Reader {
+	if f, err := os.Open(filepath.Join("migrations", "schema.sql")); err == nil {
+		return f
+	}
+
+	if dev, err := pop.Connect("development"); err == nil {
+		schema := &bytes.Buffer{}
+		if err = dev.Dialect.DumpSchema(schema); err == nil {
+			return schema
+		}
+	}
+
+	if test, err := pop.Connect("test"); err == nil {
+		fm, err := pop.NewFileMigrator("./migrations", test)
+		if err != nil {
+			return nil
+		}
+
+		if err := fm.Up(); err == nil {
+			return nil
+		}
+	}
+
+	return nil
+}