From 6b03c8137579367f94b9ea78d0dbaf06f3803419 Mon Sep 17 00:00:00 2001 From: Martin Atkins Date: Tue, 22 Jan 2019 14:51:11 -0800 Subject: [PATCH] config/hcl2shim: ValuesSDKEquivalent function This is a first pass of an "approximately equal" function that tries to mimic the reduced precision caused by the field reader abstraction in helper/schema so that we can distinguish between meaningful changes to the proposed new state and incidental ones that just result from the loss of precision in the SDK implementation. --- config/hcl2shim/values_equiv.go | 177 ++++++++++++ config/hcl2shim/values_equiv_test.go | 407 +++++++++++++++++++++++++++ 2 files changed, 584 insertions(+) create mode 100644 config/hcl2shim/values_equiv.go create mode 100644 config/hcl2shim/values_equiv_test.go diff --git a/config/hcl2shim/values_equiv.go b/config/hcl2shim/values_equiv.go new file mode 100644 index 000000000..ab437de80 --- /dev/null +++ b/config/hcl2shim/values_equiv.go @@ -0,0 +1,177 @@ +package hcl2shim + +import ( + "github.com/zclconf/go-cty/cty" +) + +// ValuesSDKEquivalent returns true if both of the given values seem equivalent +// as far as the legacy SDK diffing code would be concerned. +// +// Since SDK diffing is a fuzzy, inexact operation, this function is also +// fuzzy and inexact. It will err on the side of returning false if it +// encounters an ambiguous situation. Ambiguity is most common in the presence +// of sets because in practice it is impossible to exactly correlate +// nonequal-but-equivalent set elements because they have no identity separate +// from their value. +// +// This must be used _only_ for comparing values for equivalence within the +// SDK planning code. It is only meaningful to compare the "prior state" +// provided by Terraform Core with the "planned new state" produced by the +// legacy SDK code via shims. In particular it is not valid to use this +// function with their the config value or the "proposed new state" value +// because they contain only the subset of data that Terraform Core itself is +// able to determine. +func ValuesSDKEquivalent(a, b cty.Value) bool { + if a == cty.NilVal || b == cty.NilVal { + // We don't generally expect nils to appear, but we'll allow them + // for robustness since the data structures produced by legacy SDK code + // can sometimes be non-ideal. + return a == b // equivalent if they are _both_ nil + } + if a.RawEquals(b) { + // Easy case. We use RawEquals because we want two unknowns to be + // considered equal here, whereas "Equals" would return unknown. + return true + } + if !a.IsKnown() || !b.IsKnown() { + // Two unknown values are equivalent regardless of type. A known is + // never equivalent to an unknown. + return a.IsKnown() == b.IsKnown() + } + if aZero, bZero := valuesSDKEquivalentIsNullOrZero(a), valuesSDKEquivalentIsNullOrZero(b); aZero || bZero { + // Two null/zero values are equivalent regardless of type. A non-zero is + // never equivalent to a zero. + return aZero == bZero + } + + // If we get down here then we are guaranteed that both a and b are known, + // non-null values. + + aTy := a.Type() + bTy := b.Type() + switch { + case aTy.IsSetType() && bTy.IsSetType(): + return valuesSDKEquivalentSets(a, b) + case aTy.IsListType() && bTy.IsListType(): + return valuesSDKEquivalentSequences(a, b) + case aTy.IsTupleType() && bTy.IsTupleType(): + return valuesSDKEquivalentSequences(a, b) + case aTy.IsMapType() && bTy.IsMapType(): + return valuesSDKEquivalentMappings(a, b) + case aTy.IsObjectType() && bTy.IsObjectType(): + return valuesSDKEquivalentMappings(a, b) + default: + // We've now covered all the interesting cases, so anything that falls + // down here cannot be equivalent. + return false + } +} + +// valuesSDKEquivalentIsNullOrZero returns true if the given value is either +// null or is the "zero value" (in the SDK/Go sense) for its type. +func valuesSDKEquivalentIsNullOrZero(v cty.Value) bool { + if v == cty.NilVal { + return true + } + + ty := v.Type() + switch { + case !v.IsKnown(): + return false + case v.IsNull(): + return true + + // After this point, v is always known and non-null + case ty.IsListType() || ty.IsSetType() || ty.IsMapType() || ty.IsObjectType() || ty.IsTupleType(): + return v.LengthInt() == 0 + case ty == cty.String: + return v.RawEquals(cty.StringVal("")) + case ty == cty.Number: + return v.RawEquals(cty.Zero) + case ty == cty.Bool: + return v.RawEquals(cty.False) + default: + // The above is exhaustive, but for robustness we'll consider anything + // else to _not_ be zero unless it is null. + return false + } +} + +// valuesSDKEquivalentSets returns true only if each of the elements in a can +// be correlated with at least one equivalent element in b and vice-versa. +// This is a fuzzy operation that prefers to signal non-equivalence if it cannot +// be certain that all elements are accounted for. +func valuesSDKEquivalentSets(a, b cty.Value) bool { + if aLen, bLen := a.LengthInt(), b.LengthInt(); aLen != bLen { + return false + } + + // Our methodology here is a little tricky, to deal with the fact that + // it's impossible to directly correlate two non-equal set elements because + // they don't have identities separate from their values. + // The approach is to count the number of equivalent elements each element + // of a has in b and vice-versa, and then return true only if each element + // in both sets has at least one equivalent. + as := a.AsValueSlice() + bs := b.AsValueSlice() + aeqs := make([]bool, len(as)) + beqs := make([]bool, len(bs)) + for ai, av := range as { + for bi, bv := range bs { + if ValuesSDKEquivalent(av, bv) { + aeqs[ai] = true + beqs[bi] = true + } + } + } + + for _, eq := range aeqs { + if !eq { + return false + } + } + for _, eq := range beqs { + if !eq { + return false + } + } + return true +} + +// valuesSDKEquivalentSequences decides equivalence for two sequence values +// (lists or tuples). +func valuesSDKEquivalentSequences(a, b cty.Value) bool { + as := a.AsValueSlice() + bs := b.AsValueSlice() + if len(as) != len(bs) { + return false + } + + for i := range as { + if !ValuesSDKEquivalent(as[i], bs[i]) { + return false + } + } + return true +} + +// valuesSDKEquivalentMappings decides equivalence for two mapping values +// (maps or objects). +func valuesSDKEquivalentMappings(a, b cty.Value) bool { + as := a.AsValueMap() + bs := b.AsValueMap() + if len(as) != len(bs) { + return false + } + + for k, av := range as { + bv, ok := bs[k] + if !ok { + return false + } + if !ValuesSDKEquivalent(av, bv) { + return false + } + } + return true +} diff --git a/config/hcl2shim/values_equiv_test.go b/config/hcl2shim/values_equiv_test.go new file mode 100644 index 000000000..443eb6b7d --- /dev/null +++ b/config/hcl2shim/values_equiv_test.go @@ -0,0 +1,407 @@ +package hcl2shim + +import ( + "fmt" + "testing" + + "github.com/zclconf/go-cty/cty" +) + +func TestValuesSDKEquivalent(t *testing.T) { + tests := []struct { + A, B cty.Value + Want bool + }{ + // Strings + { + cty.StringVal("hello"), + cty.StringVal("hello"), + true, + }, + { + cty.StringVal("hello"), + cty.StringVal("world"), + false, + }, + { + cty.StringVal("hello"), + cty.StringVal(""), + false, + }, + { + cty.NullVal(cty.String), + cty.StringVal(""), + true, + }, + + // Numbers + { + cty.NumberIntVal(1), + cty.NumberIntVal(1), + true, + }, + { + cty.NumberIntVal(1), + cty.NumberIntVal(2), + false, + }, + { + cty.NumberIntVal(1), + cty.Zero, + false, + }, + { + cty.NullVal(cty.Number), + cty.Zero, + true, + }, + + // Bools + { + cty.True, + cty.True, + true, + }, + { + cty.True, + cty.False, + false, + }, + { + cty.NullVal(cty.Bool), + cty.False, + true, + }, + + // Mixed primitives + { + cty.StringVal("hello"), + cty.False, + false, + }, + { + cty.StringVal(""), + cty.False, + true, + }, + { + cty.NumberIntVal(0), + cty.False, + true, + }, + { + cty.StringVal(""), + cty.NumberIntVal(0), + true, + }, + { + cty.NullVal(cty.Bool), + cty.NullVal(cty.Number), + true, + }, + { + cty.StringVal(""), + cty.NullVal(cty.Number), + true, + }, + + // Lists + { + cty.ListValEmpty(cty.String), + cty.ListValEmpty(cty.String), + true, + }, + { + cty.ListValEmpty(cty.String), + cty.NullVal(cty.List(cty.String)), + true, + }, + { + cty.ListVal([]cty.Value{cty.StringVal("hello")}), + cty.ListVal([]cty.Value{cty.StringVal("hello"), cty.StringVal("hello")}), + false, + }, + { + cty.ListVal([]cty.Value{cty.StringVal("hello")}), + cty.ListValEmpty(cty.String), + false, + }, + { + cty.ListVal([]cty.Value{cty.StringVal("hello")}), + cty.ListVal([]cty.Value{cty.StringVal("hello")}), + true, + }, + { + cty.ListVal([]cty.Value{cty.StringVal("hello")}), + cty.ListVal([]cty.Value{cty.StringVal("world")}), + false, + }, + { + cty.ListVal([]cty.Value{cty.NullVal(cty.String)}), + cty.ListVal([]cty.Value{cty.StringVal("")}), + true, + }, + + // Tuples + { + cty.EmptyTupleVal, + cty.EmptyTupleVal, + true, + }, + { + cty.EmptyTupleVal, + cty.NullVal(cty.EmptyTuple), + true, + }, + { + cty.TupleVal([]cty.Value{cty.StringVal("hello")}), + cty.TupleVal([]cty.Value{cty.StringVal("hello"), cty.StringVal("hello")}), + false, + }, + { + cty.TupleVal([]cty.Value{cty.StringVal("hello")}), + cty.EmptyTupleVal, + false, + }, + { + cty.TupleVal([]cty.Value{cty.StringVal("hello")}), + cty.TupleVal([]cty.Value{cty.StringVal("hello")}), + true, + }, + { + cty.TupleVal([]cty.Value{cty.StringVal("hello")}), + cty.TupleVal([]cty.Value{cty.StringVal("world")}), + false, + }, + { + cty.TupleVal([]cty.Value{cty.NullVal(cty.String)}), + cty.TupleVal([]cty.Value{cty.StringVal("")}), + true, + }, + + // Sets + { + cty.SetValEmpty(cty.String), + cty.SetValEmpty(cty.String), + true, + }, + { + cty.SetValEmpty(cty.String), + cty.NullVal(cty.Set(cty.String)), + true, + }, + { + cty.SetVal([]cty.Value{cty.StringVal("hello")}), + cty.SetValEmpty(cty.String), + false, + }, + { + cty.SetVal([]cty.Value{cty.StringVal("hello")}), + cty.SetVal([]cty.Value{cty.StringVal("hello")}), + true, + }, + { + cty.SetVal([]cty.Value{cty.StringVal("hello")}), + cty.SetVal([]cty.Value{cty.StringVal("world")}), + false, + }, + { + cty.SetVal([]cty.Value{cty.NullVal(cty.String)}), + cty.SetVal([]cty.Value{cty.StringVal("")}), + true, + }, + { + cty.SetVal([]cty.Value{ + cty.NullVal(cty.String), + cty.StringVal(""), + }), + cty.SetVal([]cty.Value{ + cty.NullVal(cty.String), + }), + false, // because the element count is different + }, + { + cty.SetVal([]cty.Value{ + cty.ObjectVal(map[string]cty.Value{ + "a": cty.StringVal(""), + "b": cty.StringVal(""), + }), + cty.ObjectVal(map[string]cty.Value{ + "a": cty.NullVal(cty.String), + "b": cty.StringVal(""), + }), + }), + cty.SetVal([]cty.Value{ + cty.ObjectVal(map[string]cty.Value{ + "a": cty.StringVal(""), + "b": cty.StringVal(""), + }), + cty.ObjectVal(map[string]cty.Value{ + "a": cty.StringVal(""), + "b": cty.NullVal(cty.String), + }), + }), + true, + }, + { + cty.SetVal([]cty.Value{ + cty.ObjectVal(map[string]cty.Value{ + "a": cty.StringVal("boop"), + "b": cty.StringVal(""), + }), + cty.ObjectVal(map[string]cty.Value{ + "a": cty.NullVal(cty.String), + "b": cty.StringVal(""), + }), + }), + cty.SetVal([]cty.Value{ + cty.ObjectVal(map[string]cty.Value{ + "a": cty.StringVal("beep"), + "b": cty.StringVal(""), + }), + cty.ObjectVal(map[string]cty.Value{ + "a": cty.StringVal(""), + "b": cty.NullVal(cty.String), + }), + }), + false, + }, + { + cty.SetVal([]cty.Value{cty.ObjectVal(map[string]cty.Value{ + "list": cty.ListValEmpty(cty.String), + "list_block": cty.ListVal([]cty.Value{ + cty.ObjectVal(map[string]cty.Value{ + "unused": cty.StringVal(""), + }), + }), + })}), + cty.SetVal([]cty.Value{cty.ObjectVal(map[string]cty.Value{ + "list": cty.ListValEmpty(cty.String), + "list_block": cty.ListVal([]cty.Value{ + cty.ObjectVal(map[string]cty.Value{ + "unused": cty.NullVal(cty.String), + }), + }), + })}), + true, + }, + + // Maps + { + cty.MapValEmpty(cty.String), + cty.MapValEmpty(cty.String), + true, + }, + { + cty.MapValEmpty(cty.String), + cty.NullVal(cty.Map(cty.String)), + true, + }, + { + cty.MapVal(map[string]cty.Value{"hi": cty.StringVal("hello")}), + cty.MapVal(map[string]cty.Value{"hi": cty.StringVal("hello"), "hey": cty.StringVal("hello")}), + false, + }, + { + cty.MapVal(map[string]cty.Value{"hi": cty.StringVal("hello")}), + cty.MapValEmpty(cty.String), + false, + }, + { + cty.MapVal(map[string]cty.Value{"hi": cty.StringVal("hello")}), + cty.MapVal(map[string]cty.Value{"hi": cty.StringVal("hello")}), + true, + }, + { + cty.MapVal(map[string]cty.Value{"hi": cty.StringVal("hello")}), + cty.MapVal(map[string]cty.Value{"hi": cty.StringVal("world")}), + false, + }, + { + cty.MapVal(map[string]cty.Value{"hi": cty.NullVal(cty.String)}), + cty.MapVal(map[string]cty.Value{"hi": cty.StringVal("")}), + true, + }, + + // Objects + { + cty.EmptyObjectVal, + cty.EmptyObjectVal, + true, + }, + { + cty.EmptyObjectVal, + cty.NullVal(cty.EmptyObject), + true, + }, + { + cty.ObjectVal(map[string]cty.Value{"hi": cty.StringVal("hello")}), + cty.ObjectVal(map[string]cty.Value{"hi": cty.StringVal("hello"), "hey": cty.StringVal("hello")}), + false, + }, + { + cty.ObjectVal(map[string]cty.Value{"hi": cty.StringVal("hello")}), + cty.EmptyObjectVal, + false, + }, + { + cty.ObjectVal(map[string]cty.Value{"hi": cty.StringVal("hello")}), + cty.ObjectVal(map[string]cty.Value{"hi": cty.StringVal("hello")}), + true, + }, + { + cty.ObjectVal(map[string]cty.Value{"hi": cty.StringVal("hello")}), + cty.ObjectVal(map[string]cty.Value{"hi": cty.StringVal("world")}), + false, + }, + { + cty.ObjectVal(map[string]cty.Value{"hi": cty.NullVal(cty.String)}), + cty.ObjectVal(map[string]cty.Value{"hi": cty.StringVal("")}), + true, + }, + + // Unknown values + { + cty.UnknownVal(cty.String), + cty.UnknownVal(cty.String), + true, + }, + { + cty.StringVal("hello"), + cty.UnknownVal(cty.String), + false, + }, + { + cty.StringVal(""), + cty.UnknownVal(cty.String), + false, + }, + { + cty.NullVal(cty.String), + cty.UnknownVal(cty.String), + false, + }, + } + + run := func(t *testing.T, a, b cty.Value, want bool) { + got := ValuesSDKEquivalent(a, b) + + if got != want { + t.Errorf("wrong result\nfor: %#v ≈ %#v\ngot %#v, but want %#v", a, b, got, want) + } + } + + for _, test := range tests { + t.Run(fmt.Sprintf("%#v ≈ %#v", test.A, test.B), func(t *testing.T) { + run(t, test.A, test.B, test.Want) + }) + // This function is symmetrical, so we'll also test in reverse so + // we don't need to manually copy all of the test cases. (But this does + // mean that one failure normally becomes two, of course!) + if !test.A.RawEquals(test.B) { + t.Run(fmt.Sprintf("%#v ≈ %#v", test.B, test.A), func(t *testing.T) { + run(t, test.B, test.A, test.Want) + }) + } + } +}