chore: tests simplification

Author: denis256

internal/shell/run_cmd.go

@@ -154,7 +154,8 @@ func (o *ShellOptions) WithForwardTFStdout(f bool) *ShellOptions {
 	return o
 }
 
-// WithExec sets the vexec.Exec used by RunCommandWithOutput.
+// WithExec installs a vexec.Exec backend that replaces the default os/exec
+// path used by RunCommandWithOutput. Pass nil to clear it. Intended for tests.
 func (o *ShellOptions) WithExec(e vexec.Exec) *ShellOptions {
 	o.Exec = e
 

internal/shell/run_cmd_test.go

@@ -2,19 +2,35 @@ package shell_test
 
 import (
 	"bytes"
+	"context"
 	"testing"
 
 	"github.com/gruntwork-io/terragrunt/internal/cache"
 	"github.com/gruntwork-io/terragrunt/internal/configbridge"
 	"github.com/gruntwork-io/terragrunt/internal/iacargs"
 	"github.com/gruntwork-io/terragrunt/internal/shell"
+	"github.com/gruntwork-io/terragrunt/internal/vexec"
 	"github.com/gruntwork-io/terragrunt/test/helpers/logger"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 
 	"github.com/gruntwork-io/terragrunt/pkg/options"
 )
 
+func TestShellOptionsWithExecRoundTrip(t *testing.T) {
+	t.Parallel()
+
+	memExec := vexec.NewMemExec(func(_ context.Context, _ vexec.Invocation) vexec.Result {
+		return vexec.Result{}
+	})
+
+	opts := shell.NewShellOptions().WithExec(memExec)
+	assert.Same(t, memExec, opts.Exec, "WithExec must store the executor")
+
+	opts.WithExec(nil)
+	assert.Nil(t, opts.Exec, "WithExec(nil) must clear the executor")
+}
+
 func TestRunShellCommand(t *testing.T) {
 	t.Parallel()
 

internal/util/collections_test.go

@@ -241,3 +241,41 @@ func TestMergeSlices(t *testing.T) {
 		})
 	}
 }
+
+// TestEnvSliceFromMap pins the contract: length matches input, output is sorted,
+// and every k=v pair from the input is present (including values containing '=').
+func TestEnvSliceFromMap(t *testing.T) {
+	t.Parallel()
+
+	testCases := []struct {
+		in   map[string]string
+		name string
+		want []string
+	}{
+		{name: "nil", in: nil, want: []string{}},
+		{name: "empty", in: map[string]string{}, want: []string{}},
+		{name: "single", in: map[string]string{"FOO": "bar"}, want: []string{"FOO=bar"}},
+		{
+			name: "multiple-overlapping-prefixes",
+			in:   map[string]string{"FOOBAR": "1", "FOO": "0", "FOOZ": "2"},
+			want: []string{"FOO=0", "FOOBAR=1", "FOOZ=2"},
+		},
+		{
+			name: "value-contains-equals",
+			in:   map[string]string{"PATH": "/a=b", "X": "1"},
+			want: []string{"PATH=/a=b", "X=1"},
+		},
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			t.Parallel()
+
+			got := util.EnvSliceFromMap(tc.in)
+
+			assert.Len(t, got, len(tc.in), "length must match input map")
+			assert.True(t, slices.IsSorted(got), "output must be sorted; got %v", got)
+			assert.ElementsMatch(t, tc.want, got, "multiset of k=v entries must match input")
+		})
+	}
+}

pkg/config/config_helpers_test.go

@@ -30,20 +30,32 @@ import (
 )
 
 // assertErrorType checks that the error chain contains an error of the same type as expectedErr.
+// Used by table-driven tests where the expected type is known only at runtime;
+// for static call sites prefer the type-parameterized requireErrorAs helper.
 func assertErrorType(t *testing.T, expectedErr, actualErr error) bool {
 	t.Helper()
 
-	expectedType := reflect.TypeOf(expectedErr)
-
-	for err := actualErr; err != nil; err = errors.Unwrap(err) {
-		if reflect.TypeOf(err) == expectedType {
-			return true
-		}
+	target := reflect.New(reflect.TypeOf(expectedErr)).Interface()
+	if errors.As(actualErr, target) {
+		return true
 	}
 
 	return assert.Fail(t, "error type mismatch", "expected error of type %T in chain, but got %T", expectedErr, actualErr)
 }
 
+// requireErrorAs unwraps err looking for a value of type T and fails the test when none is found.
+// Type-parameterized wrapper over errors.As; prefer over assertErrorType when the target type is
+// known statically.
+func requireErrorAs[T error](t *testing.T, err error) T {
+	t.Helper()
+
+	var target T
+
+	require.ErrorAs(t, err, &target)
+
+	return target
+}
+
 func TestPathRelativeToInclude(t *testing.T) {
 	t.Parallel()
 
@@ -1424,8 +1436,7 @@ func TestStartsWithArityRegression(t *testing.T) {
 			require.NotPanics(t, func() {
 				_, err := config.StartsWith(ctx, pctx, tc.args)
 				require.Error(t, err, "must return error for wrong arity (%d args)", len(tc.args))
-				require.True(t, assertErrorType(t, config.WrongNumberOfParamsError{}, err),
-					"expected WrongNumberOfParamsError, got %T: %v", err, err)
+				requireErrorAs[config.WrongNumberOfParamsError](t, err)
 			}, "startswith with %d args must not panic", len(tc.args))
 		})
 	}
@@ -1453,8 +1464,7 @@ func TestEndsWithArityRegression(t *testing.T) {
 			require.NotPanics(t, func() {
 				_, err := config.EndsWith(ctx, pctx, tc.args)
 				require.Error(t, err, "must return error for wrong arity (%d args)", len(tc.args))
-				require.True(t, assertErrorType(t, config.WrongNumberOfParamsError{}, err),
-					"expected WrongNumberOfParamsError, got %T: %v", err, err)
+				requireErrorAs[config.WrongNumberOfParamsError](t, err)
 			}, "endswith with %d args must not panic", len(tc.args))
 		})
 	}
@@ -1482,8 +1492,7 @@ func TestStrContainsArityRegression(t *testing.T) {
 			require.NotPanics(t, func() {
 				_, err := config.StrContains(ctx, pctx, tc.args)
 				require.Error(t, err, "must return error for wrong arity (%d args)", len(tc.args))
-				require.True(t, assertErrorType(t, config.WrongNumberOfParamsError{}, err),
-					"expected WrongNumberOfParamsError, got %T: %v", err, err)
+				requireErrorAs[config.WrongNumberOfParamsError](t, err)
 			}, "strcontains with %d args must not panic", len(tc.args))
 		})
 	}
@@ -1515,8 +1524,7 @@ func TestRunCommandOptionsOnlyArityRegression(t *testing.T) {
 			require.NotPanics(t, func() {
 				_, err := config.RunCommand(ctx, pctx, l, tc.params)
 				require.Error(t, err, "must return error when only option flags are supplied (%v)", tc.params)
-				require.True(t, assertErrorType(t, config.EmptyStringNotAllowedError(""), err),
-					"expected EmptyStringNotAllowedError, got %T: %v", err, err)
+				requireErrorAs[config.EmptyStringNotAllowedError](t, err)
 			}, "run_cmd with options-only %v must not panic", tc.params)
 		})
 	}

pkg/config/dependency.go

@@ -41,7 +41,6 @@ import (
 	"github.com/gruntwork-io/terragrunt/internal/shell"
 	"github.com/gruntwork-io/terragrunt/internal/tf"
 	"github.com/gruntwork-io/terragrunt/internal/util"
-	"github.com/gruntwork-io/terragrunt/internal/vexec"
 	"github.com/gruntwork-io/terragrunt/pkg/config/hclparse"
 )
 
@@ -1450,11 +1449,6 @@ func runTerragruntOutputJSON(ctx context.Context, pctx *ParsingContext, l log.Lo
 
 // shellRunOptsFromPctx builds a *shell.ShellOptions from ParsingContext flat fields.
 func shellRunOptsFromPctx(pctx *ParsingContext) *shell.ShellOptions {
-	exec := pctx.Exec
-	if exec == nil {
-		exec = vexec.NewOSExec()
-	}
-
 	return shell.NewShellOptions().
 		WithWorkingDir(pctx.WorkingDir).
 		WithEnv(pctx.Env).
@@ -1466,7 +1460,7 @@ func shellRunOptsFromPctx(pctx *ParsingContext) *shell.ShellOptions {
 		WithExperiments(pctx.Experiments).
 		WithHeadless(pctx.Headless).
 		WithForwardTFStdout(pctx.ForwardTFStdout).
-		WithExec(exec)
+		WithExec(pctx.Exec)
 }
 
 // tfRunOptsFromPctx builds a *tf.RunOptions from ParsingContext flat fields.

pkg/config/fuzz_test.go

@@ -43,14 +43,11 @@ func FuzzHCLStringHelpers(f *testing.F) {
 
 		if len(args) != 2 {
 			require.Error(t, swErr, "startswith with %d args must error", len(args))
-			require.True(t, assertErrorType(t, config.WrongNumberOfParamsError{}, swErr),
-				"startswith expected WrongNumberOfParamsError, got %T: %v", swErr, swErr)
+			requireErrorAs[config.WrongNumberOfParamsError](t, swErr)
 			require.Error(t, ewErr, "endswith with %d args must error", len(args))
-			require.True(t, assertErrorType(t, config.WrongNumberOfParamsError{}, ewErr),
-				"endswith expected WrongNumberOfParamsError, got %T: %v", ewErr, ewErr)
+			requireErrorAs[config.WrongNumberOfParamsError](t, ewErr)
 			require.Error(t, scErr, "strcontains with %d args must error", len(args))
-			require.True(t, assertErrorType(t, config.WrongNumberOfParamsError{}, scErr),
-				"strcontains expected WrongNumberOfParamsError, got %T: %v", scErr, scErr)
+			requireErrorAs[config.WrongNumberOfParamsError](t, scErr)
 
 			return
 		}
@@ -101,6 +98,9 @@ func FuzzHCLRunCommand(f *testing.F) {
 		"--unknown-flag\x00args",
 		"\x00",
 		"\x00\x00",
+		"--terragrunt-quiet\x00\x00/bin/echo\x00hi", // empty arg between flags and command
+		"/bin/echo\x00--terragrunt-quiet",           // trailing flag (not stripped — only leading flags are)
+		" \x00--terragrunt-quiet\x00cmd",            // whitespace as command
 	}
 	for _, s := range seeds {
 		f.Add(s)
@@ -140,15 +140,13 @@ func FuzzHCLRunCommand(f *testing.F) {
 		switch {
 		case conflict:
 			require.Error(t, err, "expected ConflictingRunCmdCacheOptionsError for %q", raw)
-			require.True(t, assertErrorType(t, config.ConflictingRunCmdCacheOptionsError{}, err),
-				"expected ConflictingRunCmdCacheOptionsError, got %T: %v", err, err)
+			requireErrorAs[config.ConflictingRunCmdCacheOptionsError](t, err)
 			require.Empty(t, out)
 			require.Equal(t, int32(0), calls.Load(),
 				"exec must not run on the conflict path (got %d calls)", calls.Load())
 		case len(stripped) == 0:
 			require.Error(t, err, "expected EmptyStringNotAllowedError for %q", raw)
-			require.True(t, assertErrorType(t, config.EmptyStringNotAllowedError(""), err),
-				"expected EmptyStringNotAllowedError, got %T: %v", err, err)
+			requireErrorAs[config.EmptyStringNotAllowedError](t, err)
 			require.Empty(t, out)
 			require.Equal(t, int32(0), calls.Load(),
 				"exec must not run on the empty-args path (got %d calls)", calls.Load())