mirror of
https://github.com/opentofu/opentofu.git
synced 2024-12-26 17:01:04 -06:00
db968733da
When applying a legacy diff, recount the flatmapped containers. We can't trust helper/schema to return the correct value, if it even exists.
1253 lines
24 KiB
Go
1253 lines
24 KiB
Go
package terraform
|
|
|
|
import (
|
|
"fmt"
|
|
"reflect"
|
|
"strconv"
|
|
"strings"
|
|
"testing"
|
|
|
|
"github.com/hashicorp/terraform/addrs"
|
|
)
|
|
|
|
func TestDiffEmpty(t *testing.T) {
|
|
var diff *Diff
|
|
if !diff.Empty() {
|
|
t.Fatal("should be empty")
|
|
}
|
|
|
|
diff = new(Diff)
|
|
if !diff.Empty() {
|
|
t.Fatal("should be empty")
|
|
}
|
|
|
|
mod := diff.AddModule(addrs.RootModuleInstance)
|
|
mod.Resources["nodeA"] = &InstanceDiff{
|
|
Attributes: map[string]*ResourceAttrDiff{
|
|
"foo": &ResourceAttrDiff{
|
|
Old: "foo",
|
|
New: "bar",
|
|
},
|
|
},
|
|
}
|
|
|
|
if diff.Empty() {
|
|
t.Fatal("should not be empty")
|
|
}
|
|
}
|
|
|
|
func TestDiffEmpty_taintedIsNotEmpty(t *testing.T) {
|
|
diff := new(Diff)
|
|
|
|
mod := diff.AddModule(addrs.RootModuleInstance)
|
|
mod.Resources["nodeA"] = &InstanceDiff{
|
|
DestroyTainted: true,
|
|
}
|
|
|
|
if diff.Empty() {
|
|
t.Fatal("should not be empty, since DestroyTainted was set")
|
|
}
|
|
}
|
|
|
|
func TestDiffEqual(t *testing.T) {
|
|
cases := map[string]struct {
|
|
D1, D2 *Diff
|
|
Equal bool
|
|
}{
|
|
"nil": {
|
|
nil,
|
|
new(Diff),
|
|
false,
|
|
},
|
|
|
|
"empty": {
|
|
new(Diff),
|
|
new(Diff),
|
|
true,
|
|
},
|
|
|
|
"different module order": {
|
|
&Diff{
|
|
Modules: []*ModuleDiff{
|
|
&ModuleDiff{Path: []string{"root", "foo"}},
|
|
&ModuleDiff{Path: []string{"root", "bar"}},
|
|
},
|
|
},
|
|
&Diff{
|
|
Modules: []*ModuleDiff{
|
|
&ModuleDiff{Path: []string{"root", "bar"}},
|
|
&ModuleDiff{Path: []string{"root", "foo"}},
|
|
},
|
|
},
|
|
true,
|
|
},
|
|
|
|
"different module diff destroys": {
|
|
&Diff{
|
|
Modules: []*ModuleDiff{
|
|
&ModuleDiff{Path: []string{"root", "foo"}, Destroy: true},
|
|
},
|
|
},
|
|
&Diff{
|
|
Modules: []*ModuleDiff{
|
|
&ModuleDiff{Path: []string{"root", "foo"}, Destroy: false},
|
|
},
|
|
},
|
|
true,
|
|
},
|
|
}
|
|
|
|
for name, tc := range cases {
|
|
t.Run(name, func(t *testing.T) {
|
|
actual := tc.D1.Equal(tc.D2)
|
|
if actual != tc.Equal {
|
|
t.Fatalf("expected: %v\n\n%#v\n\n%#v", tc.Equal, tc.D1, tc.D2)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestDiffPrune(t *testing.T) {
|
|
cases := map[string]struct {
|
|
D1, D2 *Diff
|
|
}{
|
|
"nil": {
|
|
nil,
|
|
nil,
|
|
},
|
|
|
|
"empty": {
|
|
new(Diff),
|
|
new(Diff),
|
|
},
|
|
|
|
"empty module": {
|
|
&Diff{
|
|
Modules: []*ModuleDiff{
|
|
&ModuleDiff{Path: []string{"root", "foo"}},
|
|
},
|
|
},
|
|
&Diff{},
|
|
},
|
|
|
|
"destroy module": {
|
|
&Diff{
|
|
Modules: []*ModuleDiff{
|
|
&ModuleDiff{Path: []string{"root", "foo"}, Destroy: true},
|
|
},
|
|
},
|
|
&Diff{
|
|
Modules: []*ModuleDiff{
|
|
&ModuleDiff{Path: []string{"root", "foo"}, Destroy: true},
|
|
},
|
|
},
|
|
},
|
|
}
|
|
|
|
for name, tc := range cases {
|
|
t.Run(name, func(t *testing.T) {
|
|
tc.D1.Prune()
|
|
if !tc.D1.Equal(tc.D2) {
|
|
t.Fatalf("bad:\n\n%#v\n\n%#v", tc.D1, tc.D2)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestModuleDiff_ChangeType(t *testing.T) {
|
|
cases := []struct {
|
|
Diff *ModuleDiff
|
|
Result DiffChangeType
|
|
}{
|
|
{
|
|
&ModuleDiff{},
|
|
DiffNone,
|
|
},
|
|
{
|
|
&ModuleDiff{
|
|
Resources: map[string]*InstanceDiff{
|
|
"foo": &InstanceDiff{Destroy: true},
|
|
},
|
|
},
|
|
DiffDestroy,
|
|
},
|
|
{
|
|
&ModuleDiff{
|
|
Resources: map[string]*InstanceDiff{
|
|
"foo": &InstanceDiff{
|
|
Attributes: map[string]*ResourceAttrDiff{
|
|
"foo": &ResourceAttrDiff{
|
|
Old: "",
|
|
New: "bar",
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
DiffUpdate,
|
|
},
|
|
{
|
|
&ModuleDiff{
|
|
Resources: map[string]*InstanceDiff{
|
|
"foo": &InstanceDiff{
|
|
Attributes: map[string]*ResourceAttrDiff{
|
|
"foo": &ResourceAttrDiff{
|
|
Old: "",
|
|
New: "bar",
|
|
RequiresNew: true,
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
DiffCreate,
|
|
},
|
|
{
|
|
&ModuleDiff{
|
|
Resources: map[string]*InstanceDiff{
|
|
"foo": &InstanceDiff{
|
|
Destroy: true,
|
|
Attributes: map[string]*ResourceAttrDiff{
|
|
"foo": &ResourceAttrDiff{
|
|
Old: "",
|
|
New: "bar",
|
|
RequiresNew: true,
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
DiffUpdate,
|
|
},
|
|
}
|
|
|
|
for i, tc := range cases {
|
|
actual := tc.Diff.ChangeType()
|
|
if actual != tc.Result {
|
|
t.Fatalf("%d: %#v", i, actual)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestDiff_DeepCopy(t *testing.T) {
|
|
cases := map[string]*Diff{
|
|
"empty": &Diff{},
|
|
|
|
"basic diff": &Diff{
|
|
Modules: []*ModuleDiff{
|
|
&ModuleDiff{
|
|
Path: []string{"root"},
|
|
Resources: map[string]*InstanceDiff{
|
|
"aws_instance.foo": &InstanceDiff{
|
|
Attributes: map[string]*ResourceAttrDiff{
|
|
"num": &ResourceAttrDiff{
|
|
Old: "0",
|
|
New: "2",
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
}
|
|
|
|
for name, tc := range cases {
|
|
t.Run(name, func(t *testing.T) {
|
|
dup := tc.DeepCopy()
|
|
if !reflect.DeepEqual(dup, tc) {
|
|
t.Fatalf("\n%#v\n\n%#v", dup, tc)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestModuleDiff_Empty(t *testing.T) {
|
|
diff := new(ModuleDiff)
|
|
if !diff.Empty() {
|
|
t.Fatal("should be empty")
|
|
}
|
|
|
|
diff.Resources = map[string]*InstanceDiff{
|
|
"nodeA": &InstanceDiff{},
|
|
}
|
|
|
|
if !diff.Empty() {
|
|
t.Fatal("should be empty")
|
|
}
|
|
|
|
diff.Resources["nodeA"].Attributes = map[string]*ResourceAttrDiff{
|
|
"foo": &ResourceAttrDiff{
|
|
Old: "foo",
|
|
New: "bar",
|
|
},
|
|
}
|
|
|
|
if diff.Empty() {
|
|
t.Fatal("should not be empty")
|
|
}
|
|
|
|
diff.Resources["nodeA"].Attributes = nil
|
|
diff.Resources["nodeA"].Destroy = true
|
|
|
|
if diff.Empty() {
|
|
t.Fatal("should not be empty")
|
|
}
|
|
}
|
|
|
|
func TestModuleDiff_String(t *testing.T) {
|
|
diff := &ModuleDiff{
|
|
Resources: map[string]*InstanceDiff{
|
|
"nodeA": &InstanceDiff{
|
|
Attributes: map[string]*ResourceAttrDiff{
|
|
"foo": &ResourceAttrDiff{
|
|
Old: "foo",
|
|
New: "bar",
|
|
},
|
|
"bar": &ResourceAttrDiff{
|
|
Old: "foo",
|
|
NewComputed: true,
|
|
},
|
|
"longfoo": &ResourceAttrDiff{
|
|
Old: "foo",
|
|
New: "bar",
|
|
RequiresNew: true,
|
|
},
|
|
"secretfoo": &ResourceAttrDiff{
|
|
Old: "foo",
|
|
New: "bar",
|
|
Sensitive: true,
|
|
},
|
|
},
|
|
},
|
|
},
|
|
}
|
|
|
|
actual := strings.TrimSpace(diff.String())
|
|
expected := strings.TrimSpace(moduleDiffStrBasic)
|
|
if actual != expected {
|
|
t.Fatalf("bad:\n%s", actual)
|
|
}
|
|
}
|
|
|
|
func TestInstanceDiff_ChangeType(t *testing.T) {
|
|
cases := []struct {
|
|
Diff *InstanceDiff
|
|
Result DiffChangeType
|
|
}{
|
|
{
|
|
&InstanceDiff{},
|
|
DiffNone,
|
|
},
|
|
{
|
|
&InstanceDiff{Destroy: true},
|
|
DiffDestroy,
|
|
},
|
|
{
|
|
&InstanceDiff{
|
|
Attributes: map[string]*ResourceAttrDiff{
|
|
"foo": &ResourceAttrDiff{
|
|
Old: "",
|
|
New: "bar",
|
|
},
|
|
},
|
|
},
|
|
DiffUpdate,
|
|
},
|
|
{
|
|
&InstanceDiff{
|
|
Attributes: map[string]*ResourceAttrDiff{
|
|
"foo": &ResourceAttrDiff{
|
|
Old: "",
|
|
New: "bar",
|
|
RequiresNew: true,
|
|
},
|
|
},
|
|
},
|
|
DiffCreate,
|
|
},
|
|
{
|
|
&InstanceDiff{
|
|
Destroy: true,
|
|
Attributes: map[string]*ResourceAttrDiff{
|
|
"foo": &ResourceAttrDiff{
|
|
Old: "",
|
|
New: "bar",
|
|
RequiresNew: true,
|
|
},
|
|
},
|
|
},
|
|
DiffDestroyCreate,
|
|
},
|
|
{
|
|
&InstanceDiff{
|
|
DestroyTainted: true,
|
|
Attributes: map[string]*ResourceAttrDiff{
|
|
"foo": &ResourceAttrDiff{
|
|
Old: "",
|
|
New: "bar",
|
|
RequiresNew: true,
|
|
},
|
|
},
|
|
},
|
|
DiffDestroyCreate,
|
|
},
|
|
}
|
|
|
|
for i, tc := range cases {
|
|
actual := tc.Diff.ChangeType()
|
|
if actual != tc.Result {
|
|
t.Fatalf("%d: %#v", i, actual)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestInstanceDiff_Empty(t *testing.T) {
|
|
var rd *InstanceDiff
|
|
|
|
if !rd.Empty() {
|
|
t.Fatal("should be empty")
|
|
}
|
|
|
|
rd = new(InstanceDiff)
|
|
|
|
if !rd.Empty() {
|
|
t.Fatal("should be empty")
|
|
}
|
|
|
|
rd = &InstanceDiff{Destroy: true}
|
|
|
|
if rd.Empty() {
|
|
t.Fatal("should not be empty")
|
|
}
|
|
|
|
rd = &InstanceDiff{
|
|
Attributes: map[string]*ResourceAttrDiff{
|
|
"foo": &ResourceAttrDiff{
|
|
New: "bar",
|
|
},
|
|
},
|
|
}
|
|
|
|
if rd.Empty() {
|
|
t.Fatal("should not be empty")
|
|
}
|
|
}
|
|
|
|
func TestModuleDiff_Instances(t *testing.T) {
|
|
yesDiff := &InstanceDiff{Destroy: true}
|
|
noDiff := &InstanceDiff{Destroy: true, DestroyTainted: true}
|
|
|
|
cases := []struct {
|
|
Diff *ModuleDiff
|
|
Id string
|
|
Result []*InstanceDiff
|
|
}{
|
|
{
|
|
&ModuleDiff{
|
|
Resources: map[string]*InstanceDiff{
|
|
"foo": yesDiff,
|
|
"bar": noDiff,
|
|
},
|
|
},
|
|
"foo",
|
|
[]*InstanceDiff{
|
|
yesDiff,
|
|
},
|
|
},
|
|
|
|
{
|
|
&ModuleDiff{
|
|
Resources: map[string]*InstanceDiff{
|
|
"foo": yesDiff,
|
|
"foo.0": yesDiff,
|
|
"bar": noDiff,
|
|
},
|
|
},
|
|
"foo",
|
|
[]*InstanceDiff{
|
|
yesDiff,
|
|
yesDiff,
|
|
},
|
|
},
|
|
|
|
{
|
|
&ModuleDiff{
|
|
Resources: map[string]*InstanceDiff{
|
|
"foo": yesDiff,
|
|
"foo.0": yesDiff,
|
|
"foo_bar": noDiff,
|
|
"bar": noDiff,
|
|
},
|
|
},
|
|
"foo",
|
|
[]*InstanceDiff{
|
|
yesDiff,
|
|
yesDiff,
|
|
},
|
|
},
|
|
}
|
|
|
|
for i, tc := range cases {
|
|
actual := tc.Diff.Instances(tc.Id)
|
|
if !reflect.DeepEqual(actual, tc.Result) {
|
|
t.Fatalf("%d: %#v", i, actual)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestInstanceDiff_RequiresNew(t *testing.T) {
|
|
rd := &InstanceDiff{
|
|
Attributes: map[string]*ResourceAttrDiff{
|
|
"foo": &ResourceAttrDiff{},
|
|
},
|
|
}
|
|
|
|
if rd.RequiresNew() {
|
|
t.Fatal("should not require new")
|
|
}
|
|
|
|
rd.Attributes["foo"].RequiresNew = true
|
|
|
|
if !rd.RequiresNew() {
|
|
t.Fatal("should require new")
|
|
}
|
|
}
|
|
|
|
func TestInstanceDiff_RequiresNew_nil(t *testing.T) {
|
|
var rd *InstanceDiff
|
|
|
|
if rd.RequiresNew() {
|
|
t.Fatal("should not require new")
|
|
}
|
|
}
|
|
|
|
func TestInstanceDiffSame(t *testing.T) {
|
|
cases := []struct {
|
|
One, Two *InstanceDiff
|
|
Same bool
|
|
Reason string
|
|
}{
|
|
{
|
|
&InstanceDiff{},
|
|
&InstanceDiff{},
|
|
true,
|
|
"",
|
|
},
|
|
|
|
{
|
|
nil,
|
|
nil,
|
|
true,
|
|
"",
|
|
},
|
|
|
|
{
|
|
&InstanceDiff{Destroy: false},
|
|
&InstanceDiff{Destroy: true},
|
|
false,
|
|
"diff: Destroy; old: false, new: true",
|
|
},
|
|
|
|
{
|
|
&InstanceDiff{Destroy: true},
|
|
&InstanceDiff{Destroy: true},
|
|
true,
|
|
"",
|
|
},
|
|
|
|
{
|
|
&InstanceDiff{
|
|
Attributes: map[string]*ResourceAttrDiff{
|
|
"foo": &ResourceAttrDiff{},
|
|
},
|
|
},
|
|
&InstanceDiff{
|
|
Attributes: map[string]*ResourceAttrDiff{
|
|
"foo": &ResourceAttrDiff{},
|
|
},
|
|
},
|
|
true,
|
|
"",
|
|
},
|
|
|
|
{
|
|
&InstanceDiff{
|
|
Attributes: map[string]*ResourceAttrDiff{
|
|
"bar": &ResourceAttrDiff{},
|
|
},
|
|
},
|
|
&InstanceDiff{
|
|
Attributes: map[string]*ResourceAttrDiff{
|
|
"foo": &ResourceAttrDiff{},
|
|
},
|
|
},
|
|
false,
|
|
"attribute mismatch: bar",
|
|
},
|
|
|
|
// Extra attributes
|
|
{
|
|
&InstanceDiff{
|
|
Attributes: map[string]*ResourceAttrDiff{
|
|
"foo": &ResourceAttrDiff{},
|
|
},
|
|
},
|
|
&InstanceDiff{
|
|
Attributes: map[string]*ResourceAttrDiff{
|
|
"foo": &ResourceAttrDiff{},
|
|
"bar": &ResourceAttrDiff{},
|
|
},
|
|
},
|
|
false,
|
|
"extra attributes: bar",
|
|
},
|
|
|
|
{
|
|
&InstanceDiff{
|
|
Attributes: map[string]*ResourceAttrDiff{
|
|
"foo": &ResourceAttrDiff{RequiresNew: true},
|
|
},
|
|
},
|
|
&InstanceDiff{
|
|
Attributes: map[string]*ResourceAttrDiff{
|
|
"foo": &ResourceAttrDiff{RequiresNew: false},
|
|
},
|
|
},
|
|
false,
|
|
"diff RequiresNew; old: true, new: false",
|
|
},
|
|
|
|
// NewComputed on primitive
|
|
{
|
|
&InstanceDiff{
|
|
Attributes: map[string]*ResourceAttrDiff{
|
|
"foo": &ResourceAttrDiff{
|
|
Old: "",
|
|
New: "${var.foo}",
|
|
NewComputed: true,
|
|
},
|
|
},
|
|
},
|
|
&InstanceDiff{
|
|
Attributes: map[string]*ResourceAttrDiff{
|
|
"foo": &ResourceAttrDiff{
|
|
Old: "0",
|
|
New: "1",
|
|
},
|
|
},
|
|
},
|
|
true,
|
|
"",
|
|
},
|
|
|
|
// NewComputed on primitive, removed
|
|
{
|
|
&InstanceDiff{
|
|
Attributes: map[string]*ResourceAttrDiff{
|
|
"foo": &ResourceAttrDiff{
|
|
Old: "",
|
|
New: "${var.foo}",
|
|
NewComputed: true,
|
|
},
|
|
},
|
|
},
|
|
&InstanceDiff{
|
|
Attributes: map[string]*ResourceAttrDiff{},
|
|
},
|
|
true,
|
|
"",
|
|
},
|
|
|
|
// NewComputed on set, removed
|
|
{
|
|
&InstanceDiff{
|
|
Attributes: map[string]*ResourceAttrDiff{
|
|
"foo.#": &ResourceAttrDiff{
|
|
Old: "",
|
|
New: "",
|
|
NewComputed: true,
|
|
},
|
|
},
|
|
},
|
|
&InstanceDiff{
|
|
Attributes: map[string]*ResourceAttrDiff{
|
|
"foo.1": &ResourceAttrDiff{
|
|
Old: "foo",
|
|
New: "",
|
|
NewRemoved: true,
|
|
},
|
|
"foo.2": &ResourceAttrDiff{
|
|
Old: "",
|
|
New: "bar",
|
|
},
|
|
},
|
|
},
|
|
true,
|
|
"",
|
|
},
|
|
|
|
{
|
|
&InstanceDiff{
|
|
Attributes: map[string]*ResourceAttrDiff{
|
|
"foo.#": &ResourceAttrDiff{NewComputed: true},
|
|
},
|
|
},
|
|
&InstanceDiff{
|
|
Attributes: map[string]*ResourceAttrDiff{
|
|
"foo.#": &ResourceAttrDiff{
|
|
Old: "0",
|
|
New: "1",
|
|
},
|
|
"foo.0": &ResourceAttrDiff{
|
|
Old: "",
|
|
New: "12",
|
|
},
|
|
},
|
|
},
|
|
true,
|
|
"",
|
|
},
|
|
|
|
{
|
|
&InstanceDiff{
|
|
Attributes: map[string]*ResourceAttrDiff{
|
|
"foo.#": &ResourceAttrDiff{
|
|
Old: "0",
|
|
New: "1",
|
|
},
|
|
"foo.~35964334.bar": &ResourceAttrDiff{
|
|
Old: "",
|
|
New: "${var.foo}",
|
|
},
|
|
},
|
|
},
|
|
&InstanceDiff{
|
|
Attributes: map[string]*ResourceAttrDiff{
|
|
"foo.#": &ResourceAttrDiff{
|
|
Old: "0",
|
|
New: "1",
|
|
},
|
|
"foo.87654323.bar": &ResourceAttrDiff{
|
|
Old: "",
|
|
New: "12",
|
|
},
|
|
},
|
|
},
|
|
true,
|
|
"",
|
|
},
|
|
|
|
{
|
|
&InstanceDiff{
|
|
Attributes: map[string]*ResourceAttrDiff{
|
|
"foo.#": &ResourceAttrDiff{
|
|
Old: "0",
|
|
NewComputed: true,
|
|
},
|
|
},
|
|
},
|
|
&InstanceDiff{
|
|
Attributes: map[string]*ResourceAttrDiff{},
|
|
},
|
|
true,
|
|
"",
|
|
},
|
|
|
|
// Computed can change RequiresNew by removal, and that's okay
|
|
{
|
|
&InstanceDiff{
|
|
Attributes: map[string]*ResourceAttrDiff{
|
|
"foo.#": &ResourceAttrDiff{
|
|
Old: "0",
|
|
NewComputed: true,
|
|
RequiresNew: true,
|
|
},
|
|
},
|
|
},
|
|
&InstanceDiff{
|
|
Attributes: map[string]*ResourceAttrDiff{},
|
|
},
|
|
true,
|
|
"",
|
|
},
|
|
|
|
// Computed can change Destroy by removal, and that's okay
|
|
{
|
|
&InstanceDiff{
|
|
Attributes: map[string]*ResourceAttrDiff{
|
|
"foo.#": &ResourceAttrDiff{
|
|
Old: "0",
|
|
NewComputed: true,
|
|
RequiresNew: true,
|
|
},
|
|
},
|
|
|
|
Destroy: true,
|
|
},
|
|
&InstanceDiff{
|
|
Attributes: map[string]*ResourceAttrDiff{},
|
|
},
|
|
true,
|
|
"",
|
|
},
|
|
|
|
// Computed can change Destroy by elements
|
|
{
|
|
&InstanceDiff{
|
|
Attributes: map[string]*ResourceAttrDiff{
|
|
"foo.#": &ResourceAttrDiff{
|
|
Old: "0",
|
|
NewComputed: true,
|
|
RequiresNew: true,
|
|
},
|
|
},
|
|
|
|
Destroy: true,
|
|
},
|
|
&InstanceDiff{
|
|
Attributes: map[string]*ResourceAttrDiff{
|
|
"foo.#": &ResourceAttrDiff{
|
|
Old: "1",
|
|
New: "1",
|
|
},
|
|
"foo.12": &ResourceAttrDiff{
|
|
Old: "4",
|
|
New: "12",
|
|
RequiresNew: true,
|
|
},
|
|
},
|
|
|
|
Destroy: true,
|
|
},
|
|
true,
|
|
"",
|
|
},
|
|
|
|
// Computed sets may not contain all fields in the original diff, and
|
|
// because multiple entries for the same set can compute to the same
|
|
// hash before the values are computed or interpolated, the overall
|
|
// count can change as well.
|
|
{
|
|
&InstanceDiff{
|
|
Attributes: map[string]*ResourceAttrDiff{
|
|
"foo.#": &ResourceAttrDiff{
|
|
Old: "0",
|
|
New: "1",
|
|
},
|
|
"foo.~35964334.bar": &ResourceAttrDiff{
|
|
Old: "",
|
|
New: "${var.foo}",
|
|
},
|
|
},
|
|
},
|
|
&InstanceDiff{
|
|
Attributes: map[string]*ResourceAttrDiff{
|
|
"foo.#": &ResourceAttrDiff{
|
|
Old: "0",
|
|
New: "2",
|
|
},
|
|
"foo.87654323.bar": &ResourceAttrDiff{
|
|
Old: "",
|
|
New: "12",
|
|
},
|
|
"foo.87654325.bar": &ResourceAttrDiff{
|
|
Old: "",
|
|
New: "12",
|
|
},
|
|
"foo.87654325.baz": &ResourceAttrDiff{
|
|
Old: "",
|
|
New: "12",
|
|
},
|
|
},
|
|
},
|
|
true,
|
|
"",
|
|
},
|
|
|
|
// Computed values in maps will fail the "Same" check as well
|
|
{
|
|
&InstanceDiff{
|
|
Attributes: map[string]*ResourceAttrDiff{
|
|
"foo.%": &ResourceAttrDiff{
|
|
Old: "",
|
|
New: "",
|
|
NewComputed: true,
|
|
},
|
|
},
|
|
},
|
|
&InstanceDiff{
|
|
Attributes: map[string]*ResourceAttrDiff{
|
|
"foo.%": &ResourceAttrDiff{
|
|
Old: "0",
|
|
New: "1",
|
|
NewComputed: false,
|
|
},
|
|
"foo.val": &ResourceAttrDiff{
|
|
Old: "",
|
|
New: "something",
|
|
},
|
|
},
|
|
},
|
|
true,
|
|
"",
|
|
},
|
|
|
|
// In a DESTROY/CREATE scenario, the plan diff will be run against the
|
|
// state of the old instance, while the apply diff will be run against an
|
|
// empty state (because the state is cleared when the destroy runs.)
|
|
// For complex attributes, this can result in keys that seem to disappear
|
|
// between the two diffs, when in reality everything is working just fine.
|
|
//
|
|
// Same() needs to take into account this scenario by analyzing NewRemoved
|
|
// and treating as "Same" a diff that does indeed have that key removed.
|
|
{
|
|
&InstanceDiff{
|
|
Attributes: map[string]*ResourceAttrDiff{
|
|
"somemap.oldkey": &ResourceAttrDiff{
|
|
Old: "long ago",
|
|
New: "",
|
|
NewRemoved: true,
|
|
},
|
|
"somemap.newkey": &ResourceAttrDiff{
|
|
Old: "",
|
|
New: "brave new world",
|
|
},
|
|
},
|
|
},
|
|
&InstanceDiff{
|
|
Attributes: map[string]*ResourceAttrDiff{
|
|
"somemap.newkey": &ResourceAttrDiff{
|
|
Old: "",
|
|
New: "brave new world",
|
|
},
|
|
},
|
|
},
|
|
true,
|
|
"",
|
|
},
|
|
|
|
// Another thing that can occur in DESTROY/CREATE scenarios is that list
|
|
// values that are going to zero have diffs that show up at plan time but
|
|
// are gone at apply time. The NewRemoved handling catches the fields and
|
|
// treats them as OK, but it also needs to treat the .# field itself as
|
|
// okay to be present in the old diff but not in the new one.
|
|
{
|
|
&InstanceDiff{
|
|
Attributes: map[string]*ResourceAttrDiff{
|
|
"reqnew": &ResourceAttrDiff{
|
|
Old: "old",
|
|
New: "new",
|
|
RequiresNew: true,
|
|
},
|
|
"somemap.#": &ResourceAttrDiff{
|
|
Old: "1",
|
|
New: "0",
|
|
},
|
|
"somemap.oldkey": &ResourceAttrDiff{
|
|
Old: "long ago",
|
|
New: "",
|
|
NewRemoved: true,
|
|
},
|
|
},
|
|
},
|
|
&InstanceDiff{
|
|
Attributes: map[string]*ResourceAttrDiff{
|
|
"reqnew": &ResourceAttrDiff{
|
|
Old: "",
|
|
New: "new",
|
|
RequiresNew: true,
|
|
},
|
|
},
|
|
},
|
|
true,
|
|
"",
|
|
},
|
|
|
|
{
|
|
&InstanceDiff{
|
|
Attributes: map[string]*ResourceAttrDiff{
|
|
"reqnew": &ResourceAttrDiff{
|
|
Old: "old",
|
|
New: "new",
|
|
RequiresNew: true,
|
|
},
|
|
"somemap.%": &ResourceAttrDiff{
|
|
Old: "1",
|
|
New: "0",
|
|
},
|
|
"somemap.oldkey": &ResourceAttrDiff{
|
|
Old: "long ago",
|
|
New: "",
|
|
NewRemoved: true,
|
|
},
|
|
},
|
|
},
|
|
&InstanceDiff{
|
|
Attributes: map[string]*ResourceAttrDiff{
|
|
"reqnew": &ResourceAttrDiff{
|
|
Old: "",
|
|
New: "new",
|
|
RequiresNew: true,
|
|
},
|
|
},
|
|
},
|
|
true,
|
|
"",
|
|
},
|
|
|
|
// Innner computed set should allow outer change in key
|
|
{
|
|
&InstanceDiff{
|
|
Attributes: map[string]*ResourceAttrDiff{
|
|
"foo.#": &ResourceAttrDiff{
|
|
Old: "0",
|
|
New: "1",
|
|
},
|
|
"foo.~1.outer_val": &ResourceAttrDiff{
|
|
Old: "",
|
|
New: "foo",
|
|
},
|
|
"foo.~1.inner.#": &ResourceAttrDiff{
|
|
Old: "0",
|
|
New: "1",
|
|
},
|
|
"foo.~1.inner.~2.value": &ResourceAttrDiff{
|
|
Old: "",
|
|
New: "${var.bar}",
|
|
NewComputed: true,
|
|
},
|
|
},
|
|
},
|
|
&InstanceDiff{
|
|
Attributes: map[string]*ResourceAttrDiff{
|
|
"foo.#": &ResourceAttrDiff{
|
|
Old: "0",
|
|
New: "1",
|
|
},
|
|
"foo.12.outer_val": &ResourceAttrDiff{
|
|
Old: "",
|
|
New: "foo",
|
|
},
|
|
"foo.12.inner.#": &ResourceAttrDiff{
|
|
Old: "0",
|
|
New: "1",
|
|
},
|
|
"foo.12.inner.42.value": &ResourceAttrDiff{
|
|
Old: "",
|
|
New: "baz",
|
|
},
|
|
},
|
|
},
|
|
true,
|
|
"",
|
|
},
|
|
|
|
// Innner computed list should allow outer change in key
|
|
{
|
|
&InstanceDiff{
|
|
Attributes: map[string]*ResourceAttrDiff{
|
|
"foo.#": &ResourceAttrDiff{
|
|
Old: "0",
|
|
New: "1",
|
|
},
|
|
"foo.~1.outer_val": &ResourceAttrDiff{
|
|
Old: "",
|
|
New: "foo",
|
|
},
|
|
"foo.~1.inner.#": &ResourceAttrDiff{
|
|
Old: "0",
|
|
New: "1",
|
|
},
|
|
"foo.~1.inner.0.value": &ResourceAttrDiff{
|
|
Old: "",
|
|
New: "${var.bar}",
|
|
NewComputed: true,
|
|
},
|
|
},
|
|
},
|
|
&InstanceDiff{
|
|
Attributes: map[string]*ResourceAttrDiff{
|
|
"foo.#": &ResourceAttrDiff{
|
|
Old: "0",
|
|
New: "1",
|
|
},
|
|
"foo.12.outer_val": &ResourceAttrDiff{
|
|
Old: "",
|
|
New: "foo",
|
|
},
|
|
"foo.12.inner.#": &ResourceAttrDiff{
|
|
Old: "0",
|
|
New: "1",
|
|
},
|
|
"foo.12.inner.0.value": &ResourceAttrDiff{
|
|
Old: "",
|
|
New: "baz",
|
|
},
|
|
},
|
|
},
|
|
true,
|
|
"",
|
|
},
|
|
|
|
// When removing all collection items, the diff is allowed to contain
|
|
// nothing when re-creating the resource. This should be the "Same"
|
|
// since we said we were going from 1 to 0.
|
|
{
|
|
&InstanceDiff{
|
|
Attributes: map[string]*ResourceAttrDiff{
|
|
"foo.%": &ResourceAttrDiff{
|
|
Old: "1",
|
|
New: "0",
|
|
RequiresNew: true,
|
|
},
|
|
"foo.bar": &ResourceAttrDiff{
|
|
Old: "baz",
|
|
New: "",
|
|
NewRemoved: true,
|
|
RequiresNew: true,
|
|
},
|
|
},
|
|
},
|
|
&InstanceDiff{},
|
|
true,
|
|
"",
|
|
},
|
|
|
|
{
|
|
&InstanceDiff{
|
|
Attributes: map[string]*ResourceAttrDiff{
|
|
"foo.#": &ResourceAttrDiff{
|
|
Old: "1",
|
|
New: "0",
|
|
RequiresNew: true,
|
|
},
|
|
"foo.0": &ResourceAttrDiff{
|
|
Old: "baz",
|
|
New: "",
|
|
NewRemoved: true,
|
|
RequiresNew: true,
|
|
},
|
|
},
|
|
},
|
|
&InstanceDiff{},
|
|
true,
|
|
"",
|
|
},
|
|
|
|
// Make sure that DestroyTainted diffs pass as well, especially when diff
|
|
// two works off of no state.
|
|
{
|
|
&InstanceDiff{
|
|
DestroyTainted: true,
|
|
Attributes: map[string]*ResourceAttrDiff{
|
|
"foo": &ResourceAttrDiff{
|
|
Old: "foo",
|
|
New: "foo",
|
|
},
|
|
},
|
|
},
|
|
&InstanceDiff{
|
|
DestroyTainted: true,
|
|
Attributes: map[string]*ResourceAttrDiff{
|
|
"foo": &ResourceAttrDiff{
|
|
Old: "",
|
|
New: "foo",
|
|
},
|
|
},
|
|
},
|
|
true,
|
|
"",
|
|
},
|
|
// RequiresNew in different attribute
|
|
{
|
|
&InstanceDiff{
|
|
Attributes: map[string]*ResourceAttrDiff{
|
|
"foo": &ResourceAttrDiff{
|
|
Old: "foo",
|
|
New: "foo",
|
|
},
|
|
"bar": &ResourceAttrDiff{
|
|
Old: "bar",
|
|
New: "baz",
|
|
RequiresNew: true,
|
|
},
|
|
},
|
|
},
|
|
&InstanceDiff{
|
|
Attributes: map[string]*ResourceAttrDiff{
|
|
"foo": &ResourceAttrDiff{
|
|
Old: "",
|
|
New: "foo",
|
|
},
|
|
"bar": &ResourceAttrDiff{
|
|
Old: "",
|
|
New: "baz",
|
|
RequiresNew: true,
|
|
},
|
|
},
|
|
},
|
|
true,
|
|
"",
|
|
},
|
|
}
|
|
|
|
for i, tc := range cases {
|
|
t.Run(fmt.Sprintf("%d", i), func(t *testing.T) {
|
|
same, reason := tc.One.Same(tc.Two)
|
|
if same != tc.Same {
|
|
t.Fatalf("%d: expected same: %t, got %t (%s)\n\n one: %#v\n\ntwo: %#v",
|
|
i, tc.Same, same, reason, tc.One, tc.Two)
|
|
}
|
|
if reason != tc.Reason {
|
|
t.Fatalf(
|
|
"%d: bad reason\n\nexpected: %#v\n\ngot: %#v", i, tc.Reason, reason)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
const moduleDiffStrBasic = `
|
|
CREATE: nodeA
|
|
bar: "foo" => "<computed>"
|
|
foo: "foo" => "bar"
|
|
longfoo: "foo" => "bar" (forces new resource)
|
|
secretfoo: "<sensitive>" => "<sensitive>" (attribute changed)
|
|
`
|
|
|
|
func TestCountFlatmapContainerValues(t *testing.T) {
|
|
for i, tc := range []struct {
|
|
attrs map[string]string
|
|
key string
|
|
count string
|
|
}{
|
|
{
|
|
attrs: map[string]string{"set.2.list.#": "9999", "set.2.list.0": "x", "set.2.list.0.z": "y", "set.2.attr": "bar", "set.#": "9999"},
|
|
key: "set.2.list.#",
|
|
count: "1",
|
|
},
|
|
{
|
|
attrs: map[string]string{"set.2.list.#": "9999", "set.2.list.0": "x", "set.2.list.0.z": "y", "set.2.attr": "bar", "set.#": "9999"},
|
|
key: "set.#",
|
|
count: "1",
|
|
},
|
|
{
|
|
attrs: map[string]string{"set.2.list.0": "x", "set.2.list.0.z": "y", "set.2.attr": "bar", "set.#": "9999"},
|
|
key: "set.#",
|
|
count: "1",
|
|
},
|
|
{
|
|
attrs: map[string]string{"map.#": "3", "map.a": "b", "map.a.#": "0", "map.b": "4"},
|
|
key: "map.#",
|
|
count: "2",
|
|
},
|
|
} {
|
|
t.Run(strconv.Itoa(i), func(t *testing.T) {
|
|
count := countFlatmapContainerValues(tc.key, tc.attrs)
|
|
if count != tc.count {
|
|
t.Fatalf("expected %q, got %q", tc.count, count)
|
|
}
|
|
})
|
|
}
|
|
}
|