Merge pull request #1620 from gruntwork-io/feature/modularize-terragrunt

Refactor: Extract formatting utilities to internal/lib

Author: james00012

internal/lib/formatting/format.go

@@ -0,0 +1,141 @@
+// Package formatting provides internal utilities for formatting Terraform/Terragrunt CLI arguments.
+package formatting
+
+import (
+	"fmt"
+	"reflect"
+	"strconv"
+	"strings"
+)
+
+// FormatBackendConfigAsArgs formats backend configuration as Terraform CLI args.
+// Example: {"bucket": "my-bucket"} -> ["-backend-config=bucket=my-bucket"]
+func FormatBackendConfigAsArgs(vars map[string]interface{}) []string {
+	return formatTerraformArgs(vars, "-backend-config", false, true)
+}
+
+// FormatPluginDirAsArgs formats plugin directory as a Terraform CLI arg.
+// Returns nil if pluginDir is empty.
+func FormatPluginDirAsArgs(pluginDir string) []string {
+	if pluginDir == "" {
+		return nil
+	}
+	return []string{fmt.Sprintf("-plugin-dir=%v", pluginDir)}
+}
+
+// formatTerraformArgs formats vars as CLI args with the given prefix.
+func formatTerraformArgs(vars map[string]interface{}, prefix string, useSpaceAsSeparator bool, omitNil bool) []string {
+	var args []string
+
+	for key, value := range vars {
+		var argValue string
+		if omitNil && value == nil {
+			argValue = key
+		} else {
+			hclString := toHclString(value, false)
+			argValue = fmt.Sprintf("%s=%s", key, hclString)
+		}
+		if useSpaceAsSeparator {
+			args = append(args, prefix, argValue)
+		} else {
+			args = append(args, fmt.Sprintf("%s=%s", prefix, argValue))
+		}
+	}
+
+	return args
+}
+
+// toHclString converts Go values to HCL-formatted strings for Terraform CLI arguments.
+// Handles primitives, slices, and maps. Example: []int{1,2,3} -> "[1, 2, 3]"
+func toHclString(value interface{}, isNested bool) string {
+	if slice, isSlice := tryToConvertToGenericSlice(value); isSlice {
+		return sliceToHclString(slice)
+	} else if m, isMap := tryToConvertToGenericMap(value); isMap {
+		return mapToHclString(m)
+	} else {
+		return primitiveToHclString(value, isNested)
+	}
+}
+
+// tryToConvertToGenericSlice converts any slice type to []interface{} using reflection.
+func tryToConvertToGenericSlice(value interface{}) ([]interface{}, bool) {
+	reflectValue := reflect.ValueOf(value)
+	if reflectValue.Kind() != reflect.Slice {
+		return []interface{}{}, false
+	}
+
+	genericSlice := make([]interface{}, reflectValue.Len())
+
+	for i := 0; i < reflectValue.Len(); i++ {
+		genericSlice[i] = reflectValue.Index(i).Interface()
+	}
+
+	return genericSlice, true
+}
+
+// tryToConvertToGenericMap converts any map[string]T to map[string]interface{} using reflection.
+func tryToConvertToGenericMap(value interface{}) (map[string]interface{}, bool) {
+	reflectValue := reflect.ValueOf(value)
+	if reflectValue.Kind() != reflect.Map {
+		return map[string]interface{}{}, false
+	}
+
+	reflectType := reflect.TypeOf(value)
+	if reflectType.Key().Kind() != reflect.String {
+		return map[string]interface{}{}, false
+	}
+
+	genericMap := make(map[string]interface{}, reflectValue.Len())
+
+	mapKeys := reflectValue.MapKeys()
+	for _, key := range mapKeys {
+		genericMap[key.String()] = reflectValue.MapIndex(key).Interface()
+	}
+
+	return genericMap, true
+}
+
+func sliceToHclString(slice []interface{}) string {
+	hclValues := []string{}
+
+	for _, value := range slice {
+		hclValue := toHclString(value, true)
+		hclValues = append(hclValues, hclValue)
+	}
+
+	return fmt.Sprintf("[%s]", strings.Join(hclValues, ", "))
+}
+
+func mapToHclString(m map[string]interface{}) string {
+	keyValuePairs := []string{}
+
+	for key, value := range m {
+		keyValuePair := fmt.Sprintf(`"%s" = %s`, key, toHclString(value, true))
+		keyValuePairs = append(keyValuePairs, keyValuePair)
+	}
+
+	return fmt.Sprintf("{%s}", strings.Join(keyValuePairs, ", "))
+}
+
+func primitiveToHclString(value interface{}, isNested bool) string {
+	if value == nil {
+		return "null"
+	}
+
+	switch v := value.(type) {
+
+	case bool:
+		return strconv.FormatBool(v)
+
+	case string:
+		// If string is nested in a larger data structure (e.g. list of string, map of string), ensure value is quoted
+		if isNested {
+			return fmt.Sprintf("\"%v\"", v)
+		}
+
+		return fmt.Sprintf("%v", v)
+
+	default:
+		return fmt.Sprintf("%v", v)
+	}
+}

internal/lib/formatting/format_test.go

@@ -0,0 +1,112 @@
+package formatting
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestFormatBackendConfigAsArgs(t *testing.T) {
+	t.Parallel()
+
+	tests := []struct {
+		name   string
+		input  map[string]interface{}
+		expect []string
+	}{
+		{
+			name:   "empty config",
+			input:  map[string]interface{}{},
+			expect: []string{},
+		},
+		{
+			name:   "string value",
+			input:  map[string]interface{}{"bucket": "my-bucket"},
+			expect: []string{"-backend-config=bucket=my-bucket"},
+		},
+		{
+			name:   "nil value omitted",
+			input:  map[string]interface{}{"key": nil},
+			expect: []string{"-backend-config=key"},
+		},
+		{
+			name:   "multiple values",
+			input:  map[string]interface{}{"region": "us-east-1", "bucket": "state"},
+			expect: []string{"-backend-config=bucket=state", "-backend-config=region=us-east-1"},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			result := FormatBackendConfigAsArgs(tt.input)
+			assert.ElementsMatch(t, tt.expect, result)
+		})
+	}
+}
+
+func TestFormatPluginDirAsArgs(t *testing.T) {
+	t.Parallel()
+
+	tests := []struct {
+		name   string
+		input  string
+		expect []string
+	}{
+		{
+			name:   "empty path",
+			input:  "",
+			expect: nil,
+		},
+		{
+			name:   "valid path",
+			input:  "/path/to/plugins",
+			expect: []string{"-plugin-dir=/path/to/plugins"},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			result := FormatPluginDirAsArgs(tt.input)
+			assert.Equal(t, tt.expect, result)
+		})
+	}
+}
+
+func TestToHclString(t *testing.T) {
+	t.Parallel()
+
+	tests := []struct {
+		name   string
+		input  interface{}
+		expect string
+	}{
+		{"nil", nil, "null"},
+		{"bool true", true, "true"},
+		{"bool false", false, "false"},
+		{"string", "hello", "hello"},
+		{"int", 42, "42"},
+		{"list of strings", []string{"a", "b"}, `["a", "b"]`},
+		{"list of ints", []int{1, 2, 3}, "[1, 2, 3]"},
+		{"map", map[string]string{"key": "value"}, `{"key" = "value"}`},
+		{"nested list", []interface{}{[]int{1, 2}}, "[[1, 2]]"},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			result := toHclString(tt.input, false)
+			assert.Equal(t, tt.expect, result)
+		})
+	}
+}
+
+func TestToHclStringNested(t *testing.T) {
+	t.Parallel()
+
+	// Nested strings should be quoted
+	result := toHclString("nested", true)
+	assert.Equal(t, `"nested"`, result)
+
+	// Non-nested strings should not be quoted
+	result = toHclString("not-nested", false)
+	assert.Equal(t, "not-nested", result)
+}

modules/terraform/format.go

@@ -6,6 +6,7 @@ import (
 	"strconv"
 	"strings"
 
+	"github.com/gruntwork-io/terratest/internal/lib/formatting"
 	"github.com/gruntwork-io/terratest/modules/collections"
 )
 
@@ -121,11 +122,7 @@ func FormatTerraformLockAsArgs(lockCheck bool, lockTimeout string) []string {
 // FormatTerraformPluginDirAsArgs formats the plugin-dir variable
 // -plugin-dir
 func FormatTerraformPluginDirAsArgs(pluginDir string) []string {
-	pluginArgs := []string{fmt.Sprintf("-plugin-dir=%v", pluginDir)}
-	if pluginDir == "" {
-		return nil
-	}
-	return pluginArgs
+	return formatting.FormatPluginDirAsArgs(pluginDir)
 }
 
 // FormatTerraformArgs will format multiple args with the arg name (e.g. "-var-file", []string{"foo.tfvars", "bar.tfvars", "baz.tfvars.json"})
@@ -141,7 +138,7 @@ func FormatTerraformArgs(argName string, args []string) []string {
 // FormatTerraformBackendConfigAsArgs formats the given variables as backend config args for Terraform (e.g. of the
 // format -backend-config=key=value).
 func FormatTerraformBackendConfigAsArgs(vars map[string]interface{}) []string {
-	return formatTerraformArgs(vars, "-backend-config", false, true)
+	return formatting.FormatBackendConfigAsArgs(vars)
 }
 
 // Format the given vars into 'Terraform' format, with each var being prefixed with the given prefix. If