update RecursiveDifference comment and extend tests

Author: Kevin Wiesmueller

fieldpath/set.go

@@ -98,9 +98,11 @@ func (s *Set) Difference(s2 *Set) *Set {
 // * appear in s
 // * do not appear in s2
 //
-// Compared to a regular difference, this recursively removes
-// all children from s
-// that are either children or members in s2
+// Compared to a regular difference,
+// this removes every field **and its children** from s that is contained in s2.
+//
+// For example, with s containing `a.b.c` and s2 containing `a.b`,
+// a RecursiveDifference will result in `a`, as the entire node `a.b` gets removed.
 func (s *Set) RecursiveDifference(s2 *Set) *Set {
 	return &Set{
 		Members:  *s.Members.Difference(&s2.Members),
@@ -349,20 +351,19 @@ func (s *SetNodeMap) Difference(s2 *Set) *SetNodeMap {
 
 // RecursiveDifference returns a SetNodeMap with members that appear in s but not in s2.
 //
-// Compared to a regular difference, this recursively removes
-// all children from s
-// that are either children or members in s2
+// Compared to a regular difference,
+// this removes every field **and its children** from s that is contained in s2.
+//
+// For example, with s containing `a.b.c` and s2 containing `a.b`,
+// a RecursiveDifference will result in `a`, as the entire node `a.b` gets removed.
 func (s *SetNodeMap) RecursiveDifference(s2 *Set) *SetNodeMap {
 	out := &SetNodeMap{}
 
 	i, j := 0, 0
 	for i < len(s.members) && j < len(s2.Children.members) {
 		if s.members[i].pathElement.Less(s2.Children.members[j].pathElement) {
 			if !s2.Members.Has(s.members[i].pathElement) {
-				out.members = append(out.members, setNode{
-					pathElement: s.members[i].pathElement,
-					set:         s.members[i].set,
-				})
+				out.members = append(out.members, setNode{pathElement: s.members[i].pathElement, set: s.members[i].set})
 			}
 			i++
 		} else {

fieldpath/set_test.go

@@ -453,66 +453,89 @@ func TestSetIntersectionDifference(t *testing.T) {
 	})
 }
 
-func TestSetRecursiveDifference(t *testing.T) {
+func TestSetDifference(t *testing.T) {
 	table := []struct {
-		name   string
-		a      *Set
-		b      *Set
-		expect *Set
+		name                      string
+		a                         *Set
+		b                         *Set
+		expectDifference          *Set
+		expectRecursiveDifference *Set
 	}{
 		{
-			name:   "removes simple path",
-			a:      NewSet(MakePathOrDie("a")),
-			b:      NewSet(MakePathOrDie("a")),
-			expect: NewSet(),
+			name:                      "removes simple path",
+			a:                         NewSet(MakePathOrDie("a")),
+			b:                         NewSet(MakePathOrDie("a")),
+			expectDifference:          NewSet(),
+			expectRecursiveDifference: NewSet(),
 		},
 		{
-			name:   "removes direct path",
-			a:      NewSet(MakePathOrDie("a", "b", "c")),
-			b:      NewSet(MakePathOrDie("a", "b", "c")),
-			expect: NewSet(),
+			name:                      "removes direct path",
+			a:                         NewSet(MakePathOrDie("a", "b", "c")),
+			b:                         NewSet(MakePathOrDie("a", "b", "c")),
+			expectDifference:          NewSet(),
+			expectRecursiveDifference: NewSet(),
 		},
 		{
 			name: "only removes matching child",
 			a: NewSet(
 				MakePathOrDie("a", "b", "c"),
 				MakePathOrDie("b", "b", "c"),
 			),
-			b:      NewSet(MakePathOrDie("a", "b", "c")),
-			expect: NewSet(MakePathOrDie("b", "b", "c")),
+			b:                         NewSet(MakePathOrDie("a", "b", "c")),
+			expectDifference:          NewSet(MakePathOrDie("b", "b", "c")),
+			expectRecursiveDifference: NewSet(MakePathOrDie("b", "b", "c")),
 		},
 		{
-			name:   "removes nested path",
-			a:      NewSet(MakePathOrDie("a", "b", "c")),
-			b:      NewSet(MakePathOrDie("a")),
-			expect: NewSet(),
+			name: "does not remove parent of specific path",
+			a: NewSet(
+				MakePathOrDie("a"),
+			),
+			b:                         NewSet(MakePathOrDie("a", "aa")),
+			expectDifference:          NewSet(MakePathOrDie("a")),
+			expectRecursiveDifference: NewSet(MakePathOrDie("a")),
 		},
 		{
-			name: "only removes nested path for matching children",
+			name:                      "RecursiveDifference removes nested path",
+			a:                         NewSet(MakePathOrDie("a", "b", "c")),
+			b:                         NewSet(MakePathOrDie("a")),
+			expectDifference:          NewSet(MakePathOrDie("a", "b", "c")),
+			expectRecursiveDifference: NewSet(),
+		},
+		{
+			name: "RecursiveDifference only removes nested path for matching children",
 			a: NewSet(
 				MakePathOrDie("a", "aa", "aab"),
 				MakePathOrDie("a", "ab", "aba"),
 			),
 			b: NewSet(MakePathOrDie("a", "aa")),
-			expect: NewSet(
+			expectDifference: NewSet(
+				MakePathOrDie("a", "aa", "aab"),
 				MakePathOrDie("a", "ab", "aba"),
 			),
+			expectRecursiveDifference: NewSet(MakePathOrDie("a", "ab", "aba")),
 		},
 		{
-			name: "remove all matching children",
+			name: "RecursiveDifference removes all matching children",
 			a: NewSet(
 				MakePathOrDie("a", "aa", "aab"),
 				MakePathOrDie("a", "ab", "aba"),
 			),
-			b:      NewSet(MakePathOrDie("a")),
-			expect: NewSet(),
+			b: NewSet(MakePathOrDie("a")),
+			expectDifference: NewSet(
+				MakePathOrDie("a", "aa", "aab"),
+				MakePathOrDie("a", "ab", "aba"),
+			),
+			expectRecursiveDifference: NewSet(),
 		},
 	}
 
 	for _, c := range table {
 		t.Run(c.name, func(t *testing.T) {
-			if result := c.a.RecursiveDifference(c.b); !result.Equals(c.expect) {
-				t.Fatalf("expected: \n%v\n, got: \n%v\n", c.expect, result)
+			if result := c.a.Difference(c.b); !result.Equals(c.expectDifference) {
+				t.Fatalf("Difference expected: \n%v\n, got: \n%v\n", c.expectDifference, result)
+			}
+			if result := c.a.RecursiveDifference(c.b); !result.Equals(c.expectRecursiveDifference) {
+				t.Fatalf("RecursiveDifference expected: \n%v\n, got: \n%v\n", c.expectRecursiveDifference, result)
 			}
 		})
 	}