github.com/inge4pres/terraform@v0.7.5-0.20160930053151-bd083f84f376/command/import_test.go (about) 1 package command 2 3 import ( 4 "testing" 5 6 "github.com/hashicorp/terraform/terraform" 7 "github.com/mitchellh/cli" 8 ) 9 10 func TestImport(t *testing.T) { 11 statePath := testTempFile(t) 12 13 p := testProvider() 14 ui := new(cli.MockUi) 15 c := &ImportCommand{ 16 Meta: Meta{ 17 ContextOpts: testCtxConfig(p), 18 Ui: ui, 19 }, 20 } 21 22 p.ImportStateFn = nil 23 p.ImportStateReturn = []*terraform.InstanceState{ 24 &terraform.InstanceState{ 25 ID: "yay", 26 Ephemeral: terraform.EphemeralState{ 27 Type: "test_instance", 28 }, 29 }, 30 } 31 32 args := []string{ 33 "-state", statePath, 34 "test_instance.foo", 35 "bar", 36 } 37 if code := c.Run(args); code != 0 { 38 t.Fatalf("bad: %d\n\n%s", code, ui.ErrorWriter.String()) 39 } 40 41 if !p.ImportStateCalled { 42 t.Fatal("ImportState should be called") 43 } 44 45 testStateOutput(t, statePath, testImportStr) 46 } 47 48 /* 49 func TestRefresh_badState(t *testing.T) { 50 p := testProvider() 51 ui := new(cli.MockUi) 52 c := &RefreshCommand{ 53 Meta: Meta{ 54 ContextOpts: testCtxConfig(p), 55 Ui: ui, 56 }, 57 } 58 59 args := []string{ 60 "-state", "i-should-not-exist-ever", 61 testFixturePath("refresh"), 62 } 63 if code := c.Run(args); code != 1 { 64 t.Fatalf("bad: %d\n\n%s", code, ui.ErrorWriter.String()) 65 } 66 } 67 68 func TestRefresh_cwd(t *testing.T) { 69 cwd, err := os.Getwd() 70 if err != nil { 71 t.Fatalf("err: %s", err) 72 } 73 if err := os.Chdir(testFixturePath("refresh")); err != nil { 74 t.Fatalf("err: %s", err) 75 } 76 defer os.Chdir(cwd) 77 78 state := testState() 79 statePath := testStateFile(t, state) 80 81 p := testProvider() 82 ui := new(cli.MockUi) 83 c := &RefreshCommand{ 84 Meta: Meta{ 85 ContextOpts: testCtxConfig(p), 86 Ui: ui, 87 }, 88 } 89 90 p.RefreshFn = nil 91 p.RefreshReturn = &terraform.InstanceState{ID: "yes"} 92 93 args := []string{ 94 "-state", statePath, 95 } 96 if code := c.Run(args); code != 0 { 97 t.Fatalf("bad: %d\n\n%s", code, ui.ErrorWriter.String()) 98 } 99 100 if !p.RefreshCalled { 101 t.Fatal("refresh should be called") 102 } 103 104 f, err := os.Open(statePath) 105 if err != nil { 106 t.Fatalf("err: %s", err) 107 } 108 109 newState, err := terraform.ReadState(f) 110 f.Close() 111 if err != nil { 112 t.Fatalf("err: %s", err) 113 } 114 115 actual := strings.TrimSpace(newState.String()) 116 expected := strings.TrimSpace(testRefreshCwdStr) 117 if actual != expected { 118 t.Fatalf("bad:\n\n%s", actual) 119 } 120 } 121 122 func TestRefresh_defaultState(t *testing.T) { 123 originalState := testState() 124 125 // Write the state file in a temporary directory with the 126 // default filename. 127 td, err := ioutil.TempDir("", "tf") 128 if err != nil { 129 t.Fatalf("err: %s", err) 130 } 131 statePath := filepath.Join(td, DefaultStateFilename) 132 133 f, err := os.Create(statePath) 134 if err != nil { 135 t.Fatalf("err: %s", err) 136 } 137 err = terraform.WriteState(originalState, f) 138 f.Close() 139 if err != nil { 140 t.Fatalf("err: %s", err) 141 } 142 143 // Change to that directory 144 cwd, err := os.Getwd() 145 if err != nil { 146 t.Fatalf("err: %s", err) 147 } 148 if err := os.Chdir(filepath.Dir(statePath)); err != nil { 149 t.Fatalf("err: %s", err) 150 } 151 defer os.Chdir(cwd) 152 153 p := testProvider() 154 ui := new(cli.MockUi) 155 c := &RefreshCommand{ 156 Meta: Meta{ 157 ContextOpts: testCtxConfig(p), 158 Ui: ui, 159 }, 160 } 161 162 p.RefreshFn = nil 163 p.RefreshReturn = &terraform.InstanceState{ID: "yes"} 164 165 args := []string{ 166 testFixturePath("refresh"), 167 } 168 if code := c.Run(args); code != 0 { 169 t.Fatalf("bad: %d\n\n%s", code, ui.ErrorWriter.String()) 170 } 171 172 if !p.RefreshCalled { 173 t.Fatal("refresh should be called") 174 } 175 176 f, err = os.Open(statePath) 177 if err != nil { 178 t.Fatalf("err: %s", err) 179 } 180 181 newState, err := terraform.ReadState(f) 182 f.Close() 183 if err != nil { 184 t.Fatalf("err: %s", err) 185 } 186 187 actual := newState.RootModule().Resources["test_instance.foo"].Primary 188 expected := p.RefreshReturn 189 if !reflect.DeepEqual(actual, expected) { 190 t.Fatalf("bad: %#v", actual) 191 } 192 193 f, err = os.Open(statePath + DefaultBackupExtension) 194 if err != nil { 195 t.Fatalf("err: %s", err) 196 } 197 198 backupState, err := terraform.ReadState(f) 199 f.Close() 200 if err != nil { 201 t.Fatalf("err: %s", err) 202 } 203 204 actual = backupState.RootModule().Resources["test_instance.foo"].Primary 205 expected = originalState.RootModule().Resources["test_instance.foo"].Primary 206 if !reflect.DeepEqual(actual, expected) { 207 t.Fatalf("bad: %#v", actual) 208 } 209 } 210 211 func TestRefresh_futureState(t *testing.T) { 212 cwd, err := os.Getwd() 213 if err != nil { 214 t.Fatalf("err: %s", err) 215 } 216 if err := os.Chdir(testFixturePath("refresh")); err != nil { 217 t.Fatalf("err: %s", err) 218 } 219 defer os.Chdir(cwd) 220 221 state := testState() 222 state.TFVersion = "99.99.99" 223 statePath := testStateFile(t, state) 224 225 p := testProvider() 226 ui := new(cli.MockUi) 227 c := &RefreshCommand{ 228 Meta: Meta{ 229 ContextOpts: testCtxConfig(p), 230 Ui: ui, 231 }, 232 } 233 234 args := []string{ 235 "-state", statePath, 236 } 237 if code := c.Run(args); code == 0 { 238 t.Fatal("should fail") 239 } 240 241 if p.RefreshCalled { 242 t.Fatal("refresh should not be called") 243 } 244 245 f, err := os.Open(statePath) 246 if err != nil { 247 t.Fatalf("err: %s", err) 248 } 249 250 newState, err := terraform.ReadState(f) 251 f.Close() 252 if err != nil { 253 t.Fatalf("err: %s", err) 254 } 255 256 actual := strings.TrimSpace(newState.String()) 257 expected := strings.TrimSpace(state.String()) 258 if actual != expected { 259 t.Fatalf("bad:\n\n%s", actual) 260 } 261 } 262 263 func TestRefresh_pastState(t *testing.T) { 264 state := testState() 265 state.TFVersion = "0.1.0" 266 statePath := testStateFile(t, state) 267 268 p := testProvider() 269 ui := new(cli.MockUi) 270 c := &RefreshCommand{ 271 Meta: Meta{ 272 ContextOpts: testCtxConfig(p), 273 Ui: ui, 274 }, 275 } 276 277 p.RefreshFn = nil 278 p.RefreshReturn = &terraform.InstanceState{ID: "yes"} 279 280 args := []string{ 281 "-state", statePath, 282 testFixturePath("refresh"), 283 } 284 if code := c.Run(args); code != 0 { 285 t.Fatalf("bad: %d\n\n%s", code, ui.ErrorWriter.String()) 286 } 287 288 if !p.RefreshCalled { 289 t.Fatal("refresh should be called") 290 } 291 292 f, err := os.Open(statePath) 293 if err != nil { 294 t.Fatalf("err: %s", err) 295 } 296 297 newState, err := terraform.ReadState(f) 298 f.Close() 299 if err != nil { 300 t.Fatalf("err: %s", err) 301 } 302 303 actual := strings.TrimSpace(newState.String()) 304 expected := strings.TrimSpace(testRefreshStr) 305 if actual != expected { 306 t.Fatalf("bad:\n\n%s", actual) 307 } 308 309 if newState.TFVersion != terraform.Version { 310 t.Fatalf("bad:\n\n%s", newState.TFVersion) 311 } 312 } 313 314 func TestRefresh_outPath(t *testing.T) { 315 state := testState() 316 statePath := testStateFile(t, state) 317 318 // Output path 319 outf, err := ioutil.TempFile("", "tf") 320 if err != nil { 321 t.Fatalf("err: %s", err) 322 } 323 outPath := outf.Name() 324 outf.Close() 325 os.Remove(outPath) 326 327 p := testProvider() 328 ui := new(cli.MockUi) 329 c := &RefreshCommand{ 330 Meta: Meta{ 331 ContextOpts: testCtxConfig(p), 332 Ui: ui, 333 }, 334 } 335 336 p.RefreshFn = nil 337 p.RefreshReturn = &terraform.InstanceState{ID: "yes"} 338 339 args := []string{ 340 "-state", statePath, 341 "-state-out", outPath, 342 testFixturePath("refresh"), 343 } 344 if code := c.Run(args); code != 0 { 345 t.Fatalf("bad: %d\n\n%s", code, ui.ErrorWriter.String()) 346 } 347 348 f, err := os.Open(statePath) 349 if err != nil { 350 t.Fatalf("err: %s", err) 351 } 352 353 newState, err := terraform.ReadState(f) 354 f.Close() 355 if err != nil { 356 t.Fatalf("err: %s", err) 357 } 358 359 if !reflect.DeepEqual(newState, state) { 360 t.Fatalf("bad: %#v", newState) 361 } 362 363 f, err = os.Open(outPath) 364 if err != nil { 365 t.Fatalf("err: %s", err) 366 } 367 368 newState, err = terraform.ReadState(f) 369 f.Close() 370 if err != nil { 371 t.Fatalf("err: %s", err) 372 } 373 374 actual := newState.RootModule().Resources["test_instance.foo"].Primary 375 expected := p.RefreshReturn 376 if !reflect.DeepEqual(actual, expected) { 377 t.Fatalf("bad: %#v", actual) 378 } 379 380 f, err = os.Open(outPath + DefaultBackupExtension) 381 if err != nil { 382 t.Fatalf("err: %s", err) 383 } 384 385 backupState, err := terraform.ReadState(f) 386 f.Close() 387 if err != nil { 388 t.Fatalf("err: %s", err) 389 } 390 391 actualStr := strings.TrimSpace(backupState.String()) 392 expectedStr := strings.TrimSpace(state.String()) 393 if actualStr != expectedStr { 394 t.Fatalf("bad:\n\n%s\n\n%s", actualStr, expectedStr) 395 } 396 } 397 398 func TestRefresh_var(t *testing.T) { 399 state := testState() 400 statePath := testStateFile(t, state) 401 402 p := testProvider() 403 ui := new(cli.MockUi) 404 c := &RefreshCommand{ 405 Meta: Meta{ 406 ContextOpts: testCtxConfig(p), 407 Ui: ui, 408 }, 409 } 410 411 args := []string{ 412 "-var", "foo=bar", 413 "-state", statePath, 414 testFixturePath("refresh-var"), 415 } 416 if code := c.Run(args); code != 0 { 417 t.Fatalf("bad: %d\n\n%s", code, ui.ErrorWriter.String()) 418 } 419 420 if !p.ConfigureCalled { 421 t.Fatal("configure should be called") 422 } 423 if p.ConfigureConfig.Config["value"].(string) != "bar" { 424 t.Fatalf("bad: %#v", p.ConfigureConfig.Config) 425 } 426 } 427 428 func TestRefresh_varFile(t *testing.T) { 429 state := testState() 430 statePath := testStateFile(t, state) 431 432 p := testProvider() 433 ui := new(cli.MockUi) 434 c := &RefreshCommand{ 435 Meta: Meta{ 436 ContextOpts: testCtxConfig(p), 437 Ui: ui, 438 }, 439 } 440 441 varFilePath := testTempFile(t) 442 if err := ioutil.WriteFile(varFilePath, []byte(refreshVarFile), 0644); err != nil { 443 t.Fatalf("err: %s", err) 444 } 445 446 args := []string{ 447 "-var-file", varFilePath, 448 "-state", statePath, 449 testFixturePath("refresh-var"), 450 } 451 if code := c.Run(args); code != 0 { 452 t.Fatalf("bad: %d\n\n%s", code, ui.ErrorWriter.String()) 453 } 454 455 if !p.ConfigureCalled { 456 t.Fatal("configure should be called") 457 } 458 if p.ConfigureConfig.Config["value"].(string) != "bar" { 459 t.Fatalf("bad: %#v", p.ConfigureConfig.Config) 460 } 461 } 462 463 func TestRefresh_varFileDefault(t *testing.T) { 464 state := testState() 465 statePath := testStateFile(t, state) 466 467 p := testProvider() 468 ui := new(cli.MockUi) 469 c := &RefreshCommand{ 470 Meta: Meta{ 471 ContextOpts: testCtxConfig(p), 472 Ui: ui, 473 }, 474 } 475 476 varFileDir := testTempDir(t) 477 varFilePath := filepath.Join(varFileDir, "terraform.tfvars") 478 if err := ioutil.WriteFile(varFilePath, []byte(refreshVarFile), 0644); err != nil { 479 t.Fatalf("err: %s", err) 480 } 481 482 cwd, err := os.Getwd() 483 if err != nil { 484 t.Fatalf("err: %s", err) 485 } 486 if err := os.Chdir(varFileDir); err != nil { 487 t.Fatalf("err: %s", err) 488 } 489 defer os.Chdir(cwd) 490 491 args := []string{ 492 "-state", statePath, 493 testFixturePath("refresh-var"), 494 } 495 if code := c.Run(args); code != 0 { 496 t.Fatalf("bad: %d\n\n%s", code, ui.ErrorWriter.String()) 497 } 498 499 if !p.ConfigureCalled { 500 t.Fatal("configure should be called") 501 } 502 if p.ConfigureConfig.Config["value"].(string) != "bar" { 503 t.Fatalf("bad: %#v", p.ConfigureConfig.Config) 504 } 505 } 506 507 func TestRefresh_varsUnset(t *testing.T) { 508 // Disable test mode so input would be asked 509 test = false 510 defer func() { test = true }() 511 512 defaultInputReader = bytes.NewBufferString("bar\n") 513 514 state := testState() 515 statePath := testStateFile(t, state) 516 517 p := testProvider() 518 ui := new(cli.MockUi) 519 c := &RefreshCommand{ 520 Meta: Meta{ 521 ContextOpts: testCtxConfig(p), 522 Ui: ui, 523 }, 524 } 525 526 args := []string{ 527 "-state", statePath, 528 testFixturePath("refresh-unset-var"), 529 } 530 if code := c.Run(args); code != 0 { 531 t.Fatalf("bad: %d\n\n%s", code, ui.ErrorWriter.String()) 532 } 533 } 534 535 func TestRefresh_backup(t *testing.T) { 536 state := testState() 537 statePath := testStateFile(t, state) 538 539 // Output path 540 outf, err := ioutil.TempFile("", "tf") 541 if err != nil { 542 t.Fatalf("err: %s", err) 543 } 544 outPath := outf.Name() 545 outf.Close() 546 os.Remove(outPath) 547 548 // Backup path 549 backupf, err := ioutil.TempFile("", "tf") 550 if err != nil { 551 t.Fatalf("err: %s", err) 552 } 553 backupPath := backupf.Name() 554 backupf.Close() 555 os.Remove(backupPath) 556 557 p := testProvider() 558 ui := new(cli.MockUi) 559 c := &RefreshCommand{ 560 Meta: Meta{ 561 ContextOpts: testCtxConfig(p), 562 Ui: ui, 563 }, 564 } 565 566 p.RefreshFn = nil 567 p.RefreshReturn = &terraform.InstanceState{ID: "yes"} 568 569 args := []string{ 570 "-state", statePath, 571 "-state-out", outPath, 572 "-backup", backupPath, 573 testFixturePath("refresh"), 574 } 575 if code := c.Run(args); code != 0 { 576 t.Fatalf("bad: %d\n\n%s", code, ui.ErrorWriter.String()) 577 } 578 579 f, err := os.Open(statePath) 580 if err != nil { 581 t.Fatalf("err: %s", err) 582 } 583 584 newState, err := terraform.ReadState(f) 585 f.Close() 586 if err != nil { 587 t.Fatalf("err: %s", err) 588 } 589 590 if !reflect.DeepEqual(newState, state) { 591 t.Fatalf("bad: %#v", newState) 592 } 593 594 f, err = os.Open(outPath) 595 if err != nil { 596 t.Fatalf("err: %s", err) 597 } 598 599 newState, err = terraform.ReadState(f) 600 f.Close() 601 if err != nil { 602 t.Fatalf("err: %s", err) 603 } 604 605 actual := newState.RootModule().Resources["test_instance.foo"].Primary 606 expected := p.RefreshReturn 607 if !reflect.DeepEqual(actual, expected) { 608 t.Fatalf("bad: %#v", actual) 609 } 610 611 f, err = os.Open(backupPath) 612 if err != nil { 613 t.Fatalf("err: %s", err) 614 } 615 616 backupState, err := terraform.ReadState(f) 617 f.Close() 618 if err != nil { 619 t.Fatalf("err: %s", err) 620 } 621 622 actualStr := strings.TrimSpace(backupState.String()) 623 expectedStr := strings.TrimSpace(state.String()) 624 if actualStr != expectedStr { 625 t.Fatalf("bad:\n\n%s\n\n%s", actualStr, expectedStr) 626 } 627 } 628 629 func TestRefresh_disableBackup(t *testing.T) { 630 state := testState() 631 statePath := testStateFile(t, state) 632 633 // Output path 634 outf, err := ioutil.TempFile("", "tf") 635 if err != nil { 636 t.Fatalf("err: %s", err) 637 } 638 outPath := outf.Name() 639 outf.Close() 640 os.Remove(outPath) 641 642 p := testProvider() 643 ui := new(cli.MockUi) 644 c := &RefreshCommand{ 645 Meta: Meta{ 646 ContextOpts: testCtxConfig(p), 647 Ui: ui, 648 }, 649 } 650 651 p.RefreshFn = nil 652 p.RefreshReturn = &terraform.InstanceState{ID: "yes"} 653 654 args := []string{ 655 "-state", statePath, 656 "-state-out", outPath, 657 "-backup", "-", 658 testFixturePath("refresh"), 659 } 660 if code := c.Run(args); code != 0 { 661 t.Fatalf("bad: %d\n\n%s", code, ui.ErrorWriter.String()) 662 } 663 664 f, err := os.Open(statePath) 665 if err != nil { 666 t.Fatalf("err: %s", err) 667 } 668 669 newState, err := terraform.ReadState(f) 670 f.Close() 671 if err != nil { 672 t.Fatalf("err: %s", err) 673 } 674 675 if !reflect.DeepEqual(newState, state) { 676 t.Fatalf("bad: %#v", newState) 677 } 678 679 f, err = os.Open(outPath) 680 if err != nil { 681 t.Fatalf("err: %s", err) 682 } 683 684 newState, err = terraform.ReadState(f) 685 f.Close() 686 if err != nil { 687 t.Fatalf("err: %s", err) 688 } 689 690 actual := newState.RootModule().Resources["test_instance.foo"].Primary 691 expected := p.RefreshReturn 692 if !reflect.DeepEqual(actual, expected) { 693 t.Fatalf("bad: %#v", actual) 694 } 695 696 // Ensure there is no backup 697 _, err = os.Stat(outPath + DefaultBackupExtension) 698 if err == nil || !os.IsNotExist(err) { 699 t.Fatalf("backup should not exist") 700 } 701 } 702 703 func TestRefresh_displaysOutputs(t *testing.T) { 704 state := testState() 705 statePath := testStateFile(t, state) 706 707 p := testProvider() 708 ui := new(cli.MockUi) 709 c := &RefreshCommand{ 710 Meta: Meta{ 711 ContextOpts: testCtxConfig(p), 712 Ui: ui, 713 }, 714 } 715 716 args := []string{ 717 "-state", statePath, 718 testFixturePath("refresh-output"), 719 } 720 if code := c.Run(args); code != 0 { 721 t.Fatalf("bad: %d\n\n%s", code, ui.ErrorWriter.String()) 722 } 723 724 // Test that outputs were displayed 725 outputValue := "foo.example.com" 726 actual := ui.OutputWriter.String() 727 if !strings.Contains(actual, outputValue) { 728 t.Fatalf("Expected:\n%s\n\nTo include: %q", actual, outputValue) 729 } 730 } 731 */ 732 733 const testImportStr = ` 734 test_instance.foo: 735 ID = yay 736 provider = test 737 `