github.com/rstandt/terraform@v0.12.32-0.20230710220336-b1063613405c/backend/local/hook_count_test.go (about)

     1  package local
     2  
     3  import (
     4  	"reflect"
     5  	"testing"
     6  
     7  	"github.com/zclconf/go-cty/cty"
     8  
     9  	"github.com/hashicorp/terraform/addrs"
    10  	"github.com/hashicorp/terraform/plans"
    11  	"github.com/hashicorp/terraform/states"
    12  	"github.com/hashicorp/terraform/terraform"
    13  )
    14  
    15  func TestCountHook_impl(t *testing.T) {
    16  	var _ terraform.Hook = new(CountHook)
    17  }
    18  
    19  func TestCountHookPostDiff_DestroyDeposed(t *testing.T) {
    20  	h := new(CountHook)
    21  
    22  	resources := map[string]*terraform.InstanceDiff{
    23  		"lorem": &terraform.InstanceDiff{DestroyDeposed: true},
    24  	}
    25  
    26  	for k := range resources {
    27  		addr := addrs.Resource{
    28  			Mode: addrs.ManagedResourceMode,
    29  			Type: "test_instance",
    30  			Name: k,
    31  		}.Instance(addrs.NoKey).Absolute(addrs.RootModuleInstance)
    32  
    33  		h.PostDiff(addr, states.DeposedKey("deadbeef"), plans.Delete, cty.DynamicVal, cty.DynamicVal)
    34  	}
    35  
    36  	expected := new(CountHook)
    37  	expected.ToAdd = 0
    38  	expected.ToChange = 0
    39  	expected.ToRemoveAndAdd = 0
    40  	expected.ToRemove = 1
    41  
    42  	if !reflect.DeepEqual(expected, h) {
    43  		t.Fatalf("Expected %#v, got %#v instead.", expected, h)
    44  	}
    45  }
    46  
    47  func TestCountHookPostDiff_DestroyOnly(t *testing.T) {
    48  	h := new(CountHook)
    49  
    50  	resources := map[string]*terraform.InstanceDiff{
    51  		"foo":   &terraform.InstanceDiff{Destroy: true},
    52  		"bar":   &terraform.InstanceDiff{Destroy: true},
    53  		"lorem": &terraform.InstanceDiff{Destroy: true},
    54  		"ipsum": &terraform.InstanceDiff{Destroy: true},
    55  	}
    56  
    57  	for k := range resources {
    58  		addr := addrs.Resource{
    59  			Mode: addrs.ManagedResourceMode,
    60  			Type: "test_instance",
    61  			Name: k,
    62  		}.Instance(addrs.NoKey).Absolute(addrs.RootModuleInstance)
    63  
    64  		h.PostDiff(addr, states.CurrentGen, plans.Delete, cty.DynamicVal, cty.DynamicVal)
    65  	}
    66  
    67  	expected := new(CountHook)
    68  	expected.ToAdd = 0
    69  	expected.ToChange = 0
    70  	expected.ToRemoveAndAdd = 0
    71  	expected.ToRemove = 4
    72  
    73  	if !reflect.DeepEqual(expected, h) {
    74  		t.Fatalf("Expected %#v, got %#v instead.", expected, h)
    75  	}
    76  }
    77  
    78  func TestCountHookPostDiff_AddOnly(t *testing.T) {
    79  	h := new(CountHook)
    80  
    81  	resources := map[string]*terraform.InstanceDiff{
    82  		"foo": &terraform.InstanceDiff{
    83  			Attributes: map[string]*terraform.ResourceAttrDiff{
    84  				"foo": &terraform.ResourceAttrDiff{RequiresNew: true},
    85  			},
    86  		},
    87  		"bar": &terraform.InstanceDiff{
    88  			Attributes: map[string]*terraform.ResourceAttrDiff{
    89  				"foo": &terraform.ResourceAttrDiff{RequiresNew: true},
    90  			},
    91  		},
    92  		"lorem": &terraform.InstanceDiff{
    93  			Attributes: map[string]*terraform.ResourceAttrDiff{
    94  				"foo": &terraform.ResourceAttrDiff{RequiresNew: true},
    95  			},
    96  		},
    97  	}
    98  
    99  	for k := range resources {
   100  		addr := addrs.Resource{
   101  			Mode: addrs.ManagedResourceMode,
   102  			Type: "test_instance",
   103  			Name: k,
   104  		}.Instance(addrs.NoKey).Absolute(addrs.RootModuleInstance)
   105  
   106  		h.PostDiff(addr, states.CurrentGen, plans.Create, cty.DynamicVal, cty.DynamicVal)
   107  	}
   108  
   109  	expected := new(CountHook)
   110  	expected.ToAdd = 3
   111  	expected.ToChange = 0
   112  	expected.ToRemoveAndAdd = 0
   113  	expected.ToRemove = 0
   114  
   115  	if !reflect.DeepEqual(expected, h) {
   116  		t.Fatalf("Expected %#v, got %#v instead.", expected, h)
   117  	}
   118  }
   119  
   120  func TestCountHookPostDiff_ChangeOnly(t *testing.T) {
   121  	h := new(CountHook)
   122  
   123  	resources := map[string]*terraform.InstanceDiff{
   124  		"foo": &terraform.InstanceDiff{
   125  			Destroy: false,
   126  			Attributes: map[string]*terraform.ResourceAttrDiff{
   127  				"foo": &terraform.ResourceAttrDiff{},
   128  			},
   129  		},
   130  		"bar": &terraform.InstanceDiff{
   131  			Destroy: false,
   132  			Attributes: map[string]*terraform.ResourceAttrDiff{
   133  				"foo": &terraform.ResourceAttrDiff{},
   134  			},
   135  		},
   136  		"lorem": &terraform.InstanceDiff{
   137  			Destroy: false,
   138  			Attributes: map[string]*terraform.ResourceAttrDiff{
   139  				"foo": &terraform.ResourceAttrDiff{},
   140  			},
   141  		},
   142  	}
   143  
   144  	for k := range resources {
   145  		addr := addrs.Resource{
   146  			Mode: addrs.ManagedResourceMode,
   147  			Type: "test_instance",
   148  			Name: k,
   149  		}.Instance(addrs.NoKey).Absolute(addrs.RootModuleInstance)
   150  
   151  		h.PostDiff(addr, states.CurrentGen, plans.Update, cty.DynamicVal, cty.DynamicVal)
   152  	}
   153  
   154  	expected := new(CountHook)
   155  	expected.ToAdd = 0
   156  	expected.ToChange = 3
   157  	expected.ToRemoveAndAdd = 0
   158  	expected.ToRemove = 0
   159  
   160  	if !reflect.DeepEqual(expected, h) {
   161  		t.Fatalf("Expected %#v, got %#v instead.", expected, h)
   162  	}
   163  }
   164  
   165  func TestCountHookPostDiff_Mixed(t *testing.T) {
   166  	h := new(CountHook)
   167  
   168  	resources := map[string]plans.Action{
   169  		"foo":   plans.Delete,
   170  		"bar":   plans.NoOp,
   171  		"lorem": plans.Update,
   172  		"ipsum": plans.Delete,
   173  	}
   174  
   175  	for k, a := range resources {
   176  		addr := addrs.Resource{
   177  			Mode: addrs.ManagedResourceMode,
   178  			Type: "test_instance",
   179  			Name: k,
   180  		}.Instance(addrs.NoKey).Absolute(addrs.RootModuleInstance)
   181  
   182  		h.PostDiff(addr, states.CurrentGen, a, cty.DynamicVal, cty.DynamicVal)
   183  	}
   184  
   185  	expected := new(CountHook)
   186  	expected.ToAdd = 0
   187  	expected.ToChange = 1
   188  	expected.ToRemoveAndAdd = 0
   189  	expected.ToRemove = 2
   190  
   191  	if !reflect.DeepEqual(expected, h) {
   192  		t.Fatalf("Expected %#v, got %#v instead.",
   193  			expected, h)
   194  	}
   195  }
   196  
   197  func TestCountHookPostDiff_NoChange(t *testing.T) {
   198  	h := new(CountHook)
   199  
   200  	resources := map[string]*terraform.InstanceDiff{
   201  		"foo":   &terraform.InstanceDiff{},
   202  		"bar":   &terraform.InstanceDiff{},
   203  		"lorem": &terraform.InstanceDiff{},
   204  		"ipsum": &terraform.InstanceDiff{},
   205  	}
   206  
   207  	for k := range resources {
   208  		addr := addrs.Resource{
   209  			Mode: addrs.ManagedResourceMode,
   210  			Type: "test_instance",
   211  			Name: k,
   212  		}.Instance(addrs.NoKey).Absolute(addrs.RootModuleInstance)
   213  
   214  		h.PostDiff(addr, states.CurrentGen, plans.NoOp, cty.DynamicVal, cty.DynamicVal)
   215  	}
   216  
   217  	expected := new(CountHook)
   218  	expected.ToAdd = 0
   219  	expected.ToChange = 0
   220  	expected.ToRemoveAndAdd = 0
   221  	expected.ToRemove = 0
   222  
   223  	if !reflect.DeepEqual(expected, h) {
   224  		t.Fatalf("Expected %#v, got %#v instead.",
   225  			expected, h)
   226  	}
   227  }
   228  
   229  func TestCountHookPostDiff_DataSource(t *testing.T) {
   230  	h := new(CountHook)
   231  
   232  	resources := map[string]plans.Action{
   233  		"foo":   plans.Delete,
   234  		"bar":   plans.NoOp,
   235  		"lorem": plans.Update,
   236  		"ipsum": plans.Delete,
   237  	}
   238  
   239  	for k, a := range resources {
   240  		addr := addrs.Resource{
   241  			Mode: addrs.DataResourceMode,
   242  			Type: "test_instance",
   243  			Name: k,
   244  		}.Instance(addrs.NoKey).Absolute(addrs.RootModuleInstance)
   245  
   246  		h.PostDiff(addr, states.CurrentGen, a, cty.DynamicVal, cty.DynamicVal)
   247  	}
   248  
   249  	expected := new(CountHook)
   250  	expected.ToAdd = 0
   251  	expected.ToChange = 0
   252  	expected.ToRemoveAndAdd = 0
   253  	expected.ToRemove = 0
   254  
   255  	if !reflect.DeepEqual(expected, h) {
   256  		t.Fatalf("Expected %#v, got %#v instead.",
   257  			expected, h)
   258  	}
   259  }
   260  
   261  func TestCountHookApply_ChangeOnly(t *testing.T) {
   262  	h := new(CountHook)
   263  
   264  	resources := map[string]*terraform.InstanceDiff{
   265  		"foo": &terraform.InstanceDiff{
   266  			Destroy: false,
   267  			Attributes: map[string]*terraform.ResourceAttrDiff{
   268  				"foo": &terraform.ResourceAttrDiff{},
   269  			},
   270  		},
   271  		"bar": &terraform.InstanceDiff{
   272  			Destroy: false,
   273  			Attributes: map[string]*terraform.ResourceAttrDiff{
   274  				"foo": &terraform.ResourceAttrDiff{},
   275  			},
   276  		},
   277  		"lorem": &terraform.InstanceDiff{
   278  			Destroy: false,
   279  			Attributes: map[string]*terraform.ResourceAttrDiff{
   280  				"foo": &terraform.ResourceAttrDiff{},
   281  			},
   282  		},
   283  	}
   284  
   285  	for k := range resources {
   286  		addr := addrs.Resource{
   287  			Mode: addrs.ManagedResourceMode,
   288  			Type: "test_instance",
   289  			Name: k,
   290  		}.Instance(addrs.NoKey).Absolute(addrs.RootModuleInstance)
   291  
   292  		h.PreApply(addr, states.CurrentGen, plans.Update, cty.DynamicVal, cty.DynamicVal)
   293  		h.PostApply(addr, states.CurrentGen, cty.DynamicVal, nil)
   294  	}
   295  
   296  	expected := &CountHook{pending: make(map[string]plans.Action)}
   297  	expected.Added = 0
   298  	expected.Changed = 3
   299  	expected.Removed = 0
   300  
   301  	if !reflect.DeepEqual(expected, h) {
   302  		t.Fatalf("Expected:\n%#v\nGot:\n%#v\n", expected, h)
   303  	}
   304  }
   305  
   306  func TestCountHookApply_DestroyOnly(t *testing.T) {
   307  	h := new(CountHook)
   308  
   309  	resources := map[string]*terraform.InstanceDiff{
   310  		"foo":   &terraform.InstanceDiff{Destroy: true},
   311  		"bar":   &terraform.InstanceDiff{Destroy: true},
   312  		"lorem": &terraform.InstanceDiff{Destroy: true},
   313  		"ipsum": &terraform.InstanceDiff{Destroy: true},
   314  	}
   315  
   316  	for k := range resources {
   317  		addr := addrs.Resource{
   318  			Mode: addrs.ManagedResourceMode,
   319  			Type: "test_instance",
   320  			Name: k,
   321  		}.Instance(addrs.NoKey).Absolute(addrs.RootModuleInstance)
   322  
   323  		h.PreApply(addr, states.CurrentGen, plans.Delete, cty.DynamicVal, cty.DynamicVal)
   324  		h.PostApply(addr, states.CurrentGen, cty.DynamicVal, nil)
   325  	}
   326  
   327  	expected := &CountHook{pending: make(map[string]plans.Action)}
   328  	expected.Added = 0
   329  	expected.Changed = 0
   330  	expected.Removed = 4
   331  
   332  	if !reflect.DeepEqual(expected, h) {
   333  		t.Fatalf("Expected:\n%#v\nGot:\n%#v\n", expected, h)
   334  	}
   335  }