fix: include append logic in no_null_override transformer (#83)

Signed-off-by: Tim Balzer <[email protected]>

Author: tbalzer

internal/provider/mergo_function.go

@@ -60,6 +60,7 @@ func (r MergoFunction) Run(ctx context.Context, req function.RunRequest, resp *f
 	opts := make([]func(*mergo.Config), 0)
 	with_override := true
 	no_null_override := false
+	with_append := false
 
 	for i, arg := range args {
 		if arg.IsNull() {
@@ -82,6 +83,7 @@ func (r MergoFunction) Run(ctx context.Context, req function.RunRequest, resp *f
 
 			case "append", "append_lists":
 				opts = append(opts, mergo.WithAppendSlice)
+				with_append = true
 
 			default:
 				resp.Error = function.NewArgumentFuncError(int64(i), "unrecognised option")
@@ -105,7 +107,7 @@ func (r MergoFunction) Run(ctx context.Context, req function.RunRequest, resp *f
 	}
 
 	if no_null_override {
-		opts = append(opts, mergo.WithTransformers(noNullOverrideTransformer{}))
+		opts = append(opts, mergo.WithTransformers(noNullOverrideTransformer{ with_append: with_append }))
 	}
 
 	merged, diags := helpers.Mergo(ctx, objs, opts...)
@@ -117,19 +119,21 @@ func (r MergoFunction) Run(ctx context.Context, req function.RunRequest, resp *f
 	resp.Error = function.ConcatFuncErrors(resp.Result.Set(ctx, &merged))
 }
 
-type noNullOverrideTransformer struct{}
+type noNullOverrideTransformer struct{
+	with_append bool
+}
 
 func (t noNullOverrideTransformer) Transformer(typ reflect.Type) func(dst, src reflect.Value) error {
 	if typ.Kind() == reflect.Map {
 		return func(dst, src reflect.Value) error {
-			deepMergeMaps(dst, src)
+			deepMergeMaps(dst, src, t.with_append)
 			return nil
 		}
 	}
 	return nil
 }
 
-func deepMergeMaps(dst, src reflect.Value) reflect.Value {
+func deepMergeMaps(dst, src reflect.Value, appendSlice bool) reflect.Value {
 	for _, key := range src.MapKeys() {
 		srcElem := src.MapIndex(key)
 		dstElem := dst.MapIndex(key)
@@ -145,13 +149,13 @@ func deepMergeMaps(dst, src reflect.Value) reflect.Value {
 
 		if srcElem.Kind() == reflect.Map && dstElem.Kind() == reflect.Map {
 			// recursive call
-			newValue := deepMergeMaps(dstElem, srcElem)
+			newValue := deepMergeMaps(dstElem, srcElem, appendSlice)
 			dst.SetMapIndex(key, newValue)
+		} else if !srcElem.IsValid() { // skip override of nil values
+			continue;
+		} else if srcElem.Kind() == reflect.Slice && dstElem.Kind() == reflect.Slice && appendSlice { // handle append
+			dst.SetMapIndex(key, reflect.AppendSlice(dstElem, srcElem))
 		} else {
-			if !srcElem.IsValid() { // skip override of nil values
-				continue
-			}
-
 			dst.SetMapIndex(key, srcElem)
 		}
 	}

internal/provider/mergo_function_test.go

@@ -216,6 +216,87 @@ func TestMergoFunction_Default(t *testing.T) {
 	})
 }
 
+func TestMergoFunction_Append_NoNullOverride(t *testing.T) {
+	resource.UnitTest(t, resource.TestCase{
+		TerraformVersionChecks: []tfversion.TerraformVersionCheck{
+			tfversion.SkipBelow(version.Must(version.NewVersion("1.8.0"))),
+		},
+		ProtoV6ProviderFactories: testAccProtoV6ProviderFactories,
+		Steps: []resource.TestStep{
+			{
+				Config: `
+				locals {
+					map1 = {
+						x1 = {
+							y1 = "foo"
+							y2 = 1
+						}
+					}
+					map2 = {
+						x1 = {
+							y2 = 2
+							y3 = [1, 2, 3]
+						}
+						x2 = {
+							y4 = {
+								a = "hello"
+								b = "world"
+							}
+						}
+					}
+					map3 = {
+						x1 = {
+							y1 = null
+							y3 = [4, 5, 6]
+						}
+						x2 = {
+							y4 = {
+								b = "mergo"
+								c = ["a", 2, ["b"]]
+							}
+						}
+					}
+				}
+				output "test" {
+					value = provider::deepmerge::mergo(local.map1, local.map2, local.map3, "append", "no_null_override")
+				}
+				`,
+				ConfigStateChecks: []statecheck.StateCheck{
+					statecheck.ExpectKnownOutputValue("test",
+						knownvalue.MapExact(map[string]knownvalue.Check{
+							"x1": knownvalue.MapExact(map[string]knownvalue.Check{
+								"y1": knownvalue.StringExact("foo"),
+								"y2": knownvalue.Int64Exact(2),
+								"y3": knownvalue.ListExact([]knownvalue.Check{
+									knownvalue.Int64Exact(1),
+									knownvalue.Int64Exact(2),
+									knownvalue.Int64Exact(3),
+									knownvalue.Int64Exact(4),
+									knownvalue.Int64Exact(5),
+									knownvalue.Int64Exact(6),
+								}),
+							}),
+							"x2": knownvalue.MapExact(map[string]knownvalue.Check{
+								"y4": knownvalue.MapExact(map[string]knownvalue.Check{
+									"a": knownvalue.StringExact("hello"),
+									"b": knownvalue.StringExact("mergo"),
+									"c": knownvalue.ListExact([]knownvalue.Check{
+										knownvalue.StringExact("a"),
+										knownvalue.Int64Exact(2),
+										knownvalue.ListExact([]knownvalue.Check{
+											knownvalue.StringExact("b"),
+										}),
+									}),
+								}),
+							}),
+						}),
+					),
+				},
+			},
+		},
+	})
+}
+
 func TestMergoFunction_Append(t *testing.T) {
 	resource.UnitTest(t, resource.TestCase{
 		TerraformVersionChecks: []tfversion.TerraformVersionCheck{