add Delta.DifferentExcept() method (#86)

I need the ability to detect whether there are any differences in a
resource's fields *other than* a particular one. Basically, in doing the
tagging work for DBInstance, I came across a problem where we were
calling the ModifyDBInstance API call even though there were no changes
to DBInstance Spec fields *other than* the Tags collection.

So, I need to add the following in an sdk_update_pre_build_request
template for DBInstance:

```go
if delta.DifferentAt("Spec.Tags") {
     if err = rm.SyncTags(ctx, desired, latest); err != nil {
         return nil, err
     }
}
if !delta.DifferentExcept("Spec.Tags") {
     // We don't want to proceed to call the ModifyDBInstance API since
     // no other resource fields have changed.
     return desired, nil
}
```

This PR adds the `delta.DifferentExcept()` implementation to enable the
above code.

Issue aws-controllers-k8s/community#1276

Signed-off-by: Jay Pipes <[email protected]>

By submitting this pull request, I confirm that my contribution is made
under the terms of the Apache 2.0 license.

Author: jaypipes

pkg/compare/delta.go

@@ -34,6 +34,49 @@ func (d *Delta) DifferentAt(subject string) bool {
 	return false
 }
 
+// DifferentExcept returns true if the delta contains any differences *other*
+// than any of the supplied path strings.
+//
+// This method is useful if you have a scenario where you don't want to proceed
+// with a modification action if certain fields in a resource have not been
+// changed.
+//
+// For example, consider this code:
+//
+// if delta.DifferentAt("Spec.Tags") {
+//     if err = rm.SyncTags(ctx, desired, latest); err != nil {
+//         return nil, err
+//     }
+// }
+// if !delta.DifferentExcept("Spec.Tags") {
+//     // We don't want to proceed to call the ModifyDBInstance API since
+//     // no other resource fields have changed.
+//     return desired, nil
+// }
+//
+// might be placed in an sdk_update_pre_build_request custom code hook to
+// prevent the ModifyDBInstance call from being executed if the DBInstance's
+// Tags field is the only field with changes.
+func (d *Delta) DifferentExcept(
+	exceptPaths ...string,
+) bool {
+	numDiffs := len(d.Differences)
+	if numDiffs == 0 {
+		return false
+	} else if numDiffs > len(exceptPaths) {
+		return true
+	}
+	foundExcepts := 0
+	for _, diff := range d.Differences {
+		for _, exceptPath := range exceptPaths {
+			if diff.Path.Contains(exceptPath) {
+				foundExcepts++
+			}
+		}
+	}
+	return foundExcepts != numDiffs
+}
+
 // Add adds a new Difference to the Delta
 func (d *Delta) Add(
 	path string,

pkg/compare/delta_test.go

@@ -59,8 +59,34 @@ func TestDifferentAt(t *testing.T) {
 	d.Add("Baz.Y", a.Baz.Y, b.Baz.Y)
 	require.True(d.DifferentAt("Baz"))
 	require.True(d.DifferentAt("Baz.Y"))
-	require.False(d.DifferentAt("Y")) // there is no diff for top-level field "Y"
-	require.False(d.DifferentAt("Bar")) // diff exists but it was not added to Delta
+	require.False(d.DifferentAt("Y"))       // there is no diff for top-level field "Y"
+	require.False(d.DifferentAt("Bar"))     // diff exists but it was not added to Delta
 	require.False(d.DifferentAt("Baz.Y.Z")) // subject length exceeds length of diff Path
-	require.False(d.DifferentAt("Baz.Z"))  // matches Path top-level field but not sub-field
+	require.False(d.DifferentAt("Baz.Z"))   // matches Path top-level field but not sub-field
+}
+
+func TestDifferentExcept(t *testing.T) {
+	require := require.New(t)
+
+	a := Foo{
+		Bar: "a_bar",
+		Baz: Baz{
+			Y: "a_baz_y",
+		},
+	}
+	b := Foo{
+		Bar: "b_bar",
+		Baz: Baz{
+			Y: "b_baz_y",
+		},
+	}
+
+	d := compare.NewDelta()
+	d.Add("", a, nil)
+	require.False(d.DifferentExcept(""))
+
+	d = compare.NewDelta()
+	d.Add("Baz.Y", a.Baz.Y, b.Baz.Y)
+	require.True(d.DifferentExcept("Bar"))    // there is a difference that is *not* Bar
+	require.False(d.DifferentExcept("Baz.Y")) // there is *not* a different that is *not* Bar
 }