Merge pull request #1622 from gruntwork-io/feat/add-missing-terragrunt-commands

Add missing terragrunt commands: ValidateAll, RunAll, FormatAll, OutputListAll

Author: james00012

modules/terragrunt/README.md

@@ -85,10 +85,13 @@ options := &terragrunt.Options{
 ### Non-Stack Commands
 Work with standard terragrunt configurations (dependencies via `dependency` blocks):
 
+- `Init(t, options)` - Initialize configuration
 - `ApplyAll(t, options)` - Apply all modules with dependencies
 - `DestroyAll(t, options)` - Destroy all modules with dependencies
 - `PlanAllExitCode(t, options)` - Plan all and return exit code (0=no changes, 2=changes)
-- `Init(t, options)` - Initialize configuration
+- `ValidateAll(t, options)` - Validate all modules
+- `RunAll(t, options, command)` - Run any terraform command with --all flag
+- `FormatAll(t, options)` - Format all terragrunt.hcl files
 
 ### Stack Commands
 Work with `terragrunt.stack.hcl` configurations:
@@ -99,6 +102,7 @@ Work with `terragrunt.stack.hcl` configurations:
 - `Output(t, options, key)` - Get stack output value
 - `OutputJson(t, options, key)` - Get stack output as JSON
 - `OutputAll(t, options)` - Get all stack outputs as map
+- `OutputListAll(t, options)` - Get list of all output variable names
 
 ## Examples
 
@@ -180,6 +184,47 @@ func TestInfrastructureUpToDate(t *testing.T) {
 }
 ```
 
+### Using RunAll for Flexibility
+
+```go
+func TestCustomCommand(t *testing.T) {
+    t.Parallel()
+
+    options := &terragrunt.Options{
+        TerragruntDir: "../modules",
+    }
+
+    // Run any terraform command with --all
+    terragrunt.RunAll(t, options, "refresh")
+
+    // Verify state is current
+    output := terragrunt.RunAll(t, options, "show")
+    assert.Contains(t, output, "expected-resource")
+}
+```
+
+### Validating Output Keys
+
+```go
+func TestOutputKeys(t *testing.T) {
+    t.Parallel()
+
+    options := &terragrunt.Options{
+        TerragruntDir: "../stack",
+    }
+
+    terragrunt.ApplyAll(t, options)
+    defer terragrunt.DestroyAll(t, options)
+
+    // Get list of all output keys
+    keys := terragrunt.OutputListAll(t, options)
+
+    // Verify required outputs exist
+    assert.Contains(t, keys, "vpc_id")
+    assert.Contains(t, keys, "subnet_ids")
+}
+```
+
 ## Not Supported
 
 This module does **NOT** support:

modules/terragrunt/apply_test.go

@@ -7,7 +7,21 @@ import (
 	"github.com/stretchr/testify/require"
 )
 
-func TestApplyAllNoError(t *testing.T) {
+func TestApplyAll(t *testing.T) {
+	t.Parallel()
+
+	testFolder, err := files.CopyTerragruntFolderToTemp("../../test/fixtures/terragrunt/terragrunt-no-error", t.Name())
+	require.NoError(t, err)
+
+	out := ApplyAll(t, &Options{
+		TerragruntDir:    testFolder,
+		TerragruntBinary: "terragrunt",
+	})
+
+	require.Contains(t, out, "Hello, World")
+}
+
+func TestApplyAllE(t *testing.T) {
 	t.Parallel()
 
 	testFolder, err := files.CopyTerragruntFolderToTemp("../../test/fixtures/terragrunt/terragrunt-no-error", t.Name())
@@ -18,7 +32,7 @@ func TestApplyAllNoError(t *testing.T) {
 		TerragruntBinary: "terragrunt",
 	}
 
-	out := ApplyAll(t, options)
-
+	out, err := ApplyAllE(t, options)
+	require.NoError(t, err)
 	require.Contains(t, out, "Hello, World")
 }

modules/terragrunt/destroy_test.go

@@ -7,7 +7,7 @@ import (
 	"github.com/stretchr/testify/require"
 )
 
-func TestDestroyAllNoError(t *testing.T) {
+func TestDestroyAll(t *testing.T) {
 	t.Parallel()
 
 	testFolder, err := files.CopyTerragruntFolderToTemp("../../test/fixtures/terragrunt/terragrunt-no-error", t.Name())
@@ -18,11 +18,29 @@ func TestDestroyAllNoError(t *testing.T) {
 		TerragruntBinary: "terragrunt",
 	}
 
-	out := ApplyAll(t, options)
+	ApplyAll(t, options)
+	destroyOut := DestroyAll(t, options)
+	require.NotEmpty(t, destroyOut)
+}
+
+func TestDestroyAllE(t *testing.T) {
+	t.Parallel()
+
+	testFolder, err := files.CopyTerragruntFolderToTemp("../../test/fixtures/terragrunt/terragrunt-no-error", t.Name())
+	require.NoError(t, err)
+
+	options := &Options{
+		TerragruntDir:    testFolder,
+		TerragruntBinary: "terragrunt",
+	}
+
+	out, err := ApplyAllE(t, options)
+	require.NoError(t, err)
 	require.Contains(t, out, "Hello, World")
 
 	// Test that destroy completes successfully
-	destroyOut := DestroyAll(t, options)
+	destroyOut, err := DestroyAllE(t, options)
+	require.NoError(t, err)
 	require.NotEmpty(t, destroyOut, "Destroy output should not be empty")
 }
 

modules/terragrunt/format.go

@@ -0,0 +1,18 @@
+package terragrunt
+
+import (
+	"github.com/gruntwork-io/terratest/modules/testing"
+	"github.com/stretchr/testify/require"
+)
+
+// FormatAll runs terragrunt hclfmt to format all terragrunt.hcl files and returns stdout/stderr
+func FormatAll(t testing.TestingT, options *Options) string {
+	out, err := FormatAllE(t, options)
+	require.NoError(t, err)
+	return out
+}
+
+// FormatAllE runs terragrunt hclfmt to format all terragrunt.hcl files and returns stdout/stderr
+func FormatAllE(t testing.TestingT, options *Options) (string, error) {
+	return runTerragruntCommandE(t, options, "hclfmt")
+}

modules/terragrunt/format_test.go

@@ -0,0 +1,52 @@
+package terragrunt
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+
+	"github.com/gruntwork-io/terratest/modules/files"
+	"github.com/stretchr/testify/require"
+)
+
+func TestFormatAll(t *testing.T) {
+	t.Parallel()
+
+	testFolder, err := files.CopyTerragruntFolderToTemp("../../test/fixtures/terragrunt/terragrunt-multi-plan", t.Name())
+	require.NoError(t, err)
+
+	// Create an unformatted terragrunt.hcl file in foo directory
+	unformattedContent := `terraform {
+source = "git::git@github.com:foo/modules.git//app"
+}
+inputs={
+foo="bar"
+}`
+	tgFile := filepath.Join(testFolder, "foo", "terragrunt.hcl")
+	err = os.WriteFile(tgFile, []byte(unformattedContent), 0644)
+	require.NoError(t, err)
+
+	options := &Options{
+		TerragruntDir:    testFolder,
+		TerragruntBinary: "terragrunt",
+	}
+
+	out := FormatAll(t, options)
+	require.NotEmpty(t, out)
+}
+
+func TestFormatAllE(t *testing.T) {
+	t.Parallel()
+
+	testFolder, err := files.CopyTerragruntFolderToTemp("../../test/fixtures/terragrunt/terragrunt-multi-plan", t.Name())
+	require.NoError(t, err)
+
+	options := &Options{
+		TerragruntDir:    testFolder,
+		TerragruntBinary: "terragrunt",
+	}
+
+	out, err := FormatAllE(t, options)
+	require.NoError(t, err)
+	require.NotEmpty(t, out)
+}

modules/terragrunt/init_test.go

@@ -15,6 +15,21 @@ func TestInit(t *testing.T) {
 		"../../test/fixtures/terragrunt/terragrunt-no-error", t.Name())
 	require.NoError(t, err)
 
+	out := Init(t, &Options{
+		TerragruntDir:    testFolder,
+		TerragruntBinary: "terragrunt",
+		TerraformArgs:    []string{"-upgrade=true"},
+	})
+	require.Contains(t, out, "Terraform has been successfully initialized!")
+}
+
+func TestInitE(t *testing.T) {
+	t.Parallel()
+
+	testFolder, err := files.CopyTerraformFolderToTemp(
+		"../../test/fixtures/terragrunt/terragrunt-no-error", t.Name())
+	require.NoError(t, err)
+
 	out, err := InitE(t, &Options{
 		TerragruntDir:    testFolder,
 		TerragruntBinary: "terragrunt",

modules/terragrunt/plan_test.go

@@ -8,7 +8,23 @@ import (
 	"github.com/stretchr/testify/require"
 )
 
-func TestTgPlanAllNoError(t *testing.T) {
+func TestPlanAllExitCode(t *testing.T) {
+	t.Parallel()
+
+	testFolder, err := files.CopyTerragruntFolderToTemp("../../test/fixtures/terragrunt/terragrunt-multi-plan", t.Name())
+	require.NoError(t, err)
+
+	options := &Options{
+		TerragruntDir:    testFolder,
+		TerragruntBinary: "terragrunt",
+	}
+
+	ApplyAll(t, options)
+	exitCode := PlanAllExitCode(t, options)
+	require.Equal(t, 0, exitCode)
+}
+
+func TestPlanAllExitCodeE(t *testing.T) {
 	t.Parallel()
 
 	testFolder, err := files.CopyTerragruntFolderToTemp("../../test/fixtures/terragrunt/terragrunt-multi-plan", t.Name())
@@ -34,7 +50,7 @@ func TestTgPlanAllNoError(t *testing.T) {
 	require.Equal(t, 0, getExitCode)
 }
 
-func TestTgPlanAllWithError(t *testing.T) {
+func TestPlanAllWithError(t *testing.T) {
 	t.Parallel()
 
 	testFolder, err := files.CopyTerragruntFolderToTemp("../../test/fixtures/terragrunt/terragrunt-with-plan-error", t.Name())

modules/terragrunt/run_all.go

@@ -0,0 +1,20 @@
+package terragrunt
+
+import (
+	"github.com/gruntwork-io/terratest/modules/testing"
+	"github.com/stretchr/testify/require"
+)
+
+// RunAll runs terragrunt run-all <command> with the given options and returns stdout/stderr.
+// This is a generic wrapper that allows running any terraform command with --all flag.
+func RunAll(t testing.TestingT, options *Options, command string) string {
+	out, err := RunAllE(t, options, command)
+	require.NoError(t, err)
+	return out
+}
+
+// RunAllE runs terragrunt run-all <command> with the given options and returns stdout/stderr.
+// This is a generic wrapper that allows running any terraform command with --all flag.
+func RunAllE(t testing.TestingT, options *Options, command string) (string, error) {
+	return runTerragruntCommandE(t, options, command, "--all")
+}

modules/terragrunt/run_all_test.go

@@ -0,0 +1,58 @@
+package terragrunt
+
+import (
+	"testing"
+
+	"github.com/gruntwork-io/terratest/modules/files"
+	"github.com/stretchr/testify/require"
+)
+
+func TestRunAll(t *testing.T) {
+	t.Parallel()
+
+	testFolder, err := files.CopyTerragruntFolderToTemp("../../test/fixtures/terragrunt/terragrunt-multi-plan", t.Name())
+	require.NoError(t, err)
+
+	options := &Options{
+		TerragruntDir:    testFolder,
+		TerragruntBinary: "terragrunt",
+	}
+
+	// Test with validate command
+	out := RunAll(t, options, "validate")
+	require.NotEmpty(t, out)
+}
+
+func TestRunAllE(t *testing.T) {
+	t.Parallel()
+
+	testFolder, err := files.CopyTerragruntFolderToTemp("../../test/fixtures/terragrunt/terragrunt-multi-plan", t.Name())
+	require.NoError(t, err)
+
+	options := &Options{
+		TerragruntDir:    testFolder,
+		TerragruntBinary: "terragrunt",
+	}
+
+	// Test with validate command
+	out, err := RunAllE(t, options, "validate")
+	require.NoError(t, err)
+	require.NotEmpty(t, out)
+}
+
+func TestRunAllWithPlan(t *testing.T) {
+	t.Parallel()
+
+	testFolder, err := files.CopyTerragruntFolderToTemp("../../test/fixtures/terragrunt/terragrunt-multi-plan", t.Name())
+	require.NoError(t, err)
+
+	options := &Options{
+		TerragruntDir:    testFolder,
+		TerragruntBinary: "terragrunt",
+	}
+
+	// Test with plan command - verify output contains expected terraform plan text
+	out, err := RunAllE(t, options, "plan")
+	require.NoError(t, err)
+	require.Contains(t, out, "Changes to Outputs")
+}

modules/terragrunt/stack_clean_test.go

@@ -17,6 +17,31 @@ func TestStackClean(t *testing.T) {
 
 	stackDir := path.Join(testFolder, "live", ".terragrunt-stack")
 
+	StackGenerate(t, &Options{
+		TerragruntDir:    path.Join(testFolder, "live"),
+		TerragruntBinary: "terragrunt",
+	})
+
+	require.DirExists(t, stackDir)
+
+	out := StackClean(t, &Options{
+		TerragruntDir:    path.Join(testFolder, "live"),
+		TerragruntBinary: "terragrunt",
+	})
+
+	require.Contains(t, out, "Deleting stack directory")
+	require.NoDirExists(t, stackDir)
+}
+
+func TestStackCleanE(t *testing.T) {
+	t.Parallel()
+
+	testFolder, err := files.CopyTerraformFolderToTemp(
+		"../../test/fixtures/terragrunt/terragrunt-stack-init", t.Name())
+	require.NoError(t, err)
+
+	stackDir := path.Join(testFolder, "live", ".terragrunt-stack")
+
 	// First generate the stack to create .terragrunt-stack directory
 	_, err = StackGenerateE(t, &Options{
 		TerragruntDir:    path.Join(testFolder, "live"),