Fix Terraform recipe parameter serialization issues

- Handle empty maps/arrays passed as strings in recipe parameters
- Add recursive normalization for nested structures with string-encoded empty objects
- Support whitespace variations (e.g., '{ }', '{}\n', '[ ]')
- Remove TF_LOG environment variable to prevent terraform-exec conflicts
- Add comprehensive test coverage for parameter normalization

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

Author: ytimocin

.gitignore

@@ -69,3 +69,7 @@ hack/bicep-types-radius/generated/**/*.md
 
 # Bicep extensions
 *.tgz
+
+# Demo
+demo/gitlab/
+demo/recipes/

pkg/recipes/terraform/config/config_test.go

@@ -175,6 +175,25 @@ func Test_NewConfig(t *testing.T) {
 			},
 			expectedConfigFile: "testdata/module-emptytemplateversion.tf.json",
 		},
+		{
+			desc:       "empty map as string parameter",
+			moduleName: testRecipeName,
+			envdef: &recipes.EnvironmentDefinition{
+				Name:            testRecipeName,
+				TemplatePath:    testTemplatePath,
+				TemplateVersion: testTemplateVersion,
+				Parameters:      envParams,
+			},
+			metadata: &recipes.ResourceMetadata{
+				Name: testRecipeName,
+				Parameters: map[string]any{
+					"redis_cache_name": "redis-test",
+					"sku":              "P",
+					"tags":             "{}", // This should be converted to an empty map
+				},
+			},
+			expectedConfigFile: "testdata/module-emptymap.tf.json",
+		},
 	}
 
 	for _, tc := range configTests {

pkg/recipes/terraform/config/testdata/module-emptymap.tf.json

@@ -0,0 +1,13 @@
+{
+  "terraform": null,
+  "module": {
+    "redis-azure": {
+      "redis_cache_name": "redis-test",
+      "resource_group_name": "test-rg",
+      "sku": "P",
+      "source": "Azure/redis/azurerm",
+      "tags": {},
+      "version": "1.1.0"
+    }
+  }
+}

pkg/recipes/terraform/config/types.go

@@ -16,6 +16,8 @@ limitations under the License.
 
 package config
 
+import "strings"
+
 const (
 	// moduleSourceKey represents the key for the module source parameter.
 	moduleSourceKey = "source"
@@ -34,7 +36,50 @@ type RecipeParams map[string]any
 // SetParams sets the recipe parameters in the Terraform module configuration.
 func (tf TFModuleConfig) SetParams(params RecipeParams) {
 	for k, v := range params {
-		tf[k] = v
+		tf[k] = normalizeValue(v)
+	}
+}
+
+// normalizeValue recursively normalizes parameter values, converting string representations
+// of empty objects/arrays to their proper types
+func normalizeValue(v any) any {
+	switch val := v.(type) {
+	case string:
+		// Trim outer whitespace for comparison
+		trimmed := strings.TrimSpace(val)
+		
+		// Handle empty object representations (including with spaces inside)
+		if trimmed == "{}" || trimmed == "{ }" {
+			return map[string]any{}
+		}
+		
+		// Handle empty array representations (including with spaces inside)
+		if trimmed == "[]" || trimmed == "[ ]" {
+			return []any{}
+		}
+		
+		// Return the original string if no conversion needed
+		return v
+		
+	case map[string]any:
+		// Recursively normalize nested maps
+		result := make(map[string]any)
+		for k, v := range val {
+			result[k] = normalizeValue(v)
+		}
+		return result
+		
+	case []any:
+		// Recursively normalize arrays
+		result := make([]any, len(val))
+		for i, item := range val {
+			result[i] = normalizeValue(item)
+		}
+		return result
+		
+	default:
+		// Return unchanged for other types
+		return v
 	}
 }
 

pkg/recipes/terraform/config/types_test.go

@@ -38,3 +38,114 @@ func TestSetParams(t *testing.T) {
 	require.Equal(t, c["foo"].(map[string]any), map[string]any{"bar": "baz"})
 	require.Equal(t, c["bar"].(map[string]any), map[string]any{"baz": "foo"})
 }
+
+func TestSetParams_EmptyMapString(t *testing.T) {
+	c := TFModuleConfig{}
+
+	c.SetParams(RecipeParams{
+		"tags":        "{}", // This should be converted to an empty map
+		"normalParam": "value",
+		"existingMap": map[string]any{
+			"key": "value",
+		},
+		"emptyMap": map[string]any{}, // This should remain as is
+	})
+
+	require.Equal(t, 4, len(c))
+
+	// Verify that the string "{}" was converted to an empty map
+	tags, ok := c["tags"].(map[string]any)
+	require.True(t, ok, "tags should be a map[string]any")
+	require.Equal(t, map[string]any{}, tags)
+
+	// Verify other parameters remain unchanged
+	require.Equal(t, "value", c["normalParam"])
+	require.Equal(t, map[string]any{"key": "value"}, c["existingMap"])
+	require.Equal(t, map[string]any{}, c["emptyMap"])
+}
+
+func TestSetParams_WhitespaceHandling(t *testing.T) {
+	c := TFModuleConfig{}
+
+	c.SetParams(RecipeParams{
+		"tags1": "{ }",     // With space inside
+		"tags2": "{}\n",    // With newline
+		"tags3": " {} ",    // With surrounding spaces
+		"array1": "[]",     // Empty array
+		"array2": "[ ]",    // Array with space inside
+		"array3": "[]\n",   // Array with newline
+	})
+
+	// Verify empty maps (all variations should be converted)
+	for _, key := range []string{"tags1", "tags2", "tags3"} {
+		val, ok := c[key].(map[string]any)
+		require.True(t, ok, "%s should be a map[string]any", key)
+		require.Equal(t, map[string]any{}, val, "%s should be an empty map", key)
+	}
+
+	// Verify empty arrays (all variations should be converted)
+	for _, key := range []string{"array1", "array2", "array3"} {
+		val, ok := c[key].([]any)
+		require.True(t, ok, "%s should be a []any", key)
+		require.Equal(t, []any{}, val, "%s should be an empty array", key)
+	}
+}
+
+func TestSetParams_NestedStructures(t *testing.T) {
+	c := TFModuleConfig{}
+
+	c.SetParams(RecipeParams{
+		"config": map[string]any{
+			"tags":     "{}",
+			"metadata": "{}",
+			"items":    "[]",
+			"nested": map[string]any{
+				"deep": map[string]any{
+					"tags": "{}",
+				},
+			},
+		},
+		"list": []any{
+			"{}",
+			"[]",
+			map[string]any{
+				"tags": "{}",
+			},
+		},
+	})
+
+	// Verify nested map normalization
+	config := c["config"].(map[string]any)
+	require.Equal(t, map[string]any{}, config["tags"])
+	require.Equal(t, map[string]any{}, config["metadata"])
+	require.Equal(t, []any{}, config["items"])
+	
+	// Verify deep nested normalization
+	nested := config["nested"].(map[string]any)
+	deep := nested["deep"].(map[string]any)
+	require.Equal(t, map[string]any{}, deep["tags"])
+
+	// Verify array normalization
+	list := c["list"].([]any)
+	require.Equal(t, map[string]any{}, list[0])
+	require.Equal(t, []any{}, list[1])
+	nestedInList := list[2].(map[string]any)
+	require.Equal(t, map[string]any{}, nestedInList["tags"])
+}
+
+func TestSetParams_PreservesNonEmptyStrings(t *testing.T) {
+	c := TFModuleConfig{}
+
+	c.SetParams(RecipeParams{
+		"notEmpty1": "{\"key\": \"value\"}",
+		"notEmpty2": "[1, 2, 3]",
+		"notEmpty3": "{ key: value }",
+		"normalStr": "just a string",
+	})
+
+	// All these should remain as strings since they're not empty
+	require.Equal(t, "{\"key\": \"value\"}", c["notEmpty1"])
+	require.Equal(t, "[1, 2, 3]", c["notEmpty2"])
+	require.Equal(t, "{ key: value }", c["notEmpty3"])
+	require.Equal(t, "just a string", c["normalStr"])
+}

pkg/recipes/terraform/execute.go

@@ -255,6 +255,10 @@ func (e *executor) setEnvironmentVariables(ctx context.Context, tf *tfexec.Terra
 
 	// Populate envVars with the environment variables from current process
 	envVars := splitEnvVar(os.Environ())
+
+	// Remove TF_LOG to prevent conflict with terraform-exec's logging configuration
+	delete(envVars, "TF_LOG")
+
 	var envVarUpdate bool
 
 	// Handle recipe config if present