github.com/rmenn/terraform@v0.3.8-0.20150225065417-fc84b3a78802/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 TestCreateBeforeDestroyTransformer(t *testing.T) {
    34  	mod := testModule(t, "transform-create-before-destroy-basic")
    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  	{
    52  		tf := &CreateBeforeDestroyTransformer{}
    53  		if err := tf.Transform(&g); err != nil {
    54  			t.Fatalf("err: %s", err)
    55  		}
    56  	}
    57  
    58  	actual := strings.TrimSpace(g.String())
    59  	expected := strings.TrimSpace(testTransformCreateBeforeDestroyBasicStr)
    60  	if actual != expected {
    61  		t.Fatalf("bad:\n\n%s", actual)
    62  	}
    63  }
    64  
    65  func TestCreateBeforeDestroyTransformer_twice(t *testing.T) {
    66  	mod := testModule(t, "transform-create-before-destroy-twice")
    67  
    68  	g := Graph{Path: RootModulePath}
    69  	{
    70  		tf := &ConfigTransformer{Module: mod}
    71  		if err := tf.Transform(&g); err != nil {
    72  			t.Fatalf("err: %s", err)
    73  		}
    74  	}
    75  
    76  	{
    77  		tf := &DestroyTransformer{}
    78  		if err := tf.Transform(&g); err != nil {
    79  			t.Fatalf("err: %s", err)
    80  		}
    81  	}
    82  
    83  	{
    84  		tf := &CreateBeforeDestroyTransformer{}
    85  		if err := tf.Transform(&g); err != nil {
    86  			t.Fatalf("err: %s", err)
    87  		}
    88  	}
    89  
    90  	actual := strings.TrimSpace(g.String())
    91  	expected := strings.TrimSpace(testTransformCreateBeforeDestroyTwiceStr)
    92  	if actual != expected {
    93  		t.Fatalf("bad:\n\n%s", actual)
    94  	}
    95  }
    96  
    97  func TestPruneDestroyTransformer(t *testing.T) {
    98  	var diff *Diff
    99  	mod := testModule(t, "transform-destroy-basic")
   100  
   101  	g := Graph{Path: RootModulePath}
   102  	{
   103  		tf := &ConfigTransformer{Module: mod}
   104  		if err := tf.Transform(&g); err != nil {
   105  			t.Fatalf("err: %s", err)
   106  		}
   107  	}
   108  
   109  	{
   110  		tf := &DestroyTransformer{}
   111  		if err := tf.Transform(&g); err != nil {
   112  			t.Fatalf("err: %s", err)
   113  		}
   114  	}
   115  
   116  	{
   117  		tf := &PruneDestroyTransformer{Diff: diff}
   118  		if err := tf.Transform(&g); err != nil {
   119  			t.Fatalf("err: %s", err)
   120  		}
   121  	}
   122  
   123  	actual := strings.TrimSpace(g.String())
   124  	expected := strings.TrimSpace(testTransformPruneDestroyBasicStr)
   125  	if actual != expected {
   126  		t.Fatalf("bad:\n\n%s", actual)
   127  	}
   128  }
   129  
   130  func TestPruneDestroyTransformer_diff(t *testing.T) {
   131  	mod := testModule(t, "transform-destroy-basic")
   132  
   133  	diff := &Diff{
   134  		Modules: []*ModuleDiff{
   135  			&ModuleDiff{
   136  				Path: RootModulePath,
   137  				Resources: map[string]*InstanceDiff{
   138  					"aws_instance.bar": &InstanceDiff{},
   139  				},
   140  			},
   141  		},
   142  	}
   143  
   144  	g := Graph{Path: RootModulePath}
   145  	{
   146  		tf := &ConfigTransformer{Module: mod}
   147  		if err := tf.Transform(&g); err != nil {
   148  			t.Fatalf("err: %s", err)
   149  		}
   150  	}
   151  
   152  	{
   153  		tf := &DestroyTransformer{}
   154  		if err := tf.Transform(&g); err != nil {
   155  			t.Fatalf("err: %s", err)
   156  		}
   157  	}
   158  
   159  	{
   160  		tf := &PruneDestroyTransformer{Diff: diff}
   161  		if err := tf.Transform(&g); err != nil {
   162  			t.Fatalf("err: %s", err)
   163  		}
   164  	}
   165  
   166  	actual := strings.TrimSpace(g.String())
   167  	expected := strings.TrimSpace(testTransformPruneDestroyBasicDiffStr)
   168  	if actual != expected {
   169  		t.Fatalf("bad:\n\n%s", actual)
   170  	}
   171  }
   172  
   173  func TestPruneDestroyTransformer_count(t *testing.T) {
   174  	mod := testModule(t, "transform-destroy-prune-count")
   175  
   176  	diff := &Diff{}
   177  
   178  	g := Graph{Path: RootModulePath}
   179  	{
   180  		tf := &ConfigTransformer{Module: mod}
   181  		if err := tf.Transform(&g); err != nil {
   182  			t.Fatalf("err: %s", err)
   183  		}
   184  	}
   185  
   186  	{
   187  		tf := &DestroyTransformer{}
   188  		if err := tf.Transform(&g); err != nil {
   189  			t.Fatalf("err: %s", err)
   190  		}
   191  	}
   192  
   193  	{
   194  		tf := &PruneDestroyTransformer{Diff: diff}
   195  		if err := tf.Transform(&g); err != nil {
   196  			t.Fatalf("err: %s", err)
   197  		}
   198  	}
   199  
   200  	actual := strings.TrimSpace(g.String())
   201  	expected := strings.TrimSpace(testTransformPruneDestroyCountStr)
   202  	if actual != expected {
   203  		t.Fatalf("bad:\n\n%s", actual)
   204  	}
   205  }
   206  
   207  func TestPruneDestroyTransformer_countDec(t *testing.T) {
   208  	mod := testModule(t, "transform-destroy-basic")
   209  
   210  	diff := &Diff{}
   211  	state := &State{
   212  		Modules: []*ModuleState{
   213  			&ModuleState{
   214  				Path: RootModulePath,
   215  				Resources: map[string]*ResourceState{
   216  					"aws_instance.bar.1": &ResourceState{
   217  						Primary: &InstanceState{},
   218  					},
   219  					"aws_instance.bar.2": &ResourceState{
   220  						Primary: &InstanceState{},
   221  					},
   222  				},
   223  			},
   224  		},
   225  	}
   226  
   227  	g := Graph{Path: RootModulePath}
   228  	{
   229  		tf := &ConfigTransformer{Module: mod}
   230  		if err := tf.Transform(&g); err != nil {
   231  			t.Fatalf("err: %s", err)
   232  		}
   233  	}
   234  
   235  	{
   236  		tf := &DestroyTransformer{}
   237  		if err := tf.Transform(&g); err != nil {
   238  			t.Fatalf("err: %s", err)
   239  		}
   240  	}
   241  
   242  	{
   243  		tf := &PruneDestroyTransformer{Diff: diff, State: state}
   244  		if err := tf.Transform(&g); err != nil {
   245  			t.Fatalf("err: %s", err)
   246  		}
   247  	}
   248  
   249  	actual := strings.TrimSpace(g.String())
   250  	expected := strings.TrimSpace(testTransformPruneDestroyCountDecStr)
   251  	if actual != expected {
   252  		t.Fatalf("bad:\n\n%s", actual)
   253  	}
   254  }
   255  
   256  func TestPruneDestroyTransformer_countState(t *testing.T) {
   257  	mod := testModule(t, "transform-destroy-basic")
   258  
   259  	diff := &Diff{}
   260  	state := &State{
   261  		Modules: []*ModuleState{
   262  			&ModuleState{
   263  				Path: RootModulePath,
   264  				Resources: map[string]*ResourceState{
   265  					"aws_instance.bar": &ResourceState{
   266  						Primary: &InstanceState{},
   267  					},
   268  				},
   269  			},
   270  		},
   271  	}
   272  
   273  	g := Graph{Path: RootModulePath}
   274  	{
   275  		tf := &ConfigTransformer{Module: mod}
   276  		if err := tf.Transform(&g); err != nil {
   277  			t.Fatalf("err: %s", err)
   278  		}
   279  	}
   280  
   281  	{
   282  		tf := &DestroyTransformer{}
   283  		if err := tf.Transform(&g); err != nil {
   284  			t.Fatalf("err: %s", err)
   285  		}
   286  	}
   287  
   288  	{
   289  		tf := &PruneDestroyTransformer{Diff: diff, State: state}
   290  		if err := tf.Transform(&g); err != nil {
   291  			t.Fatalf("err: %s", err)
   292  		}
   293  	}
   294  
   295  	actual := strings.TrimSpace(g.String())
   296  	expected := strings.TrimSpace(testTransformPruneDestroyCountStateStr)
   297  	if actual != expected {
   298  		t.Fatalf("bad:\n\n%s", actual)
   299  	}
   300  }
   301  
   302  const testTransformDestroyBasicStr = `
   303  aws_instance.bar
   304    aws_instance.bar (destroy tainted)
   305    aws_instance.bar (destroy)
   306    aws_instance.foo
   307  aws_instance.bar (destroy tainted)
   308  aws_instance.bar (destroy)
   309  aws_instance.foo
   310    aws_instance.foo (destroy tainted)
   311    aws_instance.foo (destroy)
   312  aws_instance.foo (destroy tainted)
   313    aws_instance.bar (destroy tainted)
   314  aws_instance.foo (destroy)
   315    aws_instance.bar (destroy)
   316  `
   317  
   318  const testTransformPruneDestroyBasicStr = `
   319  aws_instance.bar
   320    aws_instance.bar (destroy tainted)
   321    aws_instance.foo
   322  aws_instance.bar (destroy tainted)
   323  aws_instance.foo
   324    aws_instance.foo (destroy tainted)
   325  aws_instance.foo (destroy tainted)
   326    aws_instance.bar (destroy tainted)
   327  `
   328  
   329  const testTransformPruneDestroyBasicDiffStr = `
   330  aws_instance.bar
   331    aws_instance.bar (destroy tainted)
   332    aws_instance.bar (destroy)
   333    aws_instance.foo
   334  aws_instance.bar (destroy tainted)
   335  aws_instance.bar (destroy)
   336  aws_instance.foo
   337    aws_instance.foo (destroy tainted)
   338  aws_instance.foo (destroy tainted)
   339    aws_instance.bar (destroy tainted)
   340  `
   341  
   342  const testTransformPruneDestroyCountStr = `
   343  aws_instance.bar
   344    aws_instance.bar (destroy tainted)
   345    aws_instance.bar (destroy)
   346    aws_instance.foo
   347  aws_instance.bar (destroy tainted)
   348  aws_instance.bar (destroy)
   349  aws_instance.foo
   350    aws_instance.foo (destroy tainted)
   351  aws_instance.foo (destroy tainted)
   352    aws_instance.bar (destroy tainted)
   353  `
   354  
   355  const testTransformPruneDestroyCountDecStr = `
   356  aws_instance.bar
   357    aws_instance.bar (destroy tainted)
   358    aws_instance.bar (destroy)
   359    aws_instance.foo
   360  aws_instance.bar (destroy tainted)
   361  aws_instance.bar (destroy)
   362  aws_instance.foo
   363    aws_instance.foo (destroy tainted)
   364  aws_instance.foo (destroy tainted)
   365    aws_instance.bar (destroy tainted)
   366  `
   367  
   368  const testTransformPruneDestroyCountStateStr = `
   369  aws_instance.bar
   370    aws_instance.bar (destroy tainted)
   371    aws_instance.foo
   372  aws_instance.bar (destroy tainted)
   373  aws_instance.foo
   374    aws_instance.foo (destroy tainted)
   375  aws_instance.foo (destroy tainted)
   376    aws_instance.bar (destroy tainted)
   377  `
   378  
   379  const testTransformCreateBeforeDestroyBasicStr = `
   380  aws_instance.web
   381    aws_instance.web (destroy tainted)
   382  aws_instance.web (destroy tainted)
   383    aws_load_balancer.lb (destroy tainted)
   384  aws_instance.web (destroy)
   385    aws_instance.web
   386    aws_load_balancer.lb
   387    aws_load_balancer.lb (destroy)
   388  aws_load_balancer.lb
   389    aws_instance.web
   390    aws_load_balancer.lb (destroy tainted)
   391    aws_load_balancer.lb (destroy)
   392  aws_load_balancer.lb (destroy tainted)
   393  aws_load_balancer.lb (destroy)
   394  `
   395  
   396  const testTransformCreateBeforeDestroyTwiceStr = `
   397  aws_autoscale.bar
   398    aws_autoscale.bar (destroy tainted)
   399    aws_lc.foo
   400  aws_autoscale.bar (destroy tainted)
   401  aws_autoscale.bar (destroy)
   402    aws_autoscale.bar
   403  aws_lc.foo
   404    aws_lc.foo (destroy tainted)
   405  aws_lc.foo (destroy tainted)
   406    aws_autoscale.bar (destroy tainted)
   407  aws_lc.foo (destroy)
   408    aws_autoscale.bar
   409    aws_autoscale.bar (destroy)
   410    aws_lc.foo
   411  `