Add field unsetting tests

Author: jpbetz

merge/multiple_appliers_test.go

@@ -27,6 +27,7 @@ import (
 	. "sigs.k8s.io/structured-merge-diff/v3/internal/fixture"
 	"sigs.k8s.io/structured-merge-diff/v3/merge"
 	"sigs.k8s.io/structured-merge-diff/v3/typed"
+	"sigs.k8s.io/structured-merge-diff/v3/value"
 )
 
 func TestMultipleAppliersSet(t *testing.T) {
@@ -243,6 +244,275 @@ func TestMultipleAppliersSet(t *testing.T) {
 	}
 }
 
+var structParser = func() Parser {
+	parser, err := typed.NewParser(`types:
+- name: v1
+  map:
+    fields:
+      - name: struct
+        type:
+          namedType: struct
+      - name: version
+        type:
+          scalar: string
+- name: struct
+  map:
+    fields:
+      - name: name
+        type:
+          scalar: string
+      - name: scalarField_v1
+        type:
+          scalar: string
+      - name: complexField_v1
+        type:
+          namedType: complex
+- name: complex
+  map:
+    fields:
+      - name: name
+        type:
+          scalar: string
+- name: v2
+  map:
+    fields:
+      - name: struct
+        type:
+          namedType: struct_v2
+      - name: version
+        type:
+          scalar: string
+- name: struct_v2
+  map:
+    fields:
+      - name: name
+        type:
+          scalar: string
+      - name: scalarField_v2
+        type:
+          scalar: string
+      - name: complexField_v2
+        type:
+          namedType: complex_v2
+- name: complex_v2
+  map:
+    fields:
+      - name: name
+        type:
+          scalar: string
+`)
+	if err != nil {
+		panic(err)
+	}
+	return parser
+}()
+
+type versionPair struct {
+	a fieldpath.APIVersion
+	b fieldpath.APIVersion
+}
+
+func TestMultipleAppliersFieldUnsetting(t *testing.T) {
+	for _, a := range []fieldpath.APIVersion{"v1", "v2"} {
+		for _, b := range []fieldpath.APIVersion{"v1", "v2"} {
+			t.Run(fmt.Sprintf("%s-%s", a, b), func(t *testing.T) {
+				testMultipleAppliersFieldUnsetting(t, versionPair{a, b})
+			})
+		}
+	}
+}
+
+func testMultipleAppliersFieldUnsetting(t *testing.T, versions versionPair) {
+	tests := map[string]TestCase{
+		"unset_scalar_sole_owner": {
+			Ops: []Operation{
+				Apply{
+					Manager:    "apply-one",
+					APIVersion: versions.a,
+					Object: typed.YAMLObject(fmt.Sprintf(`
+						struct:
+						  name: a
+						  scalarField_%s: a
+					`, versions.a)),
+				},
+				Apply{
+					Manager:    "apply-one",
+					APIVersion: versions.b,
+					Object: `
+						struct:
+						  name: a
+					`,
+				},
+			},
+			Object: `
+				struct:
+				  name: a
+			`,
+			APIVersion: versions.a,
+			Managed: fieldpath.ManagedFields{
+				"apply-one": fieldpath.NewVersionedSet(
+					_NS(
+						_P("struct", "name"),
+					),
+					versions.b,
+					false,
+				),
+			},
+		},
+		"unset_scalar_shared_owner": {
+			Ops: []Operation{
+				Apply{
+					Manager:    "apply-one",
+					APIVersion: versions.a,
+					Object: typed.YAMLObject(fmt.Sprintf(`
+						struct:
+						  name: a
+						  scalarField_%s: a
+					`, versions.a)),
+				},
+				Apply{
+					Manager:    "apply-two",
+					APIVersion: versions.b,
+					Object: typed.YAMLObject(fmt.Sprintf(`
+						struct:
+						  scalarField_%s: a
+					`, versions.b)),
+				},
+				Apply{
+					Manager:    "apply-one",
+					APIVersion: versions.a,
+					Object: `
+						struct:
+						  name: a
+					`,
+				},
+			},
+			Object: typed.YAMLObject(fmt.Sprintf(`
+				struct:
+				  name: a
+				  scalarField_%s: a
+			`, versions.a)),
+			APIVersion: versions.a,
+			Managed: fieldpath.ManagedFields{
+				"apply-one": fieldpath.NewVersionedSet(
+					_NS(
+						_P("struct", "name"),
+					),
+					versions.a,
+					true,
+				),
+				"apply-two": fieldpath.NewVersionedSet(
+					_NS(
+						_P("struct", fmt.Sprintf("scalarField_%s", versions.b)),
+					),
+					versions.b,
+					false,
+				),
+			},
+		},
+		"unset_complex_sole_owner": {
+			Ops: []Operation{
+				Apply{
+					Manager:    "apply-one",
+					APIVersion: versions.a,
+					Object: typed.YAMLObject(fmt.Sprintf(`
+						struct:
+						  name: a
+						  complexField_%s:
+						    name: b
+					`, versions.a)),
+				},
+				Apply{
+					Manager:    "apply-one",
+					APIVersion: versions.b,
+					Object: `
+						struct:
+						  name: a
+					`,
+				},
+			},
+			Object: typed.YAMLObject(fmt.Sprintf(`
+				struct:
+				  name: a
+				  complexField_%s: null
+			`, versions.a)),
+			APIVersion: versions.a,
+			Managed: fieldpath.ManagedFields{
+				"apply-one": fieldpath.NewVersionedSet(
+					_NS(
+						_P("struct", "name"),
+					),
+					versions.b,
+					false,
+				),
+			},
+		},
+		"unset_complex_shared_owner": {
+			Ops: []Operation{
+				Apply{
+					Manager:    "apply-one",
+					APIVersion: versions.a,
+					Object: typed.YAMLObject(fmt.Sprintf(`
+						struct:
+						  name: a
+						  complexField_%s:
+						    name: b
+					`, versions.a)),
+				},
+				Apply{
+					Manager:    "apply-two",
+					APIVersion: versions.b,
+					Object: typed.YAMLObject(fmt.Sprintf(`
+						struct:
+						  complexField_%s:
+						    name: b
+					`, versions.b)),
+				},
+				Apply{
+					Manager:    "apply-one",
+					APIVersion: versions.a,
+					Object: `
+						struct:
+						  name: a
+					`,
+				},
+			},
+			Object: typed.YAMLObject(fmt.Sprintf(`
+				struct:
+				  name: a
+				  complexField_%s:
+				    name: b
+			`, versions.a)),
+			APIVersion: versions.a,
+			Managed: fieldpath.ManagedFields{
+				"apply-one": fieldpath.NewVersionedSet(
+					_NS(
+						_P("struct", "name"),
+					),
+					versions.a,
+					false,
+				),
+				"apply-two": fieldpath.NewVersionedSet(
+					_NS(
+						_P("struct", fmt.Sprintf("complexField_%s", versions.b), "name"),
+					),
+					versions.b,
+					false,
+				),
+			},
+		},
+	}
+
+	converter := renamingConverter{structParser}
+	for name, test := range tests {
+		t.Run(name, func(t *testing.T) {
+			if err := test.TestWithConverter(structParser, converter); err != nil {
+				t.Fatal(err)
+			}
+		})
+	}
+}
+
 func TestMultipleAppliersNestedType(t *testing.T) {
 	tests := map[string]TestCase{
 		"remove_one_keep_one_with_two_sub_items": {
@@ -1041,6 +1311,56 @@ func (r repeatingConverter) IsMissingVersionError(err error) bool {
 	return err == missingVersionError
 }
 
+// renamingConverter renames fields by substituting the version suffix of the field name. E.g.
+// converting a map  with a field named "name_v1" from v1 to v2 renames the field to "name_v2".
+// Fields without a version suffix are not converted; they are the same in all versions.
+// When parsing, this converter will look for the type by using the APIVersion of the
+// object it's trying to parse. If trying to parse a "v1" object, a corresponding "v1" type
+// should exist in the schema of the provided parser.
+type renamingConverter struct {
+	parser Parser
+}
+
+// Convert implements merge.Converter
+func (r renamingConverter) Convert(v *typed.TypedValue, version fieldpath.APIVersion) (*typed.TypedValue, error) {
+	if !v.AsValue().IsMap() {
+		return v, nil
+	}
+	inVersion := fieldpath.APIVersion(*v.TypeRef().NamedType)
+	outType := r.parser.Type(string(version))
+	return outType.FromUnstructured(renameConvert(v.AsValue(), string(inVersion), string(version)))
+}
+
+func renameConvert(v value.Value, oldSuffix, newSuffix string) interface{} {
+	if v.IsMap() {
+		out := map[string]interface{}{}
+		v.AsMap().Iterate(func(key string, value value.Value) bool {
+			if strings.HasSuffix(key, oldSuffix) {
+				out[strings.TrimSuffix(key, oldSuffix)+newSuffix] = renameConvert(value, oldSuffix, newSuffix)
+			} else {
+				out[key] = renameConvert(value, oldSuffix, newSuffix)
+			}
+			return true
+		})
+		return out
+	}
+	if v.IsList() {
+		var out []interface{}
+		ri := v.AsList().Range()
+		for ri.Next() {
+			_, v := ri.Item()
+			out = append(out, renameConvert(v, oldSuffix, newSuffix))
+		}
+		return out
+	}
+	return v.Unstructured()
+}
+
+// Convert implements merge.Converter
+func (r renamingConverter) IsMissingVersionError(err error) bool {
+	return err == missingVersionError
+}
+
 func BenchmarkMultipleApplierRecursiveRealConversion(b *testing.B) {
 	test := TestCase{
 		Ops: []Operation{

typed/typed.go

@@ -61,6 +61,11 @@ type TypedValue struct {
 	schema  *schema.Schema
 }
 
+// TypeRef is the type of the value.
+func (tv TypedValue) TypeRef() schema.TypeRef {
+	return tv.typeRef
+}
+
 // AsValue removes the type from the TypedValue and only keeps the value.
 func (tv TypedValue) AsValue() value.Value {
 	return tv.value