Lint fixes

Signed-off-by: apostasie <[email protected]>

Author: apostasie

mod/tigron/require/requirement.go

@@ -26,7 +26,7 @@ import (
 
 func Binary(name string) *test.Requirement {
 	return &test.Requirement{
-		Check: func(data test.Data, helpers test.Helpers) (bool, string) {
+		Check: func(_ test.Data, _ test.Helpers) (bool, string) {
 			mess := fmt.Sprintf("executable %q has been found in PATH", name)
 			ret := true
 			if _, err := exec.LookPath(name); err != nil {
@@ -41,7 +41,7 @@ func Binary(name string) *test.Requirement {
 
 func OS(os string) *test.Requirement {
 	return &test.Requirement{
-		Check: func(data test.Data, helpers test.Helpers) (bool, string) {
+		Check: func(_ test.Data, _ test.Helpers) (bool, string) {
 			mess := fmt.Sprintf("current operating system is %q", runtime.GOOS)
 			ret := true
 			if runtime.GOOS != os {
@@ -55,7 +55,7 @@ func OS(os string) *test.Requirement {
 
 func Arch(arch string) *test.Requirement {
 	return &test.Requirement{
-		Check: func(data test.Data, helpers test.Helpers) (bool, string) {
+		Check: func(_ test.Data, _ test.Helpers) (bool, string) {
 			mess := fmt.Sprintf("current architecture is %q", runtime.GOARCH)
 			ret := true
 			if runtime.GOARCH != arch {
@@ -67,18 +67,22 @@ func Arch(arch string) *test.Requirement {
 	}
 }
 
-var Amd64 = Arch("amd64")
-var Arm64 = Arch("arm64")
-var Windows = OS("windows")
-var Linux = OS("linux")
-var Darwin = OS("darwin")
+//nolint:gochecknoglobals
+var (
+	Amd64   = Arch("amd64")
+	Arm64   = Arch("arm64")
+	Windows = OS("windows")
+	Linux   = OS("linux")
+	Darwin  = OS("darwin")
+)
 
-// NOTE: Not will always lose setups and cleanups...
+// NOTE: Not will always ignore any setup and cleanup inside the wrapped requirement.
 
 func Not(requirement *test.Requirement) *test.Requirement {
 	return &test.Requirement{
 		Check: func(data test.Data, helpers test.Helpers) (bool, string) {
 			ret, mess := requirement.Check(data, helpers)
+
 			return !ret, mess
 		},
 	}
@@ -93,10 +97,12 @@ func All(requirements ...*test.Requirement) *test.Requirement {
 			for _, requirement := range requirements {
 				ret, subMess = requirement.Check(data, helpers)
 				mess += "\n" + subMess
+
 				if !ret {
 					return ret, mess
 				}
 			}
+
 			return ret, mess
 		},
 		Setup: func(data test.Data, helpers test.Helpers) {

mod/tigron/test/case.go

@@ -59,10 +59,13 @@ type Case struct {
 	parent  *Case
 }
 
-// Run prepares and executes the test, and any possible subtests
+// Run prepares and executes the test, and any possible subtests.
+//
+//nolint:gocognit
 func (test *Case) Run(t *testing.T) {
 	t.Helper()
 	// Run the test
+	//nolint:thelper
 	testRun := func(subT *testing.T) {
 		subT.Helper()
 
@@ -81,10 +84,13 @@ func (test *Case) Run(t *testing.T) {
 
 		// If we have a parent, get parent env, data and config
 		var parentData Data
+
 		var parentConfig Config
+
 		if test.parent != nil {
 			parentData = test.parent.Data
 			parentConfig = test.parent.Config
+
 			for k, v := range test.parent.Env {
 				if _, ok := test.Env[k]; !ok {
 					test.Env[k] = v
@@ -96,23 +102,22 @@ func (test *Case) Run(t *testing.T) {
 		test.Data = configureData(test.t, test.Data, parentData)
 		test.Config = configureConfig(test.Config, parentConfig)
 
-		var b CustomizableCommand
+		var custCom CustomizableCommand
 		if registeredTestable == nil {
-			b = &GenericCommand{}
+			custCom = &GenericCommand{}
 		} else {
-			b = registeredTestable.CustomCommand(test, test.t)
+			custCom = registeredTestable.CustomCommand(test, test.t)
 		}
 
-		b.WithCwd(test.Data.TempDir())
-
-		b.withT(test.t)
-		b.withTempDir(test.Data.TempDir())
-		b.withEnv(test.Env)
-		b.withConfig(test.Config)
+		custCom.WithCwd(test.Data.TempDir())
+		custCom.withT(test.t)
+		custCom.withTempDir(test.Data.TempDir())
+		custCom.withEnv(test.Env)
+		custCom.withConfig(test.Config)
 
 		// Attach the base command, and t
 		test.helpers = &helpersInternal{
-			cmdInternal: b,
+			cmdInternal: custCom,
 			t:           test.t,
 		}
 
@@ -125,9 +130,11 @@ func (test *Case) Run(t *testing.T) {
 			if !shouldRun {
 				test.t.Skipf("test skipped as: %s", message)
 			}
+
 			if test.Require.Setup != nil {
 				setups = append(setups, test.Require.Setup)
 			}
+
 			if test.Require.Cleanup != nil {
 				cleanups = append(cleanups, test.Require.Cleanup)
 			}
@@ -154,35 +161,46 @@ func (test *Case) Run(t *testing.T) {
 		}
 
 		// Execute cleanups now
+		test.t.Log("")
 		test.t.Log("======================== Pre-test cleanup ========================")
+
 		for _, cleanup := range cleanups {
 			cleanup(test.Data, test.helpers)
 		}
 
 		// Register the cleanups, in reverse
 		test.t.Cleanup(func() {
+			test.t.Log("")
 			test.t.Log("======================== Post-test cleanup ========================")
+
 			slices.Reverse(cleanups)
+
 			for _, cleanup := range cleanups {
 				cleanup(test.Data, test.helpers)
 			}
 		})
 
 		// Run the setups
+		test.t.Log("")
 		test.t.Log("======================== Test setup ========================")
+
 		for _, setup := range setups {
 			setup(test.Data, test.helpers)
 		}
 
 		// Run the command if any, with expectations
 		// Note: if we have a command, we already know we DO have Expected
+		test.t.Log("")
 		test.t.Log("======================== Test Run ========================")
+
 		if test.Command != nil {
 			test.Command(test.Data, test.helpers).Run(test.Expected(test.Data, test.helpers))
 		}
 
 		// Now go for the subtests
+		test.t.Log("")
 		test.t.Log("======================== Processing subtests ========================")
+
 		for _, subTest := range test.SubTests {
 			subTest.parent = test
 			subTest.Run(test.t)

mod/tigron/test/command.go

@@ -65,7 +65,7 @@ type CustomizableCommand interface {
 	read(key ConfigKey) ConfigValue
 }
 
-// GenericCommand is a concrete Command implementation
+// GenericCommand is a concrete Command implementation.
 type GenericCommand struct {
 	Config  Config
 	TempDir string
@@ -122,15 +122,20 @@ func (gc *GenericCommand) Run(expect *Expected) {
 		gc.t.Helper()
 	}
 
-	var result *icmd.Result
-	var env []string
+	var (
+		result *icmd.Result
+		env    []string
+		tty    *os.File
+		psty   *os.File
+	)
+
 	output := &bytes.Buffer{}
 	stdout := ""
 	copyGroup := &errgroup.Group{}
-	var tty *os.File
-	var psty *os.File
+
 	if !gc.async {
 		iCmdCmd := gc.boot()
+
 		if gc.pty {
 			psty, tty, _ = pty.Open()
 			_, _ = term.MakeRaw(int(tty.Fd()))
@@ -141,6 +146,7 @@ func (gc *GenericCommand) Run(expect *Expected) {
 			// Copy from the master
 			copyGroup.Go(func() error {
 				_, _ = io.Copy(output, psty)
+
 				return nil
 			})
 
@@ -195,25 +201,29 @@ func (gc *GenericCommand) Run(expect *Expected) {
 	if expect != nil {
 		// Build the debug string - additionally attach the env (which iCmd does not do)
 		debug := result.String() + "Env:\n" + strings.Join(env, "\n")
+
 		// ExitCode goes first
-		if expect.ExitCode == internal.ExitCodeNoCheck { //nolint:revive
+		switch expect.ExitCode {
+		case internal.ExitCodeNoCheck:
 			// ExitCodeNoCheck means we do not care at all about exit code. It can be a failure, a success, or a timeout.
-		} else if expect.ExitCode == internal.ExitCodeGenericFail {
+		case internal.ExitCodeGenericFail:
 			// ExitCodeGenericFail means we expect an error (excluding timeout).
 			assert.Assert(gc.t, result.ExitCode != 0,
-				"Command succeeded while we were expecting an error\n"+debug)
-		} else if result.Timeout {
+				"Expected exit code to be different than 0\n"+debug)
+		case internal.ExitCodeTimeout:
 			assert.Assert(gc.t, expect.ExitCode == internal.ExitCodeTimeout,
 				"Command unexpectedly timed-out\n"+debug)
-		} else {
+		default:
 			assert.Assert(gc.t, expect.ExitCode == result.ExitCode,
 				fmt.Sprintf("Expected exit code: %d\n", expect.ExitCode)+debug)
 		}
+
 		// Range through the expected errors and confirm they are seen on stderr
 		for _, expectErr := range expect.Errors {
 			assert.Assert(gc.t, strings.Contains(gc.rawStdErr, expectErr.Error()),
 				fmt.Sprintf("Expected error: %q to be found in stderr\n", expectErr.Error())+debug)
 		}
+
 		// Finally, check the output if we are asked to
 		if expect.Output != nil {
 			expect.Output(stdout, debug, gc.t)
@@ -228,19 +238,22 @@ func (gc *GenericCommand) Stderr() string {
 func (gc *GenericCommand) Background(timeout time.Duration) {
 	// Run it
 	gc.async = true
+
 	i := gc.boot()
+
 	gc.timeout = timeout
 	gc.result = icmd.StartCmd(i)
 }
 
 func (gc *GenericCommand) Signal(sig os.Signal) error {
-	return gc.result.Cmd.Process.Signal(sig)
+	return gc.result.Cmd.Process.Signal(sig) //nolint:wrapcheck
 }
 
 func (gc *GenericCommand) withEnv(env map[string]string) {
 	if gc.Env == nil {
 		gc.Env = map[string]string{}
 	}
+
 	for k, v := range env {
 		gc.Env[k] = v
 	}
@@ -262,43 +275,48 @@ func (gc *GenericCommand) PrependArgs(args ...string) {
 	gc.prependArgs = append(gc.prependArgs, args...)
 }
 
+//nolint:ireturn
 func (gc *GenericCommand) Clone() TestableCommand {
 	// Copy the command and return a new one - with almost everything from the parent command
-	cc := *gc
-	cc.result = nil
-	cc.stdin = nil
-	cc.timeout = 0
-	cc.rawStdErr = ""
+	com := *gc
+	com.result = nil
+	com.stdin = nil
+	com.timeout = 0
+	com.rawStdErr = ""
 	// Clone Env
-	cc.Env = make(map[string]string, len(gc.Env))
+	com.Env = make(map[string]string, len(gc.Env))
 	for k, v := range gc.Env {
-		cc.Env[k] = v
+		com.Env[k] = v
 	}
-	return &cc
+
+	return &com
 }
 
 func (gc *GenericCommand) T() *testing.T {
 	return gc.t
 }
 
+//nolint:ireturn
 func (gc *GenericCommand) clear() TestableCommand {
-	cc := *gc
-	cc.mainBinary = ""
-	cc.helperBinary = ""
-	cc.mainArgs = []string{}
-	cc.prependArgs = []string{}
-	cc.helperArgs = []string{}
+	com := *gc
+	com.mainBinary = ""
+	com.helperBinary = ""
+	com.mainArgs = []string{}
+	com.prependArgs = []string{}
+	com.helperArgs = []string{}
 	// Clone Env
-	cc.Env = make(map[string]string, len(gc.Env))
+	com.Env = make(map[string]string, len(gc.Env))
 	// Reset configuration
-	cc.Config = &config{}
+	com.Config = &config{}
 	for k, v := range gc.Env {
-		cc.Env[k] = v
+		com.Env[k] = v
 	}
-	return &cc
+
+	return &com
 }
 
 func (gc *GenericCommand) withT(t *testing.T) {
+	t.Helper()
 	gc.t = t
 }
 
@@ -317,7 +335,9 @@ func (gc *GenericCommand) boot() icmd.Cmd {
 	}
 
 	binary := gc.mainBinary
+	//nolint:gocritic
 	args := append(gc.prependArgs, gc.mainArgs...)
+
 	if gc.helperBinary != "" {
 		args = append([]string{binary}, args...)
 		args = append(gc.helperArgs, args...)
@@ -330,16 +350,20 @@ func (gc *GenericCommand) boot() icmd.Cmd {
 
 	iCmdCmd := icmd.Command(binary, args...)
 	iCmdCmd.Env = []string{}
-	for _, v := range os.Environ() {
+
+	for _, envValue := range os.Environ() {
 		add := true
+
 		for _, b := range gc.envBlackList {
-			if strings.HasPrefix(v, b+"=") {
+			if strings.HasPrefix(envValue, b+"=") {
 				add = false
+
 				break
 			}
 		}
+
 		if add {
-			iCmdCmd.Env = append(iCmdCmd.Env, v)
+			iCmdCmd.Env = append(iCmdCmd.Env, envValue)
 		}
 	}