added lanai-cli basic testing lib and tests for init sub-command

Author: stonedu1011

cmd/lanai-cli/cmdtest/cmd.go

@@ -0,0 +1,118 @@
+package cmdtest
+
+import (
+	"context"
+	"fmt"
+	"github.com/cisco-open/go-lanai/cmd/lanai-cli/cmdutils"
+	"github.com/cisco-open/go-lanai/test"
+	"github.com/spf13/cobra"
+	"os"
+	"path/filepath"
+	"testing"
+)
+
+const (
+	TestTmpDir    = ".tmp"
+	TestOutputDir = "output"
+)
+
+var (
+	testRootCmd = &cobra.Command{
+		Use:                "lanai-cli-test",
+		Short:              "lanai-cli for test",
+		FParseErrWhitelist: cobra.FParseErrWhitelist{UnknownFlags: true},
+		PersistentPreRunE: cmdutils.MergeRunE(
+			cmdutils.EnsureGlobalDirectories(),
+			cmdutils.PrintEnvironment(),
+		),
+	}
+)
+
+func init() {
+	cmdutils.PersistentFlags(testRootCmd, &cmdutils.GlobalArgs)
+}
+
+func SetupResetPackageVars() test.SetupFunc {
+	return func(ctx context.Context, t *testing.T) (context.Context, error) {
+		cmdutils.ResetGoCmd()
+		return ctx, nil
+	}
+}
+
+// DryRunCobraCommand Run given cobra.Command in given work dir relative to "testdata"
+func DryRunCobraCommand(ctx context.Context, wd string, cmd *cobra.Command, handler TestDryRunHandler, args ...string) error {
+	// prepare global args
+	originalArgs := cmdutils.GlobalArgs
+	defer func() { cmdutils.GlobalArgs = originalArgs }()
+
+	cmdutils.GlobalArgs = cmdutils.Global{
+		WorkingDir: PathRelativeToTestdata(wd),
+		TmpDir:     PathRelativeToTestdata(wd, TestTmpDir),
+		OutputDir:  PathRelativeToTestdata(wd, TestOutputDir),
+		Verbose:    true,
+		DryRun:     true,
+	}
+
+	// setup dry run handler
+	if handler != nil {
+		cmdutils.GlobalArgs.DryRunFunc = handler.Handle
+	} else {
+		cmdutils.GlobalArgs.DryRunFunc = originalArgs.DryRunFunc
+	}
+
+	// clean up FS
+	if e := os.RemoveAll(cmdutils.GlobalArgs.OutputDir); e != nil {
+		return fmt.Errorf("unable to start command with clean FS: %w", e)
+	}
+
+	// run command
+	if len(args) == 0 {
+		args = []string{}
+	}
+	cmdCopy, _ := CopyCommandChain(cmd, args...)
+	return cmdCopy.ExecuteContext(ctx)
+}
+
+// CopyCommandChain do following things:
+// - Make copy of given command and its parents/ancestors.
+// - Fix arguments of its ancestors.
+// - Attach the given command chain to a copy of predefined test root command (to mimic how main() function works)
+// This function returns copied command and a copy of its root command. Two values may be same if they are the root
+func CopyCommandChain(cmd *cobra.Command, args...string) (cmdCpy, rootCpy *cobra.Command) {
+	cmdCpy = copyCmd(cmd)
+	var cpy, prev *cobra.Command
+	for cpy, prev = cmdCpy, nil; cpy != nil; cpy = copyCmd(cpy.Parent()) {
+		if prev != nil {
+			args = append([]string{prev.Name()}, args...)
+			cpy.ResetCommands()
+			cpy.AddCommand(prev)
+		}
+		cpy.SetArgs(args)
+		prev = cpy
+	}
+	rootCpy = copyCmd(testRootCmd)
+	if prev != nil {
+		args = append([]string{prev.Name()}, args...)
+		rootCpy.ResetCommands()
+		rootCpy.AddCommand(prev)
+	}
+	rootCpy.SetArgs(args)
+	return
+}
+
+func copyCmd(cmd *cobra.Command) *cobra.Command {
+	if cmd == nil {
+		return nil
+	}
+	vCopy := *cmd
+	return &vCopy
+}
+
+func PathRelativeToTestdata(pathComponents ...string) string {
+	if base, e := os.Getwd(); e != nil {
+		pathComponents = append([]string{"testdata"}, pathComponents...)
+	} else {
+		pathComponents = append([]string{base, "testdata"}, pathComponents...)
+	}
+	return filepath.Join(pathComponents...)
+}

cmd/lanai-cli/cmdtest/dryrun.go

@@ -0,0 +1,73 @@
+package cmdtest
+
+import (
+	"context"
+	"github.com/cisco-open/go-lanai/cmd/lanai-cli/cmdutils"
+	"github.com/cisco-open/go-lanai/pkg/utils/matcher"
+	"github.com/cisco-open/go-lanai/test"
+	"mvdan.cc/sh/v3/interp"
+	"mvdan.cc/sh/v3/syntax"
+	"testing"
+)
+
+func SetupDryRun(handler TestDryRunHandler) test.SetupFunc {
+	return func(ctx context.Context, t *testing.T) (context.Context, error) {
+		cmdutils.GlobalArgs.DryRun = true
+		if handler != nil {
+			cmdutils.GlobalArgs.DryRunFunc = handler.Handle
+		}
+		return ctx, nil
+	}
+}
+
+type TestDryRunHandler map[cmdutils.DryRunCmdType]cmdutils.DryRunFunc
+
+func (h TestDryRunHandler) Handle(ctx context.Context, cmdType cmdutils.DryRunCmdType, args ...interface{}) (interface{}, error) {
+	if handler, ok := h[cmdType]; ok {
+		return handler(ctx, cmdType, args...)
+	}
+	return nil, cmdutils.ErrDryRunIgnored
+}
+
+func DryRunShellWithFilter(ignoreMatched bool, matchers ...matcher.StringMatcher) cmdutils.DryRunFunc {
+	return func(ctx context.Context, cmdType cmdutils.DryRunCmdType, args ...interface{}) (interface{}, error) {
+		if cmdType != cmdutils.DryRunTypeShell || len(args) < 4 {
+			return nil, cmdutils.ErrDryRunIgnored
+		}
+
+		var cmd string
+		var runner *interp.Runner
+		var parsedCmd *syntax.File
+		for _, arg := range args {
+			switch v := arg.(type) {
+			case string:
+				cmd = v
+			case *interp.Runner:
+				runner = v
+			case *syntax.File:
+				parsedCmd = v
+			case *cmdutils.ShCmdOption:
+				// do nothing
+			default:
+				return nil, cmdutils.ErrDryRunIgnored
+			}
+		}
+
+		for _, m := range matchers {
+			ok, e := m.MatchesWithContext(ctx, cmd)
+			if e != nil || ignoreMatched && ok || !ignoreMatched && !ok || runner == nil || parsedCmd == nil {
+				continue
+			}
+			if e := runner.Run(ctx, parsedCmd); e != nil {
+				if status, ok := interp.IsExitStatus(e); ok {
+					return status, e
+				}
+				return uint8(1), e
+			}
+			return 0, nil
+		}
+
+		return nil, cmdutils.ErrDryRunIgnored
+	}
+}
+

cmd/lanai-cli/cmdtest/package.go

@@ -0,0 +1,10 @@
+package cmdtest
+
+import "github.com/cisco-open/go-lanai/test"
+
+func WithDryRun(handler TestDryRunHandler) test.Options {
+	return test.WithOptions(
+		test.SubTestSetup(SetupResetPackageVars()),
+		test.SubTestSetup(SetupDryRun(handler)),
+	)
+}

cmd/lanai-cli/cmdutils/flags.go

@@ -99,10 +99,11 @@ func parseStructForFlags(v reflect.Value) (ret []*flagMeta, err error) {
 		}
 
 		meta, e := parseStructFieldForFlags(f, fv)
-		if e != nil || meta == nil {
+		if e != nil {
 			return nil, e
+		} else if meta != nil {
+			ret = append(ret, meta)
 		}
-		ret = append(ret, meta)
 	}
 	return
 }

cmd/lanai-cli/cmdutils/global.go

@@ -17,6 +17,8 @@
 package cmdutils
 
 import (
+	"context"
+	"errors"
 	"github.com/cisco-open/go-lanai/pkg/log"
 	"os"
 	"path"
@@ -42,8 +44,22 @@ type Global struct {
 	OutputDir  string `flag:"output,o" desc:"output directory. All non-absolute paths for output are relative to this directory"`
 	Verbose    bool   `flag:"debug" desc:"show debug information"`
 	DryRun     bool   `flag:"dry-run" desc:"do not actually execute shell commands"`
+	// DryRunFunc Used for tests. To provide an alternative behavior when DryRun flag is detected.
+	// If not set (default case in non-testing execution), the behavior depends on supporting components.
+	// e.g. for shell command, the command is logged.
+	DryRunFunc DryRunFunc
 }
 
+var ErrDryRunIgnored = errors.New("dry-run: ignored command")
+
+type DryRunCmdType string
+
+// DryRunFunc Used for tests. To provide an alternative behavior when DryRun flag is detected.
+// Implementing function could return special error ErrDryRunIgnored to indicate there is no alternative way to perform dry-run,
+// and the caller should apply default behavior
+type DryRunFunc func(ctx context.Context, cmdType DryRunCmdType, args...interface{}) (interface{}, error)
+
+
 func (g Global) AbsPath(base, path string) string {
 	if filepath.IsAbs(path) {
 		return filepath.Clean(path)

cmd/lanai-cli/cmdutils/go_cmd.go

@@ -41,6 +41,15 @@ var (
 	packageImportPathCacheOnce = sync.Once{}
 )
 
+// ResetGoCmd Used for tests. Reset any package-level variables related to go command
+func ResetGoCmd() {
+	targetTmpGoModFile = ""
+	targetModule = nil
+	targetModuleOnce = sync.Once{}
+	packageImportPathCache = nil
+	packageImportPathCacheOnce = sync.Once{}
+}
+
 type GoCmdOptions func(goCmd *string)
 
 func GoCmdModFile(modFile string) GoCmdOptions {

cmd/lanai-cli/cmdutils/shell.go

@@ -18,6 +18,7 @@ package cmdutils
 
 import (
 	"context"
+	"errors"
 	"io"
 	"mvdan.cc/sh/v3/expand"
 	"mvdan.cc/sh/v3/interp"
@@ -42,6 +43,8 @@ type ShCmdOption struct {
 	Stderr io.Writer
 }
 
+var DryRunTypeShell DryRunCmdType = "shell"
+
 // ShellCmd add shell commends
 func ShellCmd(cmds ...string) ShCmdOptions {
 	return func(opt *ShCmdOption) {
@@ -150,6 +153,17 @@ func runSingleCommand(ctx context.Context, cmd string, opt *ShCmdOption) (uint8,
 	}
 
 	if GlobalArgs.DryRun {
+		if GlobalArgs.DryRunFunc != nil {
+			switch rs, e := GlobalArgs.DryRunFunc(ctx, DryRunTypeShell, cmd, opt, r, p); {
+			case e != nil && !errors.Is(e, ErrDryRunIgnored):
+				if status, ok := rs.(uint8); ok {
+					return status, e
+				}
+				return 1, e
+			case e == nil:
+				return 0, nil
+			}
+		}
 		logger.WithContext(ctx).Infof("Run: %s", cmd)
 		return 0, nil
 	}

cmd/lanai-cli/initcmd/binaries_test.go

@@ -2,15 +2,15 @@ package initcmd
 
 import (
 	"context"
-	"github.com/cisco-open/go-lanai/cmd/lanai-cli/cmdutils"
+	"github.com/cisco-open/go-lanai/cmd/lanai-cli/cmdtest"
 	"github.com/cisco-open/go-lanai/test"
 	"github.com/onsi/gomega"
 	"testing"
 )
 
 func TestInstallBinaries(t *testing.T) {
 	test.RunTest(context.Background(), t,
-		test.Setup(SetupGlobalArgs()),
+		cmdtest.WithDryRun(nil),
 		test.GomegaSubTest(SubTestWithBinaryOverride(), "WithBinaryOverride"),
 	)
 }
@@ -19,13 +19,6 @@ func TestInstallBinaries(t *testing.T) {
 	Sub-Test Cases
  *************************/
 
-func SetupGlobalArgs() test.SetupFunc {
-	return func(ctx context.Context, t *testing.T) (context.Context, error) {
-		cmdutils.GlobalArgs.DryRun = true
-		return ctx, nil
-	}
-}
-
 func SubTestWithBinaryOverride() test.GomegaSubTestFunc {
 	return func(ctx context.Context, t *testing.T, g *gomega.WithT) {
 		Module.Binaries = []*Binary{