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 `