github.com/ns1/terraform@v0.7.10-0.20161109153551-8949419bef40/terraform/transform_destroy_test.go (about)

     1  package terraform
     2  
     3  import (
     4  	"strings"
     5  	"testing"
     6  )
     7  
     8  func TestDestroyTransformer(t *testing.T) {
     9  	mod := testModule(t, "transform-destroy-basic")
    10  
    11  	g := Graph{Path: RootModulePath}
    12  	{
    13  		tf := &ConfigTransformer{Module: mod}
    14  		if err := tf.Transform(&g); err != nil {
    15  			t.Fatalf("err: %s", err)
    16  		}
    17  	}
    18  
    19  	{
    20  		tf := &DestroyTransformer{}
    21  		if err := tf.Transform(&g); err != nil {
    22  			t.Fatalf("err: %s", err)
    23  		}
    24  	}
    25  
    26  	actual := strings.TrimSpace(g.String())
    27  	expected := strings.TrimSpace(testTransformDestroyBasicStr)
    28  	if actual != expected {
    29  		t.Fatalf("bad:\n\n%s", actual)
    30  	}
    31  }
    32  
    33  func TestDestroyTransformer_dependsOn(t *testing.T) {
    34  	mod := testModule(t, "transform-destroy-depends-on")
    35  
    36  	g := Graph{Path: RootModulePath}
    37  	{
    38  		tf := &ConfigTransformer{Module: mod}
    39  		if err := tf.Transform(&g); err != nil {
    40  			t.Fatalf("err: %s", err)
    41  		}
    42  	}
    43  
    44  	{
    45  		tf := &DestroyTransformer{}
    46  		if err := tf.Transform(&g); err != nil {
    47  			t.Fatalf("err: %s", err)
    48  		}
    49  	}
    50  
    51  	actual := strings.TrimSpace(g.String())
    52  	expected := strings.TrimSpace(testTransformDestroyBasicStr)
    53  	if actual != expected {
    54  		t.Fatalf("bad:\n\n%s", actual)
    55  	}
    56  }
    57  
    58  func TestCreateBeforeDestroyTransformer(t *testing.T) {
    59  	mod := testModule(t, "transform-create-before-destroy-basic")
    60  
    61  	g := Graph{Path: RootModulePath}
    62  	{
    63  		tf := &ConfigTransformer{Module: mod}
    64  		if err := tf.Transform(&g); err != nil {
    65  			t.Fatalf("err: %s", err)
    66  		}
    67  	}
    68  
    69  	{
    70  		tf := &DestroyTransformer{}
    71  		if err := tf.Transform(&g); err != nil {
    72  			t.Fatalf("err: %s", err)
    73  		}
    74  	}
    75  
    76  	{
    77  		tf := &CreateBeforeDestroyTransformer{}
    78  		if err := tf.Transform(&g); err != nil {
    79  			t.Fatalf("err: %s", err)
    80  		}
    81  	}
    82  
    83  	actual := strings.TrimSpace(g.String())
    84  	expected := strings.TrimSpace(testTransformCreateBeforeDestroyBasicStr)
    85  	if actual != expected {
    86  		t.Fatalf("bad:\n\n%s", actual)
    87  	}
    88  }
    89  
    90  func TestCreateBeforeDestroyTransformer_twice(t *testing.T) {
    91  	mod := testModule(t, "transform-create-before-destroy-twice")
    92  
    93  	g := Graph{Path: RootModulePath}
    94  	{
    95  		tf := &ConfigTransformer{Module: mod}
    96  		if err := tf.Transform(&g); err != nil {
    97  			t.Fatalf("err: %s", err)
    98  		}
    99  	}
   100  
   101  	{
   102  		tf := &DestroyTransformer{}
   103  		if err := tf.Transform(&g); err != nil {
   104  			t.Fatalf("err: %s", err)
   105  		}
   106  	}
   107  
   108  	{
   109  		tf := &CreateBeforeDestroyTransformer{}
   110  		if err := tf.Transform(&g); err != nil {
   111  			t.Fatalf("err: %s", err)
   112  		}
   113  	}
   114  
   115  	actual := strings.TrimSpace(g.String())
   116  	expected := strings.TrimSpace(testTransformCreateBeforeDestroyTwiceStr)
   117  	if actual != expected {
   118  		t.Fatalf("bad:\n\n%s", actual)
   119  	}
   120  }
   121  
   122  func TestPruneDestroyTransformer(t *testing.T) {
   123  	var diff *Diff
   124  	mod := testModule(t, "transform-destroy-basic")
   125  
   126  	g := Graph{Path: RootModulePath}
   127  	{
   128  		tf := &ConfigTransformer{Module: mod}
   129  		if err := tf.Transform(&g); err != nil {
   130  			t.Fatalf("err: %s", err)
   131  		}
   132  	}
   133  
   134  	{
   135  		tf := &DestroyTransformer{}
   136  		if err := tf.Transform(&g); err != nil {
   137  			t.Fatalf("err: %s", err)
   138  		}
   139  	}
   140  
   141  	{
   142  		tf := &PruneDestroyTransformer{Diff: diff}
   143  		if err := tf.Transform(&g); err != nil {
   144  			t.Fatalf("err: %s", err)
   145  		}
   146  	}
   147  
   148  	actual := strings.TrimSpace(g.String())
   149  	expected := strings.TrimSpace(testTransformPruneDestroyBasicStr)
   150  	if actual != expected {
   151  		t.Fatalf("bad:\n\n%s", actual)
   152  	}
   153  }
   154  
   155  func TestPruneDestroyTransformer_diff(t *testing.T) {
   156  	mod := testModule(t, "transform-destroy-basic")
   157  
   158  	diff := &Diff{
   159  		Modules: []*ModuleDiff{
   160  			&ModuleDiff{
   161  				Path: RootModulePath,
   162  				Resources: map[string]*InstanceDiff{
   163  					"aws_instance.bar": &InstanceDiff{},
   164  				},
   165  			},
   166  		},
   167  	}
   168  
   169  	g := Graph{Path: RootModulePath}
   170  	{
   171  		tf := &ConfigTransformer{Module: mod}
   172  		if err := tf.Transform(&g); err != nil {
   173  			t.Fatalf("err: %s", err)
   174  		}
   175  	}
   176  
   177  	{
   178  		tf := &DestroyTransformer{}
   179  		if err := tf.Transform(&g); err != nil {
   180  			t.Fatalf("err: %s", err)
   181  		}
   182  	}
   183  
   184  	{
   185  		tf := &PruneDestroyTransformer{Diff: diff}
   186  		if err := tf.Transform(&g); err != nil {
   187  			t.Fatalf("err: %s", err)
   188  		}
   189  	}
   190  
   191  	actual := strings.TrimSpace(g.String())
   192  	expected := strings.TrimSpace(testTransformPruneDestroyBasicDiffStr)
   193  	if actual != expected {
   194  		t.Fatalf("expected:\n\n%s\n\nbad:\n\n%s", expected, actual)
   195  	}
   196  }
   197  
   198  func TestPruneDestroyTransformer_count(t *testing.T) {
   199  	mod := testModule(t, "transform-destroy-prune-count")
   200  
   201  	diff := &Diff{}
   202  
   203  	g := Graph{Path: RootModulePath}
   204  	{
   205  		tf := &ConfigTransformer{Module: mod}
   206  		if err := tf.Transform(&g); err != nil {
   207  			t.Fatalf("err: %s", err)
   208  		}
   209  	}
   210  
   211  	{
   212  		tf := &DestroyTransformer{}
   213  		if err := tf.Transform(&g); err != nil {
   214  			t.Fatalf("err: %s", err)
   215  		}
   216  	}
   217  
   218  	{
   219  		tf := &PruneDestroyTransformer{Diff: diff}
   220  		if err := tf.Transform(&g); err != nil {
   221  			t.Fatalf("err: %s", err)
   222  		}
   223  	}
   224  
   225  	actual := strings.TrimSpace(g.String())
   226  	expected := strings.TrimSpace(testTransformPruneDestroyCountStr)
   227  	if actual != expected {
   228  		t.Fatalf("bad:\n\n%s", actual)
   229  	}
   230  }
   231  
   232  func TestPruneDestroyTransformer_countDec(t *testing.T) {
   233  	mod := testModule(t, "transform-destroy-basic")
   234  
   235  	diff := &Diff{}
   236  	state := &State{
   237  		Modules: []*ModuleState{
   238  			&ModuleState{
   239  				Path: RootModulePath,
   240  				Resources: map[string]*ResourceState{
   241  					"aws_instance.bar.1": &ResourceState{
   242  						Primary: &InstanceState{},
   243  					},
   244  					"aws_instance.bar.2": &ResourceState{
   245  						Primary: &InstanceState{},
   246  					},
   247  				},
   248  			},
   249  		},
   250  	}
   251  
   252  	g := Graph{Path: RootModulePath}
   253  	{
   254  		tf := &ConfigTransformer{Module: mod}
   255  		if err := tf.Transform(&g); err != nil {
   256  			t.Fatalf("err: %s", err)
   257  		}
   258  	}
   259  
   260  	{
   261  		tf := &DestroyTransformer{}
   262  		if err := tf.Transform(&g); err != nil {
   263  			t.Fatalf("err: %s", err)
   264  		}
   265  	}
   266  
   267  	{
   268  		tf := &PruneDestroyTransformer{Diff: diff, State: state}
   269  		if err := tf.Transform(&g); err != nil {
   270  			t.Fatalf("err: %s", err)
   271  		}
   272  	}
   273  
   274  	actual := strings.TrimSpace(g.String())
   275  	expected := strings.TrimSpace(testTransformPruneDestroyCountDecStr)
   276  	if actual != expected {
   277  		t.Fatalf("bad:\n\n%s", actual)
   278  	}
   279  }
   280  
   281  func TestPruneDestroyTransformer_countState(t *testing.T) {
   282  	mod := testModule(t, "transform-destroy-basic")
   283  
   284  	diff := &Diff{}
   285  	state := &State{
   286  		Modules: []*ModuleState{
   287  			&ModuleState{
   288  				Path: RootModulePath,
   289  				Resources: map[string]*ResourceState{
   290  					"aws_instance.bar": &ResourceState{
   291  						Primary: &InstanceState{},
   292  					},
   293  				},
   294  			},
   295  		},
   296  	}
   297  
   298  	g := Graph{Path: RootModulePath}
   299  	{
   300  		tf := &ConfigTransformer{Module: mod}
   301  		if err := tf.Transform(&g); err != nil {
   302  			t.Fatalf("err: %s", err)
   303  		}
   304  	}
   305  
   306  	{
   307  		tf := &DestroyTransformer{}
   308  		if err := tf.Transform(&g); err != nil {
   309  			t.Fatalf("err: %s", err)
   310  		}
   311  	}
   312  
   313  	{
   314  		tf := &PruneDestroyTransformer{Diff: diff, State: state}
   315  		if err := tf.Transform(&g); err != nil {
   316  			t.Fatalf("err: %s", err)
   317  		}
   318  	}
   319  
   320  	actual := strings.TrimSpace(g.String())
   321  	expected := strings.TrimSpace(testTransformPruneDestroyCountStateStr)
   322  	if actual != expected {
   323  		t.Fatalf("bad:\n\n%s", actual)
   324  	}
   325  }
   326  
   327  func TestPruneDestroyTransformer_prefixMatch(t *testing.T) {
   328  	mod := testModule(t, "transform-destroy-prefix")
   329  
   330  	diff := &Diff{}
   331  	state := &State{
   332  		Modules: []*ModuleState{
   333  			&ModuleState{
   334  				Path: RootModulePath,
   335  				Resources: map[string]*ResourceState{
   336  					"aws_instance.foo-bar.0": &ResourceState{
   337  						Primary: &InstanceState{ID: "foo"},
   338  					},
   339  
   340  					"aws_instance.foo-bar.1": &ResourceState{
   341  						Primary: &InstanceState{ID: "foo"},
   342  					},
   343  				},
   344  			},
   345  		},
   346  	}
   347  
   348  	g := Graph{Path: RootModulePath}
   349  	{
   350  		tf := &ConfigTransformer{Module: mod}
   351  		if err := tf.Transform(&g); err != nil {
   352  			t.Fatalf("err: %s", err)
   353  		}
   354  	}
   355  
   356  	{
   357  		tf := &DestroyTransformer{}
   358  		if err := tf.Transform(&g); err != nil {
   359  			t.Fatalf("err: %s", err)
   360  		}
   361  	}
   362  
   363  	{
   364  		tf := &PruneDestroyTransformer{Diff: diff, State: state}
   365  		if err := tf.Transform(&g); err != nil {
   366  			t.Fatalf("err: %s", err)
   367  		}
   368  	}
   369  
   370  	actual := strings.TrimSpace(g.String())
   371  	expected := strings.TrimSpace(testTransformPruneDestroyPrefixStr)
   372  	if actual != expected {
   373  		t.Fatalf("bad:\n\n%s", actual)
   374  	}
   375  }
   376  
   377  func TestPruneDestroyTransformer_tainted(t *testing.T) {
   378  	mod := testModule(t, "transform-destroy-basic")
   379  
   380  	diff := &Diff{}
   381  	state := &State{
   382  		Modules: []*ModuleState{
   383  			&ModuleState{
   384  				Path: RootModulePath,
   385  				Resources: map[string]*ResourceState{
   386  					"aws_instance.bar": &ResourceState{
   387  						Primary: &InstanceState{
   388  							ID:      "foo",
   389  							Tainted: true,
   390  						},
   391  					},
   392  				},
   393  			},
   394  		},
   395  	}
   396  
   397  	g := Graph{Path: RootModulePath}
   398  	{
   399  		tf := &ConfigTransformer{Module: mod}
   400  		if err := tf.Transform(&g); err != nil {
   401  			t.Fatalf("err: %s", err)
   402  		}
   403  	}
   404  
   405  	{
   406  		tf := &DestroyTransformer{}
   407  		if err := tf.Transform(&g); err != nil {
   408  			t.Fatalf("err: %s", err)
   409  		}
   410  	}
   411  
   412  	{
   413  		tf := &PruneDestroyTransformer{Diff: diff, State: state}
   414  		if err := tf.Transform(&g); err != nil {
   415  			t.Fatalf("err: %s", err)
   416  		}
   417  	}
   418  
   419  	actual := strings.TrimSpace(g.String())
   420  	expected := strings.TrimSpace(testTransformPruneDestroyTaintedStr)
   421  	if actual != expected {
   422  		t.Fatalf("bad:\n\n%s", actual)
   423  	}
   424  }
   425  
   426  const testTransformDestroyBasicStr = `
   427  aws_instance.bar
   428    aws_instance.bar (destroy)
   429    aws_instance.foo
   430  aws_instance.bar (destroy)
   431  aws_instance.foo
   432    aws_instance.foo (destroy)
   433  aws_instance.foo (destroy)
   434    aws_instance.bar (destroy)
   435  `
   436  
   437  const testTransformPruneDestroyBasicStr = `
   438  aws_instance.bar
   439    aws_instance.foo
   440  aws_instance.foo
   441  `
   442  
   443  const testTransformPruneDestroyBasicDiffStr = `
   444  aws_instance.bar
   445    aws_instance.foo
   446  aws_instance.foo
   447  `
   448  
   449  const testTransformPruneDestroyCountStr = `
   450  aws_instance.bar
   451    aws_instance.bar (destroy)
   452    aws_instance.foo
   453  aws_instance.bar (destroy)
   454  aws_instance.foo
   455  `
   456  
   457  const testTransformPruneDestroyCountDecStr = `
   458  aws_instance.bar
   459    aws_instance.bar (destroy)
   460    aws_instance.foo
   461  aws_instance.bar (destroy)
   462  aws_instance.foo
   463  `
   464  
   465  const testTransformPruneDestroyCountStateStr = `
   466  aws_instance.bar
   467    aws_instance.foo
   468  aws_instance.foo
   469  `
   470  
   471  const testTransformPruneDestroyPrefixStr = `
   472  aws_instance.foo
   473  aws_instance.foo-bar
   474    aws_instance.foo-bar (destroy)
   475  aws_instance.foo-bar (destroy)
   476  `
   477  
   478  const testTransformPruneDestroyTaintedStr = `
   479  aws_instance.bar
   480    aws_instance.foo
   481  aws_instance.foo
   482  `
   483  
   484  const testTransformCreateBeforeDestroyBasicStr = `
   485  aws_instance.web
   486  aws_instance.web (destroy)
   487    aws_instance.web
   488    aws_load_balancer.lb
   489    aws_load_balancer.lb (destroy)
   490  aws_load_balancer.lb
   491    aws_instance.web
   492    aws_load_balancer.lb (destroy)
   493  aws_load_balancer.lb (destroy)
   494  `
   495  
   496  const testTransformCreateBeforeDestroyTwiceStr = `
   497  aws_autoscale.bar
   498    aws_lc.foo
   499  aws_autoscale.bar (destroy)
   500    aws_autoscale.bar
   501  aws_lc.foo
   502  aws_lc.foo (destroy)
   503    aws_autoscale.bar
   504    aws_autoscale.bar (destroy)
   505    aws_lc.foo
   506  `